initial commit

node_modules/.bin/semver

+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../semver/bin/semver.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/../semver/bin/semver.js" "$@"
+  ret=$?
+fi
+exit $ret

node_modules/.bin/semver.cmd

+@ECHO off
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+"%_prog%"  "%dp0%\..\semver\bin\semver.js" %*
+ENDLOCAL
+EXIT /b %errorlevel%
+:find_dp0
+SET dp0=%~dp0
+EXIT /b

node_modules/.bin/semver.ps1

+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  & "$basedir/node$exe"  "$basedir/../semver/bin/semver.js" $args
+  $ret=$LASTEXITCODE
+} else {
+  & "node$exe"  "$basedir/../semver/bin/semver.js" $args
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/uuid

+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../uuid/dist/bin/uuid" "$@"
+  ret=$?
+else 
+  node  "$basedir/../uuid/dist/bin/uuid" "$@"
+  ret=$?
+fi
+exit $ret

node_modules/.bin/uuid.cmd

+@ECHO off
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+"%_prog%"  "%dp0%\..\uuid\dist\bin\uuid" %*
+ENDLOCAL
+EXIT /b %errorlevel%
+:find_dp0
+SET dp0=%~dp0
+EXIT /b

node_modules/.bin/uuid.ps1

+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  & "$basedir/node$exe"  "$basedir/../uuid/dist/bin/uuid" $args
+  $ret=$LASTEXITCODE
+} else {
+  & "node$exe"  "$basedir/../uuid/dist/bin/uuid" $args
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/@types/debug/LICENSE

+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

node_modules/@types/debug/README.md

+# Installation
+> `npm install --save @types/debug`
+
+# Summary
+This package contains type definitions for debug (https://github.com/visionmedia/debug).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/debug.
+## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/debug/index.d.ts)
+````ts
+// Type definitions for debug 4.1
+// Project: https://github.com/visionmedia/debug
+// Definitions by: Seon-Wook Park <https://github.com/swook>
+//                 Gal Talmor <https://github.com/galtalmor>
+//                 John McLaughlin <https://github.com/zamb3zi>
+//                 Brasten Sager <https://github.com/brasten>
+//                 Nicolas Penin <https://github.com/npenin>
+//                 Kristian Brünn <https://github.com/kristianmitk>
+//                 Caleb Gregory <https://github.com/calebgregory>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare var debug: debug.Debug & { debug: debug.Debug; default: debug.Debug };
+
+export = debug;
+export as namespace debug;
+
+declare namespace debug {
+    interface Debug {
+        (namespace: string): Debugger;
+        coerce: (val: any) => any;
+        disable: () => string;
+        enable: (namespaces: string) => void;
+        enabled: (namespaces: string) => boolean;
+        formatArgs: (this: Debugger, args: any[]) => void;
+        log: (...args: any[]) => any;
+        selectColor: (namespace: string) => string | number;
+        humanize: typeof import('ms');
+
+        names: RegExp[];
+        skips: RegExp[];
+
+        formatters: Formatters;
+    }
+
+    type IDebug = Debug;
+
+    interface Formatters {
+        [formatter: string]: (v: any) => string;
+    }
+
+    type IDebugger = Debugger;
+
+    interface Debugger {
+        (formatter: any, ...args: any[]): void;
+
+        color: string;
+        diff: number;
+        enabled: boolean;
+        log: (...args: any[]) => any;
+        namespace: string;
+        destroy: () => boolean;
+        extend: (namespace: string, delimiter?: string) => Debugger;
+    }
+}
+
+````
+
+### Additional Details
+ * Last updated: Sat, 24 Jul 2021 08:01:14 GMT
+ * Dependencies: [@types/ms](https://npmjs.com/package/@types/ms)
+ * Global values: `debug`
+
+# Credits
+These definitions were written by [Seon-Wook Park](https://github.com/swook), [Gal Talmor](https://github.com/galtalmor), [John McLaughlin](https://github.com/zamb3zi), [Brasten Sager](https://github.com/brasten), [Nicolas Penin](https://github.com/npenin), [Kristian Brünn](https://github.com/kristianmitk), and [Caleb Gregory](https://github.com/calebgregory).

node_modules/@types/debug/index.d.ts

+// Type definitions for debug 4.1
+// Project: https://github.com/visionmedia/debug
+// Definitions by: Seon-Wook Park <https://github.com/swook>
+//                 Gal Talmor <https://github.com/galtalmor>
+//                 John McLaughlin <https://github.com/zamb3zi>
+//                 Brasten Sager <https://github.com/brasten>
+//                 Nicolas Penin <https://github.com/npenin>
+//                 Kristian Brünn <https://github.com/kristianmitk>
+//                 Caleb Gregory <https://github.com/calebgregory>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare var debug: debug.Debug & { debug: debug.Debug; default: debug.Debug };
+
+export = debug;
+export as namespace debug;
+
+declare namespace debug {
+    interface Debug {
+        (namespace: string): Debugger;
+        coerce: (val: any) => any;
+        disable: () => string;
+        enable: (namespaces: string) => void;
+        enabled: (namespaces: string) => boolean;
+        formatArgs: (this: Debugger, args: any[]) => void;
+        log: (...args: any[]) => any;
+        selectColor: (namespace: string) => string | number;
+        humanize: typeof import('ms');
+
+        names: RegExp[];
+        skips: RegExp[];
+
+        formatters: Formatters;
+    }
+
+    type IDebug = Debug;
+
+    interface Formatters {
+        [formatter: string]: (v: any) => string;
+    }
+
+    type IDebugger = Debugger;
+
+    interface Debugger {
+        (formatter: any, ...args: any[]): void;
+
+        color: string;
+        diff: number;
+        enabled: boolean;
+        log: (...args: any[]) => any;
+        namespace: string;
+        destroy: () => boolean;
+        extend: (namespace: string, delimiter?: string) => Debugger;
+    }
+}

node_modules/@types/debug/package.json

+{
+  "_from": "@types/debug@^4.1.7",
+  "_id": "@types/debug@4.1.7",
+  "_inBundle": false,
+  "_integrity": "sha512-9AonUzyTjXXhEOa0DnqpzZi6VHlqKMswga9EXjpXnnqxwLtdvPPtlO8evrI5D9S6asFRCQ6v+wpiUKbw+vKqyg==",
+  "_location": "/@types/debug",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/debug@^4.1.7",
+    "name": "@types/debug",
+    "escapedName": "@types%2fdebug",
+    "scope": "@types",
+    "rawSpec": "^4.1.7",
+    "saveSpec": null,
+    "fetchSpec": "^4.1.7"
+  },
+  "_requiredBy": [
+    "/sequelize"
+  ],
+  "_resolved": "https://registry.npmmirror.com/@types/debug/-/debug-4.1.7.tgz",
+  "_shasum": "7cc0ea761509124709b8b2d1090d8f6c17aadb82",
+  "_spec": "@types/debug@^4.1.7",
+  "_where": "D:\\koaAndVueProjectDemo\\node_modules\\sequelize",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Seon-Wook Park",
+      "url": "https://github.com/swook"
+    },
+    {
+      "name": "Gal Talmor",
+      "url": "https://github.com/galtalmor"
+    },
+    {
+      "name": "John McLaughlin",
+      "url": "https://github.com/zamb3zi"
+    },
+    {
+      "name": "Brasten Sager",
+      "url": "https://github.com/brasten"
+    },
+    {
+      "name": "Nicolas Penin",
+      "url": "https://github.com/npenin"
+    },
+    {
+      "name": "Kristian Brünn",
+      "url": "https://github.com/kristianmitk"
+    },
+    {
+      "name": "Caleb Gregory",
+      "url": "https://github.com/calebgregory"
+    }
+  ],
+  "dependencies": {
+    "@types/ms": "*"
+  },
+  "deprecated": false,
+  "description": "TypeScript definitions for debug",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/debug",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/debug",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/debug"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.6",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "b83b27a0dee1329b5308b30bc0a4193efda8f025b3f5d9301130acb5be89a5b7",
+  "version": "4.1.7"
+}

node_modules/@types/formidable/Formidable.d.ts

+/**
+ * Docs: https://github.com/node-formidable/formidable/blob/master/src/Formidable.js#L45
+ */
+
+import { IncomingMessage } from 'http';
+import { EventEmitter } from 'stream';
+import { EmitData, EventData, Fields, File, Files, Options, Part, PluginFunction, DefaultOptions } from './';
+
+declare class IncomingForm extends EventEmitter {
+    static readonly DEFAULT_OPTIONS: DefaultOptions;
+    constructor(options?: Partial<Options>);
+
+    /**
+     * Parses an incoming Node.js request containing form data. If callback is provided, all fields
+     * and files are collected and passed to the callback.
+     *
+     * @link https://github.com/node-formidable/formidable#parserequest-callback
+     */
+    parse(request: IncomingMessage, callback?: (err: any, fields: Fields, files: Files) => void): void;
+
+    once(eventName: 'end', listener: () => void): this;
+    once(eventName: 'error', listener: (err: any) => void): this;
+
+    on(eventName: 'data', listener: (data: EventData) => void): this;
+    on(eventName: 'error', listener: (err: any) => void): this;
+    on(eventName: 'field', listener: (name: string, value: string) => void): this;
+    on(eventName: 'fileBegin' | 'file', listener: (formName: string, file: File) => void): this;
+    on(eventName: 'progress', listener: (bytesReceived: number, bytesExpected: number) => void): this;
+    on(eventName: string, listener: () => void): this;
+
+    emit(eventName: 'data', data: EmitData): boolean;
+
+    /**
+     * A method that allows you to extend the Formidable library. By default we include 4 plugins,
+     * which essentially are adapters to plug the different built-in parsers.
+     *
+     * @link https://github.com/node-formidable/formidable#useplugin-plugin
+     */
+    use(plugin: PluginFunction): void;
+
+    /**
+     * If you want to use Formidable to only handle certain parts for you, you can do something
+     * similar. Or see #387 for inspiration, you can for example validate the mime-type.
+     *
+     * @link https://github.com/node-formidable/formidable#formonpart
+     */
+    onPart(part: Part): void;
+
+    _handlePart(part: Part): void;
+}
+
+export = IncomingForm;

node_modules/@types/formidable/FormidableError.d.ts

+declare class FormidableError extends Error {
+    internalCode: number;
+    httpCode?: number | undefined;
+    constructor(message: string, internalCode: number, httpCode?: number);
+}
+
+declare const errors: {
+    FormidableError: typeof FormidableError;
+} & Record<
+    | "missingPlugin"
+    | "pluginFunction"
+    | "aborted"
+    | "noParser"
+    | "uninitializedParser"
+    | "filenameNotString"
+    | "maxFieldsSizeExceeded"
+    | "maxFieldsExceeded"
+    | "smallerThanMinFileSize"
+    | "biggerThanMaxFileSize"
+    | "noEmptyFiles"
+    | "missingContentType"
+    | "malformedMultipart"
+    | "missingMultipartBoundary"
+    | "unknownTransferEncoding",
+    number
+>;
+
+export = errors;

node_modules/@types/formidable/LICENSE

+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

node_modules/@types/formidable/PersistentFile.d.ts

+import { EventEmitter } from 'events';
+import { File, FileJSON } from "./";
+
+declare class PersistentFile extends EventEmitter {
+    constructor(properties: File);
+    open(): void;
+    toJSON(): FileJSON;
+    toString(): string;
+    write(buffer: string, cb: () => void): void;
+    end(cb: () => void): void;
+    destroy(): void;
+}
+
+export = PersistentFile;

node_modules/@types/formidable/README.md

+# Installation
+> `npm install --save @types/formidable`
+
+# Summary
+This package contains type definitions for formidable (https://github.com/node-formidable/formidable).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/formidable.
+
+### Additional Details
+ * Last updated: Mon, 02 May 2022 15:31:38 GMT
+ * Dependencies: [@types/node](https://npmjs.com/package/@types/node)
+ * Global values: none
+
+# Credits
+These definitions were written by [Wim Looman](https://github.com/Nemo157), and [Martin Badin](https://github.com/martin-badin).

node_modules/@types/formidable/VolatileFile.d.ts

+import PersistentFile = require("./PersistentFile");
+
+declare const VolatileFile: typeof PersistentFile;
+
+export = VolatileFile;

node_modules/@types/formidable/index.d.ts

+// Type definitions for formidable 2.0
+// Project: https://github.com/node-formidable/formidable
+// Definitions by: Wim Looman <https://github.com/Nemo157>
+//                 Martin Badin <https://github.com/martin-badin>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="node" />
+
+import { Stream, Writable } from "stream";
+import Formidable = require("./Formidable");
+import parsers = require("./parsers/index");
+import PersistentFile = require("./PersistentFile");
+import VolatileFile = require("./VolatileFile");
+import errors = require("./FormidableError");
+
+declare namespace formidable {
+    type BufferEncoding =
+        | "ascii"
+        | "base64"
+        | "binary"
+        | "hex"
+        | "latin1"
+        | "ucs-2"
+        | "ucs2"
+        | "utf-8"
+        | "utf16le"
+        | "utf8";
+
+    type EventNames =
+        /**
+         * Emitted when the request was aborted by the user. Right now this can be due to a 'timeout' or
+         * 'close' event on the socket. After this event is emitted, an error event will follow. In the
+         * future there will be a separate 'timeout' event (needs a change in the node core).
+         *
+         * @link https://github.com/node-formidable/formidable#aborted
+         */
+        | "aborted"
+        /**
+         * Emitted when the entire request has been received, and all contained files have finished
+         * flushing to disk. This is a great place for you to send your response.
+         *
+         * @link https://github.com/node-formidable/formidable#end
+         */
+        | "end"
+        /**
+         * Emitted when there is an error processing the incoming form. A request that experiences an
+         * error is automatically paused, you will have to manually call request.resume() if you want the
+         * request to continue firing 'data' events.
+         *
+         * @link https://github.com/node-formidable/formidable#error
+         */
+        | "error"
+        /**
+         * Emitted whenever a field / value pair has been received.
+         *
+         * @link https://github.com/node-formidable/formidable#field
+         */
+        | "field"
+        /**
+         * Emitted whenever a field / file pair has been received. file is an instance of File.
+         *
+         * @link https://github.com/node-formidable/formidable#file-1
+         */
+        | "file"
+        /**
+         * Emitted whenever a new file is detected in the upload stream. Use this event if you want to
+         * stream the file to somewhere else while buffering the upload on the file system.
+         *
+         * @link https://github.com/node-formidable/formidable#filebegin
+         */
+        | "fileBegin"
+        | "headerEnd"
+        | "headerField"
+        | "headersEnd"
+        | "headerValue"
+        | "partBegin"
+        | "partData"
+        /**
+         * Emitted after each incoming chunk of data that has been parsed. Can be used to roll your own
+         * progress bar.
+         *
+         * @link https://github.com/node-formidable/formidable#progress
+         */
+        | "progress";
+
+    interface Options {
+        /**
+         * sets encoding for incoming form fields
+         *
+         * @default 'utf-8'
+         */
+        encoding?: BufferEncoding | undefined;
+
+        /**
+         * the directory for placing file uploads in. You can move them later by using fs.rename()
+         *
+         * @default os.tmpdir()
+         */
+        uploadDir?: string | undefined;
+
+        /**
+         * to include the extensions of the original files or not
+         *
+         * @default false
+         */
+        keepExtensions?: boolean | undefined;
+
+        /**
+         * allow upload empty files
+         *
+         * @default true
+         */
+        allowEmptyFiles?: boolean | undefined;
+
+        /**
+         * the minium size of uploaded file
+         *
+         * @default 1
+         */
+        minFileSize?: number | undefined;
+
+        /**
+         * limit the amount of uploaded files, set Infinity for unlimited
+         *
+         * @default Infinity
+         */
+        maxFiles?: number | undefined;
+
+        /**
+         * limit the size of uploaded file
+         *
+         * @default 200 * 1024 * 1024
+         */
+        maxFileSize?: number | undefined;
+
+        /**
+         * limit the size of the batch of uploaded files
+         *
+         * @default options.maxFileSize
+         */
+        maxTotalFileSize?: number | undefined;
+
+        /**
+         * limit the number of fields, set 0 for unlimited
+         *
+         * @default 1000
+         */
+        maxFields?: number | undefined;
+
+        /**
+         * limit the amount of memory all fields together (except files) can allocate in bytes
+         *
+         * @default 20 * 1024 * 1024
+         */
+        maxFieldsSize?: number | undefined;
+
+        /**
+         * include checksums calculated for incoming files, set this to some hash algorithm, see
+         * crypto.createHash for available algorithms
+         *
+         * @default false
+         */
+        hashAlgorithm?: string | false | undefined;
+
+        /**
+         * which by default writes to host machine file system every file parsed; The function should
+         * return an instance of a Writable stream that will receive the uploaded file data. With this
+         * option, you can have any custom behavior regarding where the uploaded file data will be
+         * streamed for. If you are looking to write the file uploaded in other types of cloud storages
+         * (AWS S3, Azure blob storage, Google cloud storage) or private file storage, this is the option
+         * you're looking for. When this option is defined the default behavior of writing the file in the
+         * host machine file system is lost.
+         *
+         * @default null
+         */
+        fileWriteStreamHandler?: (() => Writable) | undefined;
+
+        /**
+         * when you call the .parse method, the files argument (of the callback) will contain arrays of
+         * files for inputs which submit multiple files using the HTML5 multiple attribute. Also, the
+         * fields argument will contain arrays of values for fields that have names ending with '[]'
+         *
+         * @default false
+         */
+        multiples?: boolean | undefined;
+
+        /**
+         * Use it to control newFilename. Must return a string. Will be joined with
+         * options.uploadDir.
+         *
+         * @default undefined
+         */
+        filename?: (name: string, ext: string, part: Part, form: Formidable) => string;
+
+        enabledPlugins?: string[] | undefined;
+
+        filter?: (part: Part) => boolean;
+    }
+
+    interface Fields {
+        [field: string]: string | string[];
+    }
+    interface Files {
+        [file: string]: File | File[];
+    }
+
+    interface Part extends Stream {
+        name: string | null;
+        originalFilename: string | null;
+        mimetype: string | null;
+    }
+
+    /**
+     * @link https://github.com/node-formidable/formidable#file
+     */
+    interface FileJSON extends Pick<File, "size" | "filepath" | "originalFilename" | "mimetype" | "hash"> {
+        length: number;
+        mimetype: string | null;
+        mtime: Date | null;
+    }
+
+    interface File {
+        /**
+         * The size of the uploaded file in bytes. If the file is still being uploaded (see `'fileBegin'`
+         * event), this property says how many bytes of the file have been written to disk yet.
+         */
+        size: number;
+
+        /**
+         * The path this file is being written to. You can modify this in the `'fileBegin'` event in case
+         * you are unhappy with the way formidable generates a temporary path for your files.
+         */
+        filepath: string;
+
+        /**
+         * The name this file had according to the uploading client.
+         */
+        originalFilename: string | null;
+
+        /**
+         * Calculated based on options provided
+         */
+        newFilename: string;
+
+        /**
+         * The mime type of this file, according to the uploading client.
+         */
+        mimetype: string | null;
+
+        /**
+         * A Date object (or `null`) containing the time this file was last written to. Mostly here for
+         * compatibility with the [W3C File API Draft](http://dev.w3.org/2006/webapi/FileAPI/).
+         */
+        mtime?: Date | null | undefined;
+
+        hashAlgorithm: false | "sha1" | "md5" | "sha256";
+
+        /**
+         * If `options.hashAlgorithm` calculation was set, you can read the hex digest out of this var
+         * (at the end it will be a string).
+         */
+        hash?: string | null;
+
+        /**
+         * This method returns a JSON-representation of the file, allowing you to JSON.stringify() the
+         * file which is useful for logging and responding to requests.
+         *
+         * @link https://github.com/node-formidable/formidable#filetojson
+         */
+        toJSON(): FileJSON;
+
+        toString(): string;
+    }
+
+    interface EmitData {
+        formname: any;
+        key?: string | number | undefined;
+        name: "fileBegin" | "file";
+        value: File | string;
+    }
+
+    interface EventData {
+        name: EventNames;
+        buffer: string;
+        end: string;
+        formname: string;
+        key: string;
+        start: string;
+        value: string;
+    }
+
+    type PluginFunction = (formidable: Formidable, options: Partial<Options>) => void;
+
+    type MappedParsers = {
+        [P in keyof typeof parsers]: typeof parsers[P];
+    };
+
+    type Plugins = ["octetstream", "querystring", "multipart", "json"];
+
+    type Plugin = keyof { [K in Plugins[number]]: K };
+
+    type DefaultOptions = Required<Omit<Options, "enabledPlugins">> & {
+        enabledPlugins: EnabledPlugins;
+    };
+
+    type EnabledPlugins = {
+        [P in Plugin]: PluginFunction;
+    };
+}
+
+declare const formidable: {
+    (options?: formidable.Options): Formidable;
+    defaultOptions: formidable.DefaultOptions;
+    enabledPlugins: formidable.EnabledPlugins;
+    plugins: formidable.EnabledPlugins;
+    errors: typeof errors;
+    File: typeof PersistentFile;
+    PersistentFile: typeof PersistentFile;
+    VolatileFile: typeof VolatileFile;
+    Formidable: typeof Formidable;
+    formidable: (options?: formidable.Options) => Formidable;
+    // alias
+    IncomingForm: typeof Formidable;
+    // parsers and mapped parsers
+    parsers: typeof parsers;
+} & formidable.MappedParsers;
+
+export = formidable;

node_modules/@types/formidable/package.json

+{
+  "_from": "@types/formidable@^2.0.4",
+  "_id": "@types/formidable@2.0.5",
+  "_inBundle": false,
+  "_integrity": "sha512-uvMcdn/KK3maPOaVUAc3HEYbCEhjaGFwww4EsX6IJfWIJ1tzHtDHczuImH3GKdusPnAAmzB07St90uabZeCKPA==",
+  "_location": "/@types/formidable",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/formidable@^2.0.4",
+    "name": "@types/formidable",
+    "escapedName": "@types%2fformidable",
+    "scope": "@types",
+    "rawSpec": "^2.0.4",
+    "saveSpec": null,
+    "fetchSpec": "^2.0.4"
+  },
+  "_requiredBy": [
+    "/koa-body"
+  ],
+  "_resolved": "https://registry.npmmirror.com/@types/formidable/-/formidable-2.0.5.tgz",
+  "_shasum": "e54e31d242ef750ac2d05aa163fa0274c8e6ef9c",
+  "_spec": "@types/formidable@^2.0.4",
+  "_where": "D:\\koaAndVueProjectDemo\\node_modules\\koa-body",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Wim Looman",
+      "url": "https://github.com/Nemo157"
+    },
+    {
+      "name": "Martin Badin",
+      "url": "https://github.com/martin-badin"
+    }
+  ],
+  "dependencies": {
+    "@types/node": "*"
+  },
+  "deprecated": false,
+  "description": "TypeScript definitions for formidable",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/formidable",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/formidable",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/formidable"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.9",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "1c16a50024730c3aa195a3732e682f00caac6ab41f1f3684f2d91242556ec3f7",
+  "version": "2.0.5"
+}

node_modules/@types/formidable/parsers/index.d.ts

+import { IncomingForm, Options } from "../";
+import { PassThrough, Transform } from "stream";
+
+export class MultipartParser extends Transform {
+    constructor(options?: Partial<Options>);
+    _final(callback: () => void): void;
+    _handleCallback(name: string, buffer: Buffer, start?: number, end?: number): void;
+    _transform(buffer: Buffer, _: any, callback: () => void): number;
+    explain(): string;
+    initWithBoundary(str: string): void;
+
+    static stateToString: (stateNumber: number) => string;
+
+    static STATES: Record<
+        | "PARSER_UNINITIALIZED"
+        | "START"
+        | "START_BOUNDARY"
+        | "HEADER_FIELD_START"
+        | "HEADER_FIELD"
+        | "HEADER_VALUE_START"
+        | "HEADER_VALUE"
+        | "HEADER_VALUE_ALMOST_DONE"
+        | "HEADERS_ALMOST_DONE"
+        | "PART_DATA_START"
+        | "PART_DATA"
+        | "PART_END"
+        | "END",
+        number
+    >;
+}
+
+export class OctetStreamParser extends PassThrough {
+    constructor(options?: Partial<Options>);
+}
+
+export class QuerystringParser extends Transform {
+    constructor(options?: Partial<Options>);
+    _flush(callback: () => void): void;
+    _transform(buffer: Buffer, encoding: BufferEncoding, callback: () => void): void;
+}
+
+export class StreamingQuerystring extends QuerystringParser {
+    emitField(key: string, val?: string): void;
+    getSection(buffer: Buffer, i: number): string;
+}
+
+export class DummyParser extends Transform {
+    constructor(incomingForm: typeof IncomingForm, options?: Partial<Options>);
+    _flush(callback: () => void): void;
+}
+
+export class JSONParser extends Transform {
+    constructor(options?: Partial<Options>);
+    _flush(callback: () => void): void;
+    _transform(chunk: any, encoding: BufferEncoding, callback: () => void): void;
+}

node_modules/@types/ms/LICENSE

+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

node_modules/@types/ms/README.md

+# Installation
+> `npm install --save @types/ms`
+
+# Summary
+This package contains type definitions for ms (https://github.com/zeit/ms).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/ms
+
+Additional Details
+ * Last updated: Wed, 04 Sep 2019 20:48:21 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by Zhiyuan Wang <https://github.com/danny8002>.

node_modules/@types/ms/index.d.ts

+// Type definitions for ms v0.7.1
+// Project: https://github.com/zeit/ms
+// Definitions by: Zhiyuan Wang <https://github.com/danny8002>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+
+
+/**
+* Short/Long format for `value`.
+*
+* @param {Number} value
+* @param {{long: boolean}} options
+* @return {String}
+*/
+declare function ms(value: number, options?: { long: boolean }): string;
+
+/**
+* Parse the given `value` and return milliseconds.
+*
+* @param {String} value
+* @return {Number}
+*/
+declare function ms(value: string): number;
+
+export = ms;

node_modules/@types/ms/package.json

+{
+  "_from": "@types/ms@*",
+  "_id": "@types/ms@0.7.31",
+  "_inBundle": false,
+  "_integrity": "sha512-iiUgKzV9AuaEkZqkOLDIvlQiL6ltuZd9tGcW3gwpnX8JbuiuhFlEGmmFXEXkN50Cvq7Os88IY2v0dkDqXYWVgA==",
+  "_location": "/@types/ms",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/ms@*",
+    "name": "@types/ms",
+    "escapedName": "@types%2fms",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/debug"
+  ],
+  "_resolved": "https://registry.npmmirror.com/@types/ms/-/ms-0.7.31.tgz",
+  "_shasum": "31b7ca6407128a3d2bbc27fe2d21b345397f6197",
+  "_spec": "@types/ms@*",
+  "_where": "D:\\koaAndVueProjectDemo\\node_modules\\@types\\debug",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Zhiyuan Wang",
+      "url": "https://github.com/danny8002"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for ms",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/ms",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/ms"
+  },
+  "scripts": {},
+  "typeScriptVersion": "2.0",
+  "types": "index",
+  "typesPublisherContentHash": "ff2ed90b1d3539f07c5e91fe5cac8d4aa504a3290632a4e76a02d1684dcfabfc",
+  "version": "0.7.31"
+}

node_modules/@types/node/LICENSE

+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

node_modules/@types/node/README.md

+# Installation
+> `npm install --save @types/node`
+
+# Summary
+This package contains type definitions for Node.js (https://nodejs.org/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
+
+### Additional Details
+ * Last updated: Tue, 31 May 2022 20:31:33 GMT
+ * Dependencies: none
+ * Global values: `AbortController`, `AbortSignal`, `__dirname`, `__filename`, `console`, `exports`, `gc`, `global`, `module`, `process`, `require`, `structuredClone`
+
+# Credits
+These definitions were written by [Microsoft TypeScript](https://github.com/Microsoft), [DefinitelyTyped](https://github.com/DefinitelyTyped), [Alberto Schiabel](https://github.com/jkomyno), [Alvis HT Tang](https://github.com/alvis), [Andrew Makarov](https://github.com/r3nya), [Benjamin Toueg](https://github.com/btoueg), [Chigozirim C.](https://github.com/smac89), [David Junger](https://github.com/touffy), [Deividas Bakanas](https://github.com/DeividasBakanas), [Eugene Y. Q. Shen](https://github.com/eyqs), [Hannes Magnusson](https://github.com/Hannes-Magnusson-CK), [Huw](https://github.com/hoo29), [Kelvin Jin](https://github.com/kjin), [Klaus Meinhardt](https://github.com/ajafff), [Lishude](https://github.com/islishude), [Mariusz Wiktorczyk](https://github.com/mwiktorczyk), [Mohsen Azimi](https://github.com/mohsen1), [Nicolas Even](https://github.com/n-e), [Nikita Galkin](https://github.com/galkin), [Parambir Singh](https://github.com/parambirs), [Sebastian Silbermann](https://github.com/eps1lon), [Simon Schick](https://github.com/SimonSchick), [Thomas den Hollander](https://github.com/ThomasdenH), [Wilco Bakker](https://github.com/WilcoBakker), [wwwy3y3](https://github.com/wwwy3y3), [Samuel Ainsworth](https://github.com/samuela), [Kyle Uehlein](https://github.com/kuehlein), [Thanik Bhongbhibhat](https://github.com/bhongy), [Marcin Kopacz](https://github.com/chyzwar), [Trivikram Kamat](https://github.com/trivikr), [Junxiao Shi](https://github.com/yoursunny), [Ilia Baryshnikov](https://github.com/qwelias), [ExE Boss](https://github.com/ExE-Boss), [Piotr Błażejewicz](https://github.com/peterblazejewicz), [Anna Henningsen](https://github.com/addaleax), [Victor Perin](https://github.com/victorperin), [Yongsheng Zhang](https://github.com/ZYSzys), [NodeJS Contributors](https://github.com/NodeJS), [Linus Unnebäck](https://github.com/LinusU), [wafuwafu13](https://github.com/wafuwafu13), and [Matteo Collina](https://github.com/mcollina).

node_modules/@types/node/assert/strict.d.ts

+declare module 'assert/strict' {
+    import { strict } from 'node:assert';
+    export = strict;
+}
+declare module 'node:assert/strict' {
+    import { strict } from 'node:assert';
+    export = strict;
+}

node_modules/@types/node/constants.d.ts

+/** @deprecated since v6.3.0 - use constants property exposed by the relevant module instead. */
+declare module 'constants' {
+    import { constants as osConstants, SignalConstants } from 'node:os';
+    import { constants as cryptoConstants } from 'node:crypto';
+    import { constants as fsConstants } from 'node:fs';
+
+    const exp: typeof osConstants.errno &
+        typeof osConstants.priority &
+        SignalConstants &
+        typeof cryptoConstants &
+        typeof fsConstants;
+    export = exp;
+}
+
+declare module 'node:constants' {
+    import constants = require('constants');
+    export = constants;
+}

node_modules/@types/node/diagnostics_channel.d.ts

+/**
+ * The `diagnostics_channel` module provides an API to create named channels
+ * to report arbitrary message data for diagnostics purposes.
+ *
+ * It can be accessed using:
+ *
+ * ```js
+ * import diagnostics_channel from 'diagnostics_channel';
+ * ```
+ *
+ * It is intended that a module writer wanting to report diagnostics messages
+ * will create one or many top-level channels to report messages through.
+ * Channels may also be acquired at runtime but it is not encouraged
+ * due to the additional overhead of doing so. Channels may be exported for
+ * convenience, but as long as the name is known it can be acquired anywhere.
+ *
+ * If you intend for your module to produce diagnostics data for others to
+ * consume it is recommended that you include documentation of what named
+ * channels are used along with the shape of the message data. Channel names
+ * should generally include the module name to avoid collisions with data from
+ * other modules.
+ * @experimental
+ * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/diagnostics_channel.js)
+ */
+declare module 'diagnostics_channel' {
+    /**
+     * Check if there are active subscribers to the named channel. This is helpful if
+     * the message you want to send might be expensive to prepare.
+     *
+     * This API is optional but helpful when trying to publish messages from very
+     * performance-sensitive code.
+     *
+     * ```js
+     * import diagnostics_channel from 'diagnostics_channel';
+     *
+     * if (diagnostics_channel.hasSubscribers('my-channel')) {
+     *   // There are subscribers, prepare and publish message
+     * }
+     * ```
+     * @since v15.1.0, v14.17.0
+     * @param name The channel name
+     * @return If there are active subscribers
+     */
+    function hasSubscribers(name: string): boolean;
+    /**
+     * This is the primary entry-point for anyone wanting to interact with a named
+     * channel. It produces a channel object which is optimized to reduce overhead at
+     * publish time as much as possible.
+     *
+     * ```js
+     * import diagnostics_channel from 'diagnostics_channel';
+     *
+     * const channel = diagnostics_channel.channel('my-channel');
+     * ```
+     * @since v15.1.0, v14.17.0
+     * @param name The channel name
+     * @return The named channel object
+     */
+    function channel(name: string): Channel;
+    type ChannelListener = (message: unknown, name: string) => void;
+    /**
+     * The class `Channel` represents an individual named channel within the data
+     * pipeline. It is use to track subscribers and to publish messages when there
+     * are subscribers present. It exists as a separate object to avoid channel
+     * lookups at publish time, enabling very fast publish speeds and allowing
+     * for heavy use while incurring very minimal cost. Channels are created with {@link channel}, constructing a channel directly
+     * with `new Channel(name)` is not supported.
+     * @since v15.1.0, v14.17.0
+     */
+    class Channel {
+        readonly name: string;
+        /**
+         * Check if there are active subscribers to this channel. This is helpful if
+         * the message you want to send might be expensive to prepare.
+         *
+         * This API is optional but helpful when trying to publish messages from very
+         * performance-sensitive code.
+         *
+         * ```js
+         * import diagnostics_channel from 'diagnostics_channel';
+         *
+         * const channel = diagnostics_channel.channel('my-channel');
+         *
+         * if (channel.hasSubscribers) {
+         *   // There are subscribers, prepare and publish message
+         * }
+         * ```
+         * @since v15.1.0, v14.17.0
+         */
+        readonly hasSubscribers: boolean;
+        private constructor(name: string);
+        /**
+         * Publish a message to any subscribers to the channel. This will
+         * trigger message handlers synchronously so they will execute within
+         * the same context.
+         *
+         * ```js
+         * import diagnostics_channel from 'diagnostics_channel';
+         *
+         * const channel = diagnostics_channel.channel('my-channel');
+         *
+         * channel.publish({
+         *   some: 'message'
+         * });
+         * ```
+         * @since v15.1.0, v14.17.0
+         * @param message The message to send to the channel subscribers
+         */
+        publish(message: unknown): void;
+        /**
+         * Register a message handler to subscribe to this channel. This message handler
+         * will be run synchronously whenever a message is published to the channel. Any
+         * errors thrown in the message handler will trigger an `'uncaughtException'`.
+         *
+         * ```js
+         * import diagnostics_channel from 'diagnostics_channel';
+         *
+         * const channel = diagnostics_channel.channel('my-channel');
+         *
+         * channel.subscribe((message, name) => {
+         *   // Received data
+         * });
+         * ```
+         * @since v15.1.0, v14.17.0
+         * @param onMessage The handler to receive channel messages
+         */
+        subscribe(onMessage: ChannelListener): void;
+        /**
+         * Remove a message handler previously registered to this channel with `channel.subscribe(onMessage)`.
+         *
+         * ```js
+         * import diagnostics_channel from 'diagnostics_channel';
+         *
+         * const channel = diagnostics_channel.channel('my-channel');
+         *
+         * function onMessage(message, name) {
+         *   // Received data
+         * }
+         *
+         * channel.subscribe(onMessage);
+         *
+         * channel.unsubscribe(onMessage);
+         * ```
+         * @since v15.1.0, v14.17.0
+         * @param onMessage The previous subscribed handler to remove
+         */
+        unsubscribe(onMessage: ChannelListener): void;
+    }
+}
+declare module 'node:diagnostics_channel' {
+    export * from 'diagnostics_channel';
+}

node_modules/@types/node/globals.global.d.ts

+declare var global: typeof globalThis;

node_modules/@types/node/module.d.ts

+/**
+ * @since v0.3.7
+ */
+declare module 'module' {
+    import { URL } from 'node:url';
+    namespace Module {
+        /**
+         * The `module.syncBuiltinESMExports()` method updates all the live bindings for
+         * builtin `ES Modules` to match the properties of the `CommonJS` exports. It
+         * does not add or remove exported names from the `ES Modules`.
+         *
+         * ```js
+         * const fs = require('fs');
+         * const assert = require('assert');
+         * const { syncBuiltinESMExports } = require('module');
+         *
+         * fs.readFile = newAPI;
+         *
+         * delete fs.readFileSync;
+         *
+         * function newAPI() {
+         *   // ...
+         * }
+         *
+         * fs.newAPI = newAPI;
+         *
+         * syncBuiltinESMExports();
+         *
+         * import('fs').then((esmFS) => {
+         *   // It syncs the existing readFile property with the new value
+         *   assert.strictEqual(esmFS.readFile, newAPI);
+         *   // readFileSync has been deleted from the required fs
+         *   assert.strictEqual('readFileSync' in fs, false);
+         *   // syncBuiltinESMExports() does not remove readFileSync from esmFS
+         *   assert.strictEqual('readFileSync' in esmFS, true);
+         *   // syncBuiltinESMExports() does not add names
+         *   assert.strictEqual(esmFS.newAPI, undefined);
+         * });
+         * ```
+         * @since v12.12.0
+         */
+        function syncBuiltinESMExports(): void;
+        /**
+         * `path` is the resolved path for the file for which a corresponding source map
+         * should be fetched.
+         * @since v13.7.0, v12.17.0
+         */
+        function findSourceMap(path: string, error?: Error): SourceMap;
+        interface SourceMapPayload {
+            file: string;
+            version: number;
+            sources: string[];
+            sourcesContent: string[];
+            names: string[];
+            mappings: string;
+            sourceRoot: string;
+        }
+        interface SourceMapping {
+            generatedLine: number;
+            generatedColumn: number;
+            originalSource: string;
+            originalLine: number;
+            originalColumn: number;
+        }
+        /**
+         * @since v13.7.0, v12.17.0
+         */
+        class SourceMap {
+            /**
+             * Getter for the payload used to construct the `SourceMap` instance.
+             */
+            readonly payload: SourceMapPayload;
+            constructor(payload: SourceMapPayload);
+            /**
+             * Given a line number and column number in the generated source file, returns
+             * an object representing the position in the original file. The object returned
+             * consists of the following keys:
+             */
+            findEntry(line: number, column: number): SourceMapping;
+        }
+    }
+    interface Module extends NodeModule {}
+    class Module {
+        static runMain(): void;
+        static wrap(code: string): string;
+        static createRequire(path: string | URL): NodeRequire;
+        static builtinModules: string[];
+        static Module: typeof Module;
+        constructor(id: string, parent?: Module);
+    }
+    global {
+        interface ImportMeta {
+            url: string;
+            /**
+             * @experimental
+             * This feature is only available with the `--experimental-import-meta-resolve`
+             * command flag enabled.
+             *
+             * Provides a module-relative resolution function scoped to each module, returning
+             * the URL string.
+             *
+             * @param specified The module specifier to resolve relative to `parent`.
+             * @param parent The absolute parent module URL to resolve from. If none
+             * is specified, the value of `import.meta.url` is used as the default.
+             */
+            resolve?(specified: string, parent?: string | URL): Promise<string>;
+        }
+    }
+    export = Module;
+}
+declare module 'node:module' {
+    import module = require('module');
+    export = module;
+}

node_modules/@types/validator/es/lib/blacklist.d.ts

+import validator from '../../';
+export default validator.blacklist;