up n_m

node_modules/@types/acorn/LICENSE

@@ -0,0 +1,21 @@
+    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/acorn/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/acorn`
+
+# Summary
+This package contains type definitions for Acorn (https://github.com/acornjs/acorn).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/acorn.
+
+### Additional Details
+ * Last updated: Tue, 06 Jul 2021 18:05:30 GMT
+ * Dependencies: [@types/estree](https://npmjs.com/package/@types/estree)
+ * Global values: `acorn`
+
+# Credits
+These definitions were written by [RReverser](https://github.com/RReverser), and [e-cloud](https://github.com/e-cloud).

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

@@ -0,0 +1,254 @@
+// Type definitions for Acorn 4.0
+// Project: https://github.com/acornjs/acorn
+// Definitions by: RReverser <https://github.com/RReverser>, e-cloud <https://github.com/e-cloud>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export as namespace acorn;
+export = acorn;
+import * as ESTree from 'estree';
+
+declare namespace acorn {
+    interface PlainObject {
+        [name: string]: any;
+    }
+
+    interface PluginsObject {
+        [name: string]: (p: Parser, config: any) => void;
+    }
+
+    interface Options {
+        ecmaVersion?: 3 | 5 | 6 | 7 | 8 | 2015 | 2016 | 2017 | undefined;
+        sourceType?: 'script' | 'module' | undefined;
+        onInsertedSemicolon?: ((lastTokEnd: number, lastTokEndLoc?: ESTree.Position) => void) | undefined;
+        onTrailingComma?: ((lastTokEnd: number, lastTokEndLoc?: ESTree.Position) => void) | undefined;
+        allowReserved?: boolean | undefined;
+        allowReturnOutsideFunction?: boolean | undefined;
+        allowImportExportEverywhere?: boolean | undefined;
+        allowHashBang?: boolean | undefined;
+        locations?: boolean | undefined;
+        onToken?: ((token: Token) => any) | Token[] | undefined;
+        onComment?: ((
+            isBlock: boolean, text: string, start: number, end: number, startLoc?: ESTree.Position,
+            endLoc?: ESTree.Position
+        ) => void) | Comment[] | undefined;
+        ranges?: boolean | undefined;
+        program?: ESTree.Program | undefined;
+        sourceFile?: string | undefined;
+        directSourceFile?: string | undefined;
+        preserveParens?: boolean | undefined;
+        plugins?: PlainObject | undefined;
+    }
+
+    class Parser {
+        constructor(options: Options, input: string, startPos?: number);
+
+        parse(): ESTree.Program;
+    }
+
+    const plugins: PluginsObject;
+
+    const defaultOptions: Options;
+
+    class Position implements ESTree.Position {
+        line: number;
+        column: number;
+
+        constructor(line: number, col: number);
+
+        offset(n: number): Position;
+    }
+
+    class SourceLocation implements ESTree.SourceLocation {
+        start: Position;
+        end: Position;
+        source?: string | null | undefined;
+
+        constructor(p: Parser, start: Position, end: Position);
+    }
+
+    function getLineInfo(input: string, offset: number): ESTree.Position;
+
+    class Node {
+        type: string;
+        start: number;
+        end: number;
+        loc?: ESTree.SourceLocation | undefined;
+        sourceFile?: string | undefined;
+        range?: [number, number] | undefined;
+
+        constructor(parser: Parser, pos: number, loc: number);
+    }
+
+    interface TokeTypeConfig {
+        keyword: string;
+        beforeExpr?: boolean | undefined;
+        startsExpr?: boolean | undefined;
+        isLoop?: boolean | undefined;
+        isAssign?: boolean | undefined;
+        prefix?: boolean | undefined;
+        postfix?: boolean | undefined;
+        binop?: number | undefined;
+    }
+
+    class TokenType {
+        label: string;
+        keyword: string;
+        beforeExpr: boolean;
+        startsExpr: boolean;
+        isLoop: boolean;
+        isAssign: boolean;
+        prefix: boolean;
+        postfix: boolean;
+        binop: number;
+        updateContext: (prevType: TokenType) => void;
+
+        constructor(label: string, conf?: TokeTypeConfig);
+    }
+
+    const tokTypes: {
+        num: TokenType;
+        regexp: TokenType;
+        string: TokenType;
+        name: TokenType;
+        eof: TokenType;
+        bracketL: TokenType;
+        bracketR: TokenType;
+        braceL: TokenType;
+        braceR: TokenType;
+        parenL: TokenType;
+        parenR: TokenType;
+        comma: TokenType;
+        semi: TokenType;
+        colon: TokenType;
+        dot: TokenType;
+        question: TokenType;
+        arrow: TokenType;
+        template: TokenType;
+        ellipsis: TokenType;
+        backQuote: TokenType;
+        dollarBraceL: TokenType;
+        eq: TokenType;
+        assign: TokenType;
+        incDec: TokenType;
+        prefix: TokenType;
+        logicalOR: TokenType;
+        logicalAND: TokenType;
+        bitwiseOR: TokenType;
+        bitwiseXOR: TokenType;
+        bitwiseAND: TokenType;
+        equality: TokenType;
+        relational: TokenType;
+        bitShift: TokenType;
+        plusMin: TokenType;
+        modulo: TokenType;
+        star: TokenType;
+        slash: TokenType;
+        starstar: TokenType;
+        _break: TokenType;
+        _case: TokenType;
+        _catch: TokenType;
+        _continue: TokenType;
+        _debugger: TokenType;
+        _default: TokenType;
+        _do: TokenType;
+        _else: TokenType;
+        _finally: TokenType;
+        _for: TokenType;
+        _function: TokenType;
+        _if: TokenType;
+        _return: TokenType;
+        _switch: TokenType;
+        _throw: TokenType;
+        _try: TokenType;
+        _var: TokenType;
+        _const: TokenType;
+        _while: TokenType;
+        _with: TokenType;
+        _new: TokenType;
+        _this: TokenType;
+        _super: TokenType;
+        _class: TokenType;
+        _extends: TokenType;
+        _export: TokenType;
+        _import: TokenType;
+        _null: TokenType;
+        _true: TokenType;
+        _false: TokenType;
+        _in: TokenType;
+        _instanceof: TokenType;
+        _typeof: TokenType;
+        _void: TokenType;
+        _delete: TokenType;
+    };
+
+    class TokContext {
+        constructor(token: string, isExpr: boolean, preserveSpace: boolean, override: (p: Parser) => void);
+    }
+
+    const tokContexts: {
+        b_stat: TokContext;
+        b_expr: TokContext;
+        b_tmpl: TokContext;
+        p_stat: TokContext;
+        p_expr: TokContext;
+        q_tmpl: TokContext;
+        f_expr: TokContext;
+    };
+
+    function isIdentifierStart(code: number, astral?: boolean): boolean;
+
+    function isIdentifierChar(code: number, astral?: boolean): boolean;
+
+    interface AbstractToken {
+        start: number;
+        end: number;
+        loc?: SourceLocation | undefined;
+        range?: [number, number] | undefined;
+    }
+
+    interface Comment extends AbstractToken {
+        type: string;
+        value: string;
+    }
+
+    class Token {
+        constructor(p: Parser);
+    }
+
+    interface Token extends AbstractToken {
+        type: TokenType;
+        value: any;
+    }
+
+    function isNewLine(code: number): boolean;
+
+    const lineBreak: RegExp;
+
+    const lineBreakG: RegExp;
+
+    const version: string;
+
+    // TODO: rename type.
+    type IParse = (input: string, options?: Options) => ESTree.Program;
+
+    const parse: IParse;
+
+    function parseExpressionAt(input: string, pos?: number, options?: Options): ESTree.Expression;
+
+    interface ITokenizer {
+      getToken(): Token;
+      [Symbol.iterator](): Iterator<Token>;
+    }
+
+    function tokenizer(input: string, options: Options): ITokenizer;
+
+    let parse_dammit: IParse | undefined;
+    let LooseParser: ILooseParserClass | undefined;
+    let pluginsLoose: PluginsObject | undefined;
+
+    type ILooseParserClass = new (input: string, options?: Options) => ILooseParser;
+
+    interface ILooseParser {}
+
+    function addLooseExports(parse: IParse, parser: ILooseParserClass, plugins: PluginsObject): void;
+}

node_modules/@types/acorn/package.json

@@ -0,0 +1,32 @@
+{
+    "name": "@types/acorn",
+    "version": "4.0.6",
+    "description": "TypeScript definitions for Acorn",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/acorn",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "RReverser",
+            "url": "https://github.com/RReverser",
+            "githubUsername": "RReverser"
+        },
+        {
+            "name": "e-cloud",
+            "url": "https://github.com/e-cloud",
+            "githubUsername": "e-cloud"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/acorn"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/estree": "*"
+    },
+    "typesPublisherContentHash": "ddcea022bf260ed636fb469eb0880923eb24b6cd7e9ca6cb841e720675c50977",
+    "typeScriptVersion": "3.6"
+}

node_modules/@types/body-parser/LICENSE

@@ -0,0 +1,21 @@
+    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/body-parser/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/body-parser`
+
+# Summary
+This package contains type definitions for body-parser (https://github.com/expressjs/body-parser).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/body-parser.
+
+### Additional Details
+ * Last updated: Mon, 06 Nov 2023 22:41:05 GMT
+ * Dependencies: [@types/connect](https://npmjs.com/package/@types/connect), [@types/node](https://npmjs.com/package/@types/node)
+
+# Credits
+These definitions were written by [Santi Albo](https://github.com/santialbo), [Vilic Vane](https://github.com/vilic), [Jonathan Häberle](https://github.com/dreampulse), [Gevik Babakhani](https://github.com/blendsdk), [Tomasz Łaziuk](https://github.com/tlaziuk), [Jason Walton](https://github.com/jwalton), and [Piotr Błażejewicz](https://github.com/peterblazejewicz).

node_modules/@types/body-parser/index.d.ts

@@ -0,0 +1,95 @@
+/// <reference types="node" />
+
+import { NextHandleFunction } from "connect";
+import * as http from "http";
+
+// for docs go to https://github.com/expressjs/body-parser/tree/1.19.0#body-parser
+
+declare namespace bodyParser {
+    interface BodyParser {
+        /**
+         * @deprecated  use individual json/urlencoded middlewares
+         */
+        (options?: OptionsJson & OptionsText & OptionsUrlencoded): NextHandleFunction;
+        /**
+         * Returns middleware that only parses json and only looks at requests
+         * where the Content-Type header matches the type option.
+         */
+        json(options?: OptionsJson): NextHandleFunction;
+        /**
+         * Returns middleware that parses all bodies as a Buffer and only looks at requests
+         * where the Content-Type header matches the type option.
+         */
+        raw(options?: Options): NextHandleFunction;
+
+        /**
+         * Returns middleware that parses all bodies as a string and only looks at requests
+         * where the Content-Type header matches the type option.
+         */
+        text(options?: OptionsText): NextHandleFunction;
+        /**
+         * Returns middleware that only parses urlencoded bodies and only looks at requests
+         * where the Content-Type header matches the type option
+         */
+        urlencoded(options?: OptionsUrlencoded): NextHandleFunction;
+    }
+
+    interface Options {
+        /** When set to true, then deflated (compressed) bodies will be inflated; when false, deflated bodies are rejected. Defaults to true. */
+        inflate?: boolean | undefined;
+        /**
+         * Controls the maximum request body size. If this is a number,
+         * then the value specifies the number of bytes; if it is a string,
+         * the value is passed to the bytes library for parsing. Defaults to '100kb'.
+         */
+        limit?: number | string | undefined;
+        /**
+         * The type option is used to determine what media type the middleware will parse
+         */
+        type?: string | string[] | ((req: http.IncomingMessage) => any) | undefined;
+        /**
+         * The verify option, if supplied, is called as verify(req, res, buf, encoding),
+         * where buf is a Buffer of the raw request body and encoding is the encoding of the request.
+         */
+        verify?(req: http.IncomingMessage, res: http.ServerResponse, buf: Buffer, encoding: string): void;
+    }
+
+    interface OptionsJson extends Options {
+        /**
+         * The reviver option is passed directly to JSON.parse as the second argument.
+         */
+        reviver?(key: string, value: any): any;
+        /**
+         * When set to `true`, will only accept arrays and objects;
+         * when `false` will accept anything JSON.parse accepts. Defaults to `true`.
+         */
+        strict?: boolean | undefined;
+    }
+
+    interface OptionsText extends Options {
+        /**
+         * Specify the default character set for the text content if the charset
+         * is not specified in the Content-Type header of the request.
+         * Defaults to `utf-8`.
+         */
+        defaultCharset?: string | undefined;
+    }
+
+    interface OptionsUrlencoded extends Options {
+        /**
+         * The extended option allows to choose between parsing the URL-encoded data
+         * with the querystring library (when `false`) or the qs library (when `true`).
+         */
+        extended?: boolean | undefined;
+        /**
+         * The parameterLimit option controls the maximum number of parameters
+         * that are allowed in the URL-encoded data. If a request contains more parameters than this value,
+         * a 413 will be returned to the client. Defaults to 1000.
+         */
+        parameterLimit?: number | undefined;
+    }
+}
+
+declare const bodyParser: bodyParser.BodyParser;
+
+export = bodyParser;

node_modules/@types/body-parser/package.json

@@ -0,0 +1,58 @@
+{
+    "name": "@types/body-parser",
+    "version": "1.19.5",
+    "description": "TypeScript definitions for body-parser",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/body-parser",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Santi Albo",
+            "githubUsername": "santialbo",
+            "url": "https://github.com/santialbo"
+        },
+        {
+            "name": "Vilic Vane",
+            "githubUsername": "vilic",
+            "url": "https://github.com/vilic"
+        },
+        {
+            "name": "Jonathan Häberle",
+            "githubUsername": "dreampulse",
+            "url": "https://github.com/dreampulse"
+        },
+        {
+            "name": "Gevik Babakhani",
+            "githubUsername": "blendsdk",
+            "url": "https://github.com/blendsdk"
+        },
+        {
+            "name": "Tomasz Łaziuk",
+            "githubUsername": "tlaziuk",
+            "url": "https://github.com/tlaziuk"
+        },
+        {
+            "name": "Jason Walton",
+            "githubUsername": "jwalton",
+            "url": "https://github.com/jwalton"
+        },
+        {
+            "name": "Piotr Błażejewicz",
+            "githubUsername": "peterblazejewicz",
+            "url": "https://github.com/peterblazejewicz"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/body-parser"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/connect": "*",
+        "@types/node": "*"
+    },
+    "typesPublisherContentHash": "7be737b78c8aabd5436be840558b283182b44c3cf9da24fb1f2ff8f414db5802",
+    "typeScriptVersion": "4.5"
+}

node_modules/@types/bonjour/LICENSE

@@ -0,0 +1,21 @@
+    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/bonjour/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/bonjour`
+
+# Summary
+This package contains type definitions for bonjour (https://github.com/watson/bonjour).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/bonjour.
+
+### Additional Details
+ * Last updated: Mon, 06 Nov 2023 22:41:05 GMT
+ * Dependencies: [@types/node](https://npmjs.com/package/@types/node)
+
+# Credits
+These definitions were written by [Quentin Lampin](https://github.com/quentin-ol).

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

@@ -0,0 +1,90 @@
+/// <reference types="node" />
+
+import { RemoteInfo } from "dgram";
+
+declare function bonjour(opts?: bonjour.BonjourOptions): bonjour.Bonjour;
+export = bonjour;
+declare namespace bonjour {
+    /**
+     * Start a browser
+     *
+     * The browser listens for services by querying for PTR records of a given
+     * type, protocol and domain, e.g. _http._tcp.local.
+     *
+     * If no type is given, a wild card search is performed.
+     *
+     * An internal list of online services is kept which starts out empty. When
+     * ever a new service is discovered, it's added to the list and an "up" event
+     * is emitted with that service. When it's discovered that the service is no
+     * longer available, it is removed from the list and a "down" event is emitted
+     * with that service.
+     */
+    interface Browser extends NodeJS.EventEmitter {
+        services: RemoteService[];
+        start(): void;
+        update(): void;
+        stop(): void;
+        on(event: "up" | "down", listener: (service: RemoteService) => void): this;
+        once(event: "up" | "down", listener: (service: RemoteService) => void): this;
+        removeListener(event: "up" | "down", listener: (service: RemoteService) => void): this;
+        removeAllListeners(event?: "up" | "down"): this;
+    }
+    interface BrowserOptions {
+        type?: string | undefined;
+        subtypes?: string[] | undefined;
+        protocol?: string | undefined;
+        txt?: { [key: string]: string } | undefined;
+    }
+
+    interface ServiceOptions {
+        name: string;
+        host?: string | undefined;
+        port: number;
+        type: string;
+        subtypes?: string[] | undefined;
+        protocol?: "udp" | "tcp" | undefined;
+        txt?: { [key: string]: string } | undefined;
+        probe?: boolean | undefined;
+    }
+
+    interface BaseService {
+        name: string;
+        fqdn: string;
+        host: string;
+        port: number;
+        type: string;
+        protocol: string;
+        subtypes: string[];
+        txt: { [key: string]: string };
+    }
+    interface RemoteService extends BaseService {
+        referer: RemoteInfo;
+        rawTxt: Buffer;
+        addresses: string[];
+    }
+    interface Service extends BaseService, NodeJS.EventEmitter {
+        published: boolean;
+        addresses: string[];
+
+        stop(cb?: () => void): void;
+        start(): void;
+    }
+    interface BonjourOptions {
+        type?: "udp4" | "udp6" | undefined;
+        multicast?: boolean | undefined;
+        interface?: string | undefined;
+        port?: number | undefined;
+        ip?: string | undefined;
+        ttl?: number | undefined;
+        loopback?: boolean | undefined;
+        reuseAddr?: boolean | undefined;
+    }
+    interface Bonjour {
+        (opts?: BonjourOptions): Bonjour;
+        publish(options: ServiceOptions): Service;
+        unpublishAll(cb?: () => void): void;
+        find(options: BrowserOptions, onUp?: (service: RemoteService) => void): Browser;
+        findOne(options: BrowserOptions, cb?: (service: RemoteService) => void): Browser;
+        destroy(): void;
+    }
+}

node_modules/@types/bonjour/package.json

@@ -0,0 +1,27 @@
+{
+    "name": "@types/bonjour",
+    "version": "3.5.13",
+    "description": "TypeScript definitions for bonjour",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/bonjour",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Quentin Lampin",
+            "githubUsername": "quentin-ol",
+            "url": "https://github.com/quentin-ol"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/bonjour"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/node": "*"
+    },
+    "typesPublisherContentHash": "af953fb9d89b2e08b510c2d99252988a590b758e2e636fafadf9496dee4f2b68",
+    "typeScriptVersion": "4.5"
+}

node_modules/@types/connect-history-api-fallback/LICENSE

@@ -0,0 +1,21 @@
+    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/connect-history-api-fallback/README.md

@@ -0,0 +1,51 @@
+# Installation
+> `npm install --save @types/connect-history-api-fallback`
+
+# Summary
+This package contains type definitions for connect-history-api-fallback (https://github.com/bripkens/connect-history-api-fallback#readme).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/connect-history-api-fallback.
+## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/connect-history-api-fallback/index.d.ts)
+````ts
+/// <reference types="node" />
+
+import { Url } from "url";
+
+import * as core from "express-serve-static-core";
+
+export = historyApiFallback;
+
+declare function historyApiFallback(options?: historyApiFallback.Options): core.RequestHandler;
+
+declare namespace historyApiFallback {
+    interface Options {
+        readonly disableDotRule?: true | undefined;
+        readonly htmlAcceptHeaders?: readonly string[] | undefined;
+        readonly index?: string | undefined;
+        readonly logger?: typeof console.log | undefined;
+        readonly rewrites?: readonly Rewrite[] | undefined;
+        readonly verbose?: boolean | undefined;
+    }
+
+    interface Context {
+        readonly match: RegExpMatchArray;
+        readonly parsedUrl: Url;
+        readonly request: core.Request;
+    }
+    type RewriteTo = (context: Context) => string;
+
+    interface Rewrite {
+        readonly from: RegExp;
+        readonly to: string | RegExp | RewriteTo;
+    }
+}
+
+````
+
+### Additional Details
+ * Last updated: Mon, 20 Nov 2023 23:36:24 GMT
+ * Dependencies: [@types/express-serve-static-core](https://npmjs.com/package/@types/express-serve-static-core), [@types/node](https://npmjs.com/package/@types/node)
+
+# Credits
+These definitions were written by [Douglas Duteil](https://github.com/douglasduteil).

node_modules/@types/connect-history-api-fallback/index.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+
+import { Url } from "url";
+
+import * as core from "express-serve-static-core";
+
+export = historyApiFallback;
+
+declare function historyApiFallback(options?: historyApiFallback.Options): core.RequestHandler;
+
+declare namespace historyApiFallback {
+    interface Options {
+        readonly disableDotRule?: true | undefined;
+        readonly htmlAcceptHeaders?: readonly string[] | undefined;
+        readonly index?: string | undefined;
+        readonly logger?: typeof console.log | undefined;
+        readonly rewrites?: readonly Rewrite[] | undefined;
+        readonly verbose?: boolean | undefined;
+    }
+
+    interface Context {
+        readonly match: RegExpMatchArray;
+        readonly parsedUrl: Url;
+        readonly request: core.Request;
+    }
+    type RewriteTo = (context: Context) => string;
+
+    interface Rewrite {
+        readonly from: RegExp;
+        readonly to: string | RegExp | RewriteTo;
+    }
+}

node_modules/@types/connect-history-api-fallback/package.json

@@ -0,0 +1,28 @@
+{
+    "name": "@types/connect-history-api-fallback",
+    "version": "1.5.4",
+    "description": "TypeScript definitions for connect-history-api-fallback",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/connect-history-api-fallback",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Douglas Duteil",
+            "githubUsername": "douglasduteil",
+            "url": "https://github.com/douglasduteil"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/connect-history-api-fallback"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/express-serve-static-core": "*",
+        "@types/node": "*"
+    },
+    "typesPublisherContentHash": "d808766d9d2861db4ad548a99ff2bf4e44af08540b5df45324c6cd31964c1a1f",
+    "typeScriptVersion": "4.5"
+}

node_modules/@types/connect/LICENSE

@@ -0,0 +1,21 @@
+    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/connect/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/connect`
+
+# Summary
+This package contains type definitions for connect (https://github.com/senchalabs/connect).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/connect.
+
+### Additional Details
+ * Last updated: Mon, 06 Nov 2023 22:41:05 GMT
+ * Dependencies: [@types/node](https://npmjs.com/package/@types/node)
+
+# Credits
+These definitions were written by [Maxime LUCE](https://github.com/SomaticIT), and [Evan Hahn](https://github.com/EvanHahn).

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

@@ -0,0 +1,91 @@
+/// <reference types="node" />
+
+import * as http from "http";
+
+/**
+ * Create a new connect server.
+ */
+declare function createServer(): createServer.Server;
+
+declare namespace createServer {
+    export type ServerHandle = HandleFunction | http.Server;
+
+    export class IncomingMessage extends http.IncomingMessage {
+        originalUrl?: http.IncomingMessage["url"] | undefined;
+    }
+
+    type NextFunction = (err?: any) => void;
+
+    export type SimpleHandleFunction = (req: IncomingMessage, res: http.ServerResponse) => void;
+    export type NextHandleFunction = (req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;
+    export type ErrorHandleFunction = (
+        err: any,
+        req: IncomingMessage,
+        res: http.ServerResponse,
+        next: NextFunction,
+    ) => void;
+    export type HandleFunction = SimpleHandleFunction | NextHandleFunction | ErrorHandleFunction;
+
+    export interface ServerStackItem {
+        route: string;
+        handle: ServerHandle;
+    }
+
+    export interface Server extends NodeJS.EventEmitter {
+        (req: http.IncomingMessage, res: http.ServerResponse, next?: Function): void;
+
+        route: string;
+        stack: ServerStackItem[];
+
+        /**
+         * Utilize the given middleware `handle` to the given `route`,
+         * defaulting to _/_. This "route" is the mount-point for the
+         * middleware, when given a value other than _/_ the middleware
+         * is only effective when that segment is present in the request's
+         * pathname.
+         *
+         * For example if we were to mount a function at _/admin_, it would
+         * be invoked on _/admin_, and _/admin/settings_, however it would
+         * not be invoked for _/_, or _/posts_.
+         */
+        use(fn: NextHandleFunction): Server;
+        use(fn: HandleFunction): Server;
+        use(route: string, fn: NextHandleFunction): Server;
+        use(route: string, fn: HandleFunction): Server;
+
+        /**
+         * Handle server requests, punting them down
+         * the middleware stack.
+         */
+        handle(req: http.IncomingMessage, res: http.ServerResponse, next: Function): void;
+
+        /**
+         * Listen for connections.
+         *
+         * This method takes the same arguments
+         * as node's `http.Server#listen()`.
+         *
+         * HTTP and HTTPS:
+         *
+         * If you run your application both as HTTP
+         * and HTTPS you may wrap them individually,
+         * since your Connect "server" is really just
+         * a JavaScript `Function`.
+         *
+         *      var connect = require('connect')
+         *        , http = require('http')
+         *        , https = require('https');
+         *
+         *      var app = connect();
+         *
+         *      http.createServer(app).listen(80);
+         *      https.createServer(options, app).listen(443);
+         */
+        listen(port: number, hostname?: string, backlog?: number, callback?: Function): http.Server;
+        listen(port: number, hostname?: string, callback?: Function): http.Server;
+        listen(path: string, callback?: Function): http.Server;
+        listen(handle: any, listeningListener?: Function): http.Server;
+    }
+}
+
+export = createServer;

node_modules/@types/connect/package.json

@@ -0,0 +1,32 @@
+{
+    "name": "@types/connect",
+    "version": "3.4.38",
+    "description": "TypeScript definitions for connect",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/connect",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Maxime LUCE",
+            "githubUsername": "SomaticIT",
+            "url": "https://github.com/SomaticIT"
+        },
+        {
+            "name": "Evan Hahn",
+            "githubUsername": "EvanHahn",
+            "url": "https://github.com/EvanHahn"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/connect"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/node": "*"
+    },
+    "typesPublisherContentHash": "8990242237504bdec53088b79e314b94bec69286df9de56db31f22de403b4092",
+    "typeScriptVersion": "4.5"
+}

node_modules/@types/debug/LICENSE

@@ -0,0 +1,21 @@
+    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

@@ -0,0 +1,69 @@
+# Installation
+> `npm install --save @types/debug`
+
+# Summary
+This package contains type definitions for debug (https://github.com/debug-js/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
+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;
+
+        inspectOpts?: {
+            hideDate?: boolean | number | null;
+            colors?: boolean | number | null;
+            depth?: boolean | number | null;
+            showHidden?: boolean | number | null;
+        };
+    }
+
+    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: Thu, 09 Nov 2023 03:06:57 GMT
+ * Dependencies: [@types/ms](https://npmjs.com/package/@types/ms)
+
+# 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

@@ -0,0 +1,50 @@
+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;
+
+        inspectOpts?: {
+            hideDate?: boolean | number | null;
+            colors?: boolean | number | null;
+            depth?: boolean | number | null;
+            showHidden?: boolean | number | null;
+        };
+    }
+
+    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

@@ -0,0 +1,57 @@
+{
+    "name": "@types/debug",
+    "version": "4.1.12",
+    "description": "TypeScript definitions for debug",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/debug",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Seon-Wook Park",
+            "githubUsername": "swook",
+            "url": "https://github.com/swook"
+        },
+        {
+            "name": "Gal Talmor",
+            "githubUsername": "galtalmor",
+            "url": "https://github.com/galtalmor"
+        },
+        {
+            "name": "John McLaughlin",
+            "githubUsername": "zamb3zi",
+            "url": "https://github.com/zamb3zi"
+        },
+        {
+            "name": "Brasten Sager",
+            "githubUsername": "brasten",
+            "url": "https://github.com/brasten"
+        },
+        {
+            "name": "Nicolas Penin",
+            "githubUsername": "npenin",
+            "url": "https://github.com/npenin"
+        },
+        {
+            "name": "Kristian Brünn",
+            "githubUsername": "kristianmitk",
+            "url": "https://github.com/kristianmitk"
+        },
+        {
+            "name": "Caleb Gregory",
+            "githubUsername": "calebgregory",
+            "url": "https://github.com/calebgregory"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/debug"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/ms": "*"
+    },
+    "typesPublisherContentHash": "1053110a8e5e302f35fb57f45389304fa5a4f53bb8982b76b8065bcfd7083731",
+    "typeScriptVersion": "4.5"
+}

node_modules/@types/eslint-scope/LICENSE

@@ -0,0 +1,21 @@
+    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/eslint-scope/README.md

@@ -0,0 +1,90 @@
+# Installation
+> `npm install --save @types/eslint-scope`
+
+# Summary
+This package contains type definitions for eslint-scope (https://github.com/eslint/eslint-scope).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/eslint-scope.
+## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/eslint-scope/index.d.ts)
+````ts
+import * as eslint from "eslint";
+import * as estree from "estree";
+
+export const version: string;
+
+export class ScopeManager implements eslint.Scope.ScopeManager {
+    scopes: Scope[];
+    globalScope: Scope;
+    acquire(node: {}, inner?: boolean): Scope | null;
+    getDeclaredVariables(node: {}): Variable[];
+}
+
+export class Scope implements eslint.Scope.Scope {
+    type:
+        | "block"
+        | "catch"
+        | "class"
+        | "for"
+        | "function"
+        | "function-expression-name"
+        | "global"
+        | "module"
+        | "switch"
+        | "with"
+        | "TDZ";
+    isStrict: boolean;
+    upper: Scope | null;
+    childScopes: Scope[];
+    variableScope: Scope;
+    block: estree.Node;
+    variables: Variable[];
+    set: Map<string, Variable>;
+    references: Reference[];
+    through: Reference[];
+    functionExpressionScope: boolean;
+}
+
+export class Variable implements eslint.Scope.Variable {
+    name: string;
+    scope: Scope;
+    identifiers: estree.Identifier[];
+    references: Reference[];
+    defs: eslint.Scope.Definition[];
+}
+
+export class Reference implements eslint.Scope.Reference {
+    identifier: estree.Identifier;
+    from: Scope;
+    resolved: Variable | null;
+    writeExpr: estree.Node | null;
+    init: boolean;
+
+    isWrite(): boolean;
+    isRead(): boolean;
+    isWriteOnly(): boolean;
+    isReadOnly(): boolean;
+    isReadWrite(): boolean;
+}
+
+export interface AnalysisOptions {
+    optimistic?: boolean;
+    directive?: boolean;
+    ignoreEval?: boolean;
+    nodejsScope?: boolean;
+    impliedStrict?: boolean;
+    fallback?: string | ((node: {}) => string[]);
+    sourceType?: "script" | "module";
+    ecmaVersion?: number;
+}
+
+export function analyze(ast: {}, options?: AnalysisOptions): ScopeManager;
+
+````
+
+### Additional Details
+ * Last updated: Mon, 06 Nov 2023 22:41:05 GMT
+ * Dependencies: [@types/eslint](https://npmjs.com/package/@types/eslint), [@types/estree](https://npmjs.com/package/@types/estree)
+
+# Credits
+These definitions were written by [Toru Nagashima](https://github.com/mysticatea).

node_modules/@types/eslint-scope/index.d.ts

@@ -0,0 +1,71 @@
+import * as eslint from "eslint";
+import * as estree from "estree";
+
+export const version: string;
+
+export class ScopeManager implements eslint.Scope.ScopeManager {
+    scopes: Scope[];
+    globalScope: Scope;
+    acquire(node: {}, inner?: boolean): Scope | null;
+    getDeclaredVariables(node: {}): Variable[];
+}
+
+export class Scope implements eslint.Scope.Scope {
+    type:
+        | "block"
+        | "catch"
+        | "class"
+        | "for"
+        | "function"
+        | "function-expression-name"
+        | "global"
+        | "module"
+        | "switch"
+        | "with"
+        | "TDZ";
+    isStrict: boolean;
+    upper: Scope | null;
+    childScopes: Scope[];
+    variableScope: Scope;
+    block: estree.Node;
+    variables: Variable[];
+    set: Map<string, Variable>;
+    references: Reference[];
+    through: Reference[];
+    functionExpressionScope: boolean;
+}
+
+export class Variable implements eslint.Scope.Variable {
+    name: string;
+    scope: Scope;
+    identifiers: estree.Identifier[];
+    references: Reference[];
+    defs: eslint.Scope.Definition[];
+}
+
+export class Reference implements eslint.Scope.Reference {
+    identifier: estree.Identifier;
+    from: Scope;
+    resolved: Variable | null;
+    writeExpr: estree.Node | null;
+    init: boolean;
+
+    isWrite(): boolean;
+    isRead(): boolean;
+    isWriteOnly(): boolean;
+    isReadOnly(): boolean;
+    isReadWrite(): boolean;
+}
+
+export interface AnalysisOptions {
+    optimistic?: boolean;
+    directive?: boolean;
+    ignoreEval?: boolean;
+    nodejsScope?: boolean;
+    impliedStrict?: boolean;
+    fallback?: string | ((node: {}) => string[]);
+    sourceType?: "script" | "module";
+    ecmaVersion?: number;
+}
+
+export function analyze(ast: {}, options?: AnalysisOptions): ScopeManager;

node_modules/@types/eslint-scope/package.json

@@ -0,0 +1,28 @@
+{
+    "name": "@types/eslint-scope",
+    "version": "3.7.7",
+    "description": "TypeScript definitions for eslint-scope",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/eslint-scope",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Toru Nagashima",
+            "githubUsername": "mysticatea",
+            "url": "https://github.com/mysticatea"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/eslint-scope"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/eslint": "*",
+        "@types/estree": "*"
+    },
+    "typesPublisherContentHash": "49eee35b78c19e2c83bc96ce190c7a88329006f876dd7f1fb378c1e8034fc8f2",
+    "typeScriptVersion": "4.5"
+}

node_modules/@types/eslint/LICENSE

@@ -0,0 +1,21 @@
+    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/eslint/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/eslint`
+
+# Summary
+This package contains type definitions for eslint (https://eslint.org).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/eslint.
+
+### Additional Details
+ * Last updated: Tue, 19 Mar 2024 09:36:07 GMT
+ * Dependencies: [@types/estree](https://npmjs.com/package/@types/estree), [@types/json-schema](https://npmjs.com/package/@types/json-schema)
+
+# Credits
+These definitions were written by [Pierre-Marie Dartus](https://github.com/pmdartus), [Jed Fox](https://github.com/j-f1), [Saad Quadri](https://github.com/saadq), [Jason Kwok](https://github.com/JasonHK), [Brad Zacher](https://github.com/bradzacher), [JounQin](https://github.com/JounQin), and [Bryan Mishkin](https://github.com/bmish).

node_modules/@types/eslint/helpers.d.ts

@@ -0,0 +1,3 @@
+type Prepend<Tuple extends any[], Addend> = ((_: Addend, ..._1: Tuple) => any) extends (..._: infer Result) => any
+    ? Result
+    : never;

node_modules/@types/eslint/package.json

@@ -0,0 +1,70 @@
+{
+    "name": "@types/eslint",
+    "version": "8.56.6",
+    "description": "TypeScript definitions for eslint",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/eslint",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Pierre-Marie Dartus",
+            "githubUsername": "pmdartus",
+            "url": "https://github.com/pmdartus"
+        },
+        {
+            "name": "Jed Fox",
+            "githubUsername": "j-f1",
+            "url": "https://github.com/j-f1"
+        },
+        {
+            "name": "Saad Quadri",
+            "githubUsername": "saadq",
+            "url": "https://github.com/saadq"
+        },
+        {
+            "name": "Jason Kwok",
+            "githubUsername": "JasonHK",
+            "url": "https://github.com/JasonHK"
+        },
+        {
+            "name": "Brad Zacher",
+            "githubUsername": "bradzacher",
+            "url": "https://github.com/bradzacher"
+        },
+        {
+            "name": "JounQin",
+            "githubUsername": "JounQin",
+            "url": "https://github.com/JounQin"
+        },
+        {
+            "name": "Bryan Mishkin",
+            "githubUsername": "bmish",
+            "url": "https://github.com/bmish"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./index.d.ts"
+        },
+        "./use-at-your-own-risk": {
+            "types": "./use-at-your-own-risk.d.ts"
+        },
+        "./rules": {
+            "types": "./rules/index.d.ts"
+        },
+        "./package.json": "./package.json"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/eslint"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/estree": "*",
+        "@types/json-schema": "*"
+    },
+    "typesPublisherContentHash": "bfce2c99dc7236752e3b1b9610a7f210f49fe944f07b5a0eb303f1993afed76c",
+    "typeScriptVersion": "4.7"
+}

node_modules/@types/eslint/rules/deprecated.d.ts

@@ -0,0 +1,267 @@
+import { Linter } from "../index";
+
+export interface Deprecated extends Linter.RulesRecord {
+    /**
+     * Rule to enforce consistent indentation.
+     *
+     * @since 4.0.0-alpha.0
+     * @deprecated since 4.0.0, use [`indent`](https://eslint.org/docs/rules/indent) instead.
+     * @see https://eslint.org/docs/rules/indent-legacy
+     */
+    "indent-legacy": Linter.RuleEntry<
+        [
+            number | "tab",
+            Partial<{
+                /**
+                 * @default 0
+                 */
+                SwitchCase: number;
+                /**
+                 * @default 1
+                 */
+                VariableDeclarator:
+                    | Partial<{
+                        /**
+                         * @default 1
+                         */
+                        var: number | "first";
+                        /**
+                         * @default 1
+                         */
+                        let: number | "first";
+                        /**
+                         * @default 1
+                         */
+                        const: number | "first";
+                    }>
+                    | number
+                    | "first";
+                /**
+                 * @default 1
+                 */
+                outerIIFEBody: number;
+                /**
+                 * @default 1
+                 */
+                MemberExpression: number | "off";
+                /**
+                 * @default { parameters: 1, body: 1 }
+                 */
+                FunctionDeclaration: Partial<{
+                    /**
+                     * @default 1
+                     */
+                    parameters: number | "first" | "off";
+                    /**
+                     * @default 1
+                     */
+                    body: number;
+                }>;
+                /**
+                 * @default { parameters: 1, body: 1 }
+                 */
+                FunctionExpression: Partial<{
+                    /**
+                     * @default 1
+                     */
+                    parameters: number | "first" | "off";
+                    /**
+                     * @default 1
+                     */
+                    body: number;
+                }>;
+                /**
+                 * @default { arguments: 1 }
+                 */
+                CallExpression: Partial<{
+                    /**
+                     * @default 1
+                     */
+                    arguments: number | "first" | "off";
+                }>;
+                /**
+                 * @default 1
+                 */
+                ArrayExpression: number | "first" | "off";
+                /**
+                 * @default 1
+                 */
+                ObjectExpression: number | "first" | "off";
+                /**
+                 * @default 1
+                 */
+                ImportDeclaration: number | "first" | "off";
+                /**
+                 * @default false
+                 */
+                flatTernaryExpressions: boolean;
+                ignoredNodes: string[];
+                /**
+                 * @default false
+                 */
+                ignoreComments: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require or disallow newlines around directives.
+     *
+     * @since 3.5.0
+     * @deprecated since 4.0.0, use [`padding-line-between-statements`](https://eslint.org/docs/rules/padding-line-between-statements) instead.
+     * @see https://eslint.org/docs/rules/lines-around-directive
+     */
+    "lines-around-directive": Linter.RuleEntry<["always" | "never"]>;
+
+    /**
+     * Rule to require or disallow an empty line after variable declarations.
+     *
+     * @since 0.18.0
+     * @deprecated since 4.0.0, use [`padding-line-between-statements`](https://eslint.org/docs/rules/padding-line-between-statements) instead.
+     * @see https://eslint.org/docs/rules/newline-after-var
+     */
+    "newline-after-var": Linter.RuleEntry<["always" | "never"]>;
+
+    /**
+     * Rule to require an empty line before `return` statements.
+     *
+     * @since 2.3.0
+     * @deprecated since 4.0.0, use [`padding-line-between-statements`](https://eslint.org/docs/rules/padding-line-between-statements) instead.
+     * @see https://eslint.org/docs/rules/newline-before-return
+     */
+    "newline-before-return": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow shadowing of variables inside of `catch`.
+     *
+     * @since 0.0.9
+     * @deprecated since 5.1.0, use [`no-shadow`](https://eslint.org/docs/rules/no-shadow) instead.
+     * @see https://eslint.org/docs/rules/no-catch-shadow
+     */
+    "no-catch-shadow": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow reassignment of native objects.
+     *
+     * @since 0.0.9
+     * @deprecated since 3.3.0, use [`no-global-assign`](https://eslint.org/docs/rules/no-global-assign) instead.
+     * @see https://eslint.org/docs/rules/no-native-reassign
+     */
+    "no-native-reassign": Linter.RuleEntry<
+        [
+            Partial<{
+                exceptions: string[];
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow negating the left operand in `in` expressions.
+     *
+     * @since 0.1.2
+     * @deprecated since 3.3.0, use [`no-unsafe-negation`](https://eslint.org/docs/rules/no-unsafe-negation) instead.
+     * @see https://eslint.org/docs/rules/no-negated-in-lhs
+     */
+    "no-negated-in-lhs": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow spacing between function identifiers and their applications.
+     *
+     * @since 0.1.2
+     * @deprecated since 3.3.0, use [`func-call-spacing`](https://eslint.org/docs/rules/func-call-spacing) instead.
+     * @see https://eslint.org/docs/rules/no-spaced-func
+     */
+    "no-spaced-func": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to suggest using `Reflect` methods where applicable.
+     *
+     * @since 1.0.0-rc-2
+     * @deprecated since 3.9.0
+     * @see https://eslint.org/docs/rules/prefer-reflect
+     */
+    "prefer-reflect": Linter.RuleEntry<
+        [
+            Partial<{
+                exceptions: string[];
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require JSDoc comments.
+     *
+     * @since 1.4.0
+     * @deprecated since 5.10.0
+     * @see https://eslint.org/docs/rules/require-jsdoc
+     */
+    "require-jsdoc": Linter.RuleEntry<
+        [
+            Partial<{
+                require: Partial<{
+                    /**
+                     * @default true
+                     */
+                    FunctionDeclaration: boolean;
+                    /**
+                     * @default false
+                     */
+                    MethodDefinition: boolean;
+                    /**
+                     * @default false
+                     */
+                    ClassDeclaration: boolean;
+                    /**
+                     * @default false
+                     */
+                    ArrowFunctionExpression: boolean;
+                    /**
+                     * @default false
+                     */
+                    FunctionExpression: boolean;
+                }>;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce valid JSDoc comments.
+     *
+     * @since 0.4.0
+     * @deprecated since 5.10.0
+     * @see https://eslint.org/docs/rules/valid-jsdoc
+     */
+    "valid-jsdoc": Linter.RuleEntry<
+        [
+            Partial<{
+                prefer: Record<string, string>;
+                preferType: Record<string, string>;
+                /**
+                 * @default true
+                 */
+                requireReturn: boolean;
+                /**
+                 * @default true
+                 */
+                requireReturnType: boolean;
+                /**
+                 * @remarks
+                 * Also accept for regular expression pattern
+                 */
+                matchDescription: string;
+                /**
+                 * @default true
+                 */
+                requireParamDescription: boolean;
+                /**
+                 * @default true
+                 */
+                requireReturnDescription: boolean;
+                /**
+                 * @default true
+                 */
+                requireParamType: boolean;
+            }>,
+        ]
+    >;
+}

node_modules/@types/eslint/rules/ecmascript-6.d.ts

@@ -0,0 +1,534 @@
+import { Linter } from "../index";
+
+export interface ECMAScript6 extends Linter.RulesRecord {
+    /**
+     * Rule to require braces around arrow function bodies.
+     *
+     * @since 1.8.0
+     * @see https://eslint.org/docs/rules/arrow-body-style
+     */
+    "arrow-body-style":
+        | Linter.RuleEntry<
+            [
+                "as-needed",
+                Partial<{
+                    /**
+                     * @default false
+                     */
+                    requireReturnForObjectLiteral: boolean;
+                }>,
+            ]
+        >
+        | Linter.RuleEntry<["always" | "never"]>;
+
+    /**
+     * Rule to require parentheses around arrow function arguments.
+     *
+     * @since 1.0.0-rc-1
+     * @see https://eslint.org/docs/rules/arrow-parens
+     */
+    "arrow-parens":
+        | Linter.RuleEntry<["always"]>
+        | Linter.RuleEntry<
+            [
+                "as-needed",
+                Partial<{
+                    /**
+                     * @default false
+                     */
+                    requireForBlockBody: boolean;
+                }>,
+            ]
+        >;
+
+    /**
+     * Rule to enforce consistent spacing before and after the arrow in arrow functions.
+     *
+     * @since 1.0.0-rc-1
+     * @see https://eslint.org/docs/rules/arrow-spacing
+     */
+    "arrow-spacing": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require `super()` calls in constructors.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.24.0
+     * @see https://eslint.org/docs/rules/constructor-super
+     */
+    "constructor-super": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to enforce consistent spacing around `*` operators in generator functions.
+     *
+     * @since 0.17.0
+     * @see https://eslint.org/docs/rules/generator-star-spacing
+     */
+    "generator-star-spacing": Linter.RuleEntry<
+        [
+            | Partial<{
+                before: boolean;
+                after: boolean;
+                named:
+                    | Partial<{
+                        before: boolean;
+                        after: boolean;
+                    }>
+                    | "before"
+                    | "after"
+                    | "both"
+                    | "neither";
+                anonymous:
+                    | Partial<{
+                        before: boolean;
+                        after: boolean;
+                    }>
+                    | "before"
+                    | "after"
+                    | "both"
+                    | "neither";
+                method:
+                    | Partial<{
+                        before: boolean;
+                        after: boolean;
+                    }>
+                    | "before"
+                    | "after"
+                    | "both"
+                    | "neither";
+            }>
+            | "before"
+            | "after"
+            | "both"
+            | "neither",
+        ]
+    >;
+
+    /**
+     * Require or disallow logical assignment operator shorthand.
+     *
+     * @since 8.24.0
+     * @see https://eslint.org/docs/rules/logical-assignment-operators
+     */
+    "logical-assignment-operators":
+        | Linter.RuleEntry<
+            [
+                "always",
+                Partial<{
+                    /**
+                     * @default false
+                     */
+                    enforceForIfStatements: boolean;
+                }>,
+            ]
+        >
+        | Linter.RuleEntry<["never"]>;
+
+    /**
+     * Rule to disallow reassigning class members.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 1.0.0-rc-1
+     * @see https://eslint.org/docs/rules/no-class-assign
+     */
+    "no-class-assign": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow arrow functions where they could be confused with comparisons.
+     *
+     * @since 2.0.0-alpha-2
+     * @see https://eslint.org/docs/rules/no-confusing-arrow
+     */
+    "no-confusing-arrow": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default true
+                 */
+                allowParens: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow reassigning `const` variables.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 1.0.0-rc-1
+     * @see https://eslint.org/docs/rules/no-const-assign
+     */
+    "no-const-assign": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow duplicate class members.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 1.2.0
+     * @see https://eslint.org/docs/rules/no-dupe-class-members
+     */
+    "no-dupe-class-members": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow duplicate module imports.
+     *
+     * @since 2.5.0
+     * @see https://eslint.org/docs/rules/no-duplicate-imports
+     */
+    "no-duplicate-imports": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                includeExports: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow `new` operators with the `Symbol` object.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 2.0.0-beta.1
+     * @see https://eslint.org/docs/rules/no-new-symbol
+     */
+    "no-new-symbol": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow specified modules when loaded by `import`.
+     *
+     * @since 2.0.0-alpha-1
+     * @see https://eslint.org/docs/rules/no-restricted-imports
+     */
+    "no-restricted-imports": Linter.RuleEntry<
+        [
+            ...Array<
+                | string
+                | {
+                    name: string;
+                    importNames?: string[] | undefined;
+                    message?: string | undefined;
+                }
+                | Partial<{
+                    paths: Array<
+                        | string
+                        | {
+                            name: string;
+                            importNames?: string[] | undefined;
+                            message?: string | undefined;
+                        }
+                    >;
+                    patterns: string[];
+                }>
+            >,
+        ]
+    >;
+
+    /**
+     * Rule to disallow `this`/`super` before calling `super()` in constructors.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.24.0
+     * @see https://eslint.org/docs/rules/no-this-before-super
+     */
+    "no-this-before-super": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unnecessary computed property keys in object literals.
+     *
+     * @since 2.9.0
+     * @see https://eslint.org/docs/rules/no-useless-computed-key
+     */
+    "no-useless-computed-key": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unnecessary constructors.
+     *
+     * @since 2.0.0-beta.1
+     * @see https://eslint.org/docs/rules/no-useless-constructor
+     */
+    "no-useless-constructor": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow renaming import, export, and destructured assignments to the same name.
+     *
+     * @since 2.11.0
+     * @see https://eslint.org/docs/rules/no-useless-rename
+     */
+    "no-useless-rename": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                ignoreImport: boolean;
+                /**
+                 * @default false
+                 */
+                ignoreExport: boolean;
+                /**
+                 * @default false
+                 */
+                ignoreDestructuring: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require `let` or `const` instead of `var`.
+     *
+     * @since 0.12.0
+     * @see https://eslint.org/docs/rules/no-var
+     */
+    "no-var": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require or disallow method and property shorthand syntax for object literals.
+     *
+     * @since 0.20.0
+     * @see https://eslint.org/docs/rules/object-shorthand
+     */
+    "object-shorthand":
+        | Linter.RuleEntry<
+            [
+                "always" | "methods",
+                Partial<{
+                    /**
+                     * @default false
+                     */
+                    avoidQuotes: boolean;
+                    /**
+                     * @default false
+                     */
+                    ignoreConstructors: boolean;
+                    /**
+                     * @default false
+                     */
+                    avoidExplicitReturnArrows: boolean;
+                }>,
+            ]
+        >
+        | Linter.RuleEntry<
+            [
+                "properties",
+                Partial<{
+                    /**
+                     * @default false
+                     */
+                    avoidQuotes: boolean;
+                }>,
+            ]
+        >
+        | Linter.RuleEntry<["never" | "consistent" | "consistent-as-needed"]>;
+
+    /**
+     * Rule to require using arrow functions for callbacks.
+     *
+     * @since 1.2.0
+     * @see https://eslint.org/docs/rules/prefer-arrow-callback
+     */
+    "prefer-arrow-callback": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                allowNamedFunctions: boolean;
+                /**
+                 * @default true
+                 */
+                allowUnboundThis: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require `const` declarations for variables that are never reassigned after declared.
+     *
+     * @since 0.23.0
+     * @see https://eslint.org/docs/rules/prefer-const
+     */
+    "prefer-const": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default 'any'
+                 */
+                destructuring: "any" | "all";
+                /**
+                 * @default false
+                 */
+                ignoreReadBeforeAssign: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require destructuring from arrays and/or objects.
+     *
+     * @since 3.13.0
+     * @see https://eslint.org/docs/rules/prefer-destructuring
+     */
+    "prefer-destructuring": Linter.RuleEntry<
+        [
+            Partial<
+                | {
+                    VariableDeclarator: Partial<{
+                        array: boolean;
+                        object: boolean;
+                    }>;
+                    AssignmentExpression: Partial<{
+                        array: boolean;
+                        object: boolean;
+                    }>;
+                }
+                | {
+                    array: boolean;
+                    object: boolean;
+                }
+            >,
+            Partial<{
+                enforceForRenamedProperties: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Disallow the use of `Math.pow` in favor of the `**` operator.
+     *
+     * @since 6.7.0
+     * @see https://eslint.org/docs/latest/rules/prefer-exponentiation-operator
+     */
+    "prefer-exponentiation-operator": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow `parseInt()` and `Number.parseInt()` in favor of binary, octal, and hexadecimal literals.
+     *
+     * @since 3.5.0
+     * @see https://eslint.org/docs/rules/prefer-numeric-literals
+     */
+    "prefer-numeric-literals": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require rest parameters instead of `arguments`.
+     *
+     * @since 2.0.0-alpha-1
+     * @see https://eslint.org/docs/rules/prefer-rest-params
+     */
+    "prefer-rest-params": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require spread operators instead of `.apply()`.
+     *
+     * @since 1.0.0-rc-1
+     * @see https://eslint.org/docs/rules/prefer-spread
+     */
+    "prefer-spread": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require template literals instead of string concatenation.
+     *
+     * @since 1.2.0
+     * @see https://eslint.org/docs/rules/prefer-template
+     */
+    "prefer-template": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require generator functions to contain `yield`.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 1.0.0-rc-1
+     * @see https://eslint.org/docs/rules/require-yield
+     */
+    "require-yield": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to enforce spacing between rest and spread operators and their expressions.
+     *
+     * @since 2.12.0
+     * @see https://eslint.org/docs/rules/rest-spread-spacing
+     */
+    "rest-spread-spacing": Linter.RuleEntry<["never" | "always"]>;
+
+    /**
+     * Rule to enforce sorted import declarations within modules.
+     *
+     * @since 2.0.0-beta.1
+     * @see https://eslint.org/docs/rules/sort-imports
+     */
+    "sort-imports": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                ignoreCase: boolean;
+                /**
+                 * @default false
+                 */
+                ignoreDeclarationSort: boolean;
+                /**
+                 * @default false
+                 */
+                ignoreMemberSort: boolean;
+                /**
+                 * @default ['none', 'all', 'multiple', 'single']
+                 */
+                memberSyntaxSortOrder: Array<"none" | "all" | "multiple" | "single">;
+                /**
+                 * @default false
+                 */
+                allowSeparatedGroups: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to require symbol descriptions.
+     *
+     * @since 3.4.0
+     * @see https://eslint.org/docs/rules/symbol-description
+     */
+    "symbol-description": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require or disallow spacing around embedded expressions of template strings.
+     *
+     * @since 2.0.0-rc.0
+     * @see https://eslint.org/docs/rules/template-curly-spacing
+     */
+    "template-curly-spacing": Linter.RuleEntry<["never" | "always"]>;
+
+    /**
+     * Rule to require or disallow spacing around the `*` in `yield*` expressions.
+     *
+     * @since 2.0.0-alpha-1
+     * @see https://eslint.org/docs/rules/yield-star-spacing
+     */
+    "yield-star-spacing": Linter.RuleEntry<
+        [
+            | Partial<{
+                before: boolean;
+                after: boolean;
+            }>
+            | "before"
+            | "after"
+            | "both"
+            | "neither",
+        ]
+    >;
+}

node_modules/@types/eslint/rules/index.d.ts

@@ -0,0 +1,23 @@
+import { Linter } from "../index";
+
+import { BestPractices } from "./best-practices";
+import { Deprecated } from "./deprecated";
+import { ECMAScript6 } from "./ecmascript-6";
+import { NodeJSAndCommonJS } from "./node-commonjs";
+import { PossibleErrors } from "./possible-errors";
+import { StrictMode } from "./strict-mode";
+import { StylisticIssues } from "./stylistic-issues";
+import { Variables } from "./variables";
+
+export interface ESLintRules
+    extends
+        Linter.RulesRecord,
+        PossibleErrors,
+        BestPractices,
+        StrictMode,
+        Variables,
+        NodeJSAndCommonJS,
+        StylisticIssues,
+        ECMAScript6,
+        Deprecated
+{}

node_modules/@types/eslint/rules/node-commonjs.d.ts

@@ -0,0 +1,133 @@
+import { Linter } from "../index";
+
+export interface NodeJSAndCommonJS extends Linter.RulesRecord {
+    /**
+     * Rule to require `return` statements after callbacks.
+     *
+     * @since 1.0.0-rc-1
+     * @see https://eslint.org/docs/rules/callback-return
+     */
+    "callback-return": Linter.RuleEntry<[string[]]>;
+
+    /**
+     * Rule to require `require()` calls to be placed at top-level module scope.
+     *
+     * @since 1.4.0
+     * @see https://eslint.org/docs/rules/global-require
+     */
+    "global-require": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require error handling in callbacks.
+     *
+     * @since 0.4.5
+     * @see https://eslint.org/docs/rules/handle-callback-err
+     */
+    "handle-callback-err": Linter.RuleEntry<[string]>;
+
+    /**
+     * Rule to disallow use of the `Buffer()` constructor.
+     *
+     * @since 4.0.0-alpha.0
+     * @see https://eslint.org/docs/rules/no-buffer-constructor
+     */
+    "no-buffer-constructor": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow `require` calls to be mixed with regular variable declarations.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-mixed-requires
+     */
+    "no-mixed-requires": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                grouping: boolean;
+                /**
+                 * @default false
+                 */
+                allowCall: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow `new` operators with calls to `require`.
+     *
+     * @since 0.6.0
+     * @see https://eslint.org/docs/rules/no-new-require
+     */
+    "no-new-require": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow string concatenation when using `__dirname` and `__filename`.
+     *
+     * @since 0.4.0
+     * @see https://eslint.org/docs/rules/no-path-concat
+     */
+    "no-path-concat": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow the use of `process.env`.
+     *
+     * @since 0.9.0
+     * @see https://eslint.org/docs/rules/no-process-env
+     */
+    "no-process-env": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow the use of `process.exit()`.
+     *
+     * @since 0.4.0
+     * @see https://eslint.org/docs/rules/no-process-exit
+     */
+    "no-process-exit": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow specified modules when loaded by `require`.
+     *
+     * @since 0.6.0
+     * @see https://eslint.org/docs/rules/no-restricted-modules
+     */
+    "no-restricted-modules": Linter.RuleEntry<
+        [
+            ...Array<
+                | string
+                | {
+                    name: string;
+                    message?: string | undefined;
+                }
+                | Partial<{
+                    paths: Array<
+                        | string
+                        | {
+                            name: string;
+                            message?: string | undefined;
+                        }
+                    >;
+                    patterns: string[];
+                }>
+            >,
+        ]
+    >;
+
+    /**
+     * Rule to disallow synchronous methods.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-sync
+     */
+    "no-sync": Linter.RuleEntry<
+        [
+            {
+                /**
+                 * @default false
+                 */
+                allowAtRootLevel: boolean;
+            },
+        ]
+    >;
+}

node_modules/@types/eslint/rules/possible-errors.d.ts

@@ -0,0 +1,571 @@
+import { Linter } from "../index";
+
+export interface PossibleErrors extends Linter.RulesRecord {
+    /**
+     * Rule to enforce `for` loop update clause moving the counter in the right direction.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 4.0.0-beta.0
+     * @see https://eslint.org/docs/rules/for-direction
+     */
+    "for-direction": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to enforce `return` statements in getters.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 4.2.0
+     * @see https://eslint.org/docs/rules/getter-return
+     */
+    "getter-return": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                allowImplicit: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow using an async function as a `Promise` executor.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 5.3.0
+     * @see https://eslint.org/docs/rules/no-async-promise-executor
+     */
+    "no-async-promise-executor": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow `await` inside of loops.
+     *
+     * @since 3.12.0
+     * @see https://eslint.org/docs/rules/no-await-in-loop
+     */
+    "no-await-in-loop": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow comparing against `-0`.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 3.17.0
+     * @see https://eslint.org/docs/rules/no-compare-neg-zero
+     */
+    "no-compare-neg-zero": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow assignment operators in conditional statements.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-cond-assign
+     */
+    "no-cond-assign": Linter.RuleEntry<["except-parens" | "always"]>;
+
+    /**
+     * Rule to disallow the use of `console`.
+     *
+     * @since 0.0.2
+     * @see https://eslint.org/docs/rules/no-console
+     */
+    "no-console": Linter.RuleEntry<
+        [
+            Partial<{
+                allow: Array<keyof Console>;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow constant expressions in conditions.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.4.1
+     * @see https://eslint.org/docs/rules/no-constant-condition
+     */
+    "no-constant-condition": Linter.RuleEntry<
+        [
+            {
+                /**
+                 * @default true
+                 */
+                checkLoops: boolean;
+            },
+        ]
+    >;
+
+    /**
+     * Rule to disallow control characters in regular expressions.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.1.0
+     * @see https://eslint.org/docs/rules/no-control-regex
+     */
+    "no-control-regex": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow the use of `debugger`.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.2
+     * @see https://eslint.org/docs/rules/no-debugger
+     */
+    "no-debugger": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow duplicate arguments in `function` definitions.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.16.0
+     * @see https://eslint.org/docs/rules/no-dupe-args
+     */
+    "no-dupe-args": Linter.RuleEntry<[]>;
+
+    /**
+     * Disallow duplicate conditions in if-else-if chains.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 6.7.0
+     * @see https://eslint.org/docs/rules/no-dupe-else-if
+     */
+    "no-dupe-else-if": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow duplicate keys in object literals.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-dupe-keys
+     */
+    "no-dupe-keys": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow a duplicate case label.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.17.0
+     * @see https://eslint.org/docs/rules/no-duplicate-case
+     */
+    "no-duplicate-case": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow empty block statements.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.2
+     * @see https://eslint.org/docs/rules/no-empty
+     */
+    "no-empty": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                allowEmptyCatch: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow empty character classes in regular expressions.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.22.0
+     * @see https://eslint.org/docs/rules/no-empty-character-class
+     */
+    "no-empty-character-class": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow reassigning exceptions in `catch` clauses.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-ex-assign
+     */
+    "no-ex-assign": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unnecessary boolean casts.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.4.0
+     * @see https://eslint.org/docs/rules/no-extra-boolean-cast
+     */
+    "no-extra-boolean-cast": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unnecessary parentheses.
+     *
+     * @since 0.1.4
+     * @see https://eslint.org/docs/rules/no-extra-parens
+     */
+    "no-extra-parens":
+        | Linter.RuleEntry<
+            [
+                "all",
+                Partial<{
+                    /**
+                     * @default true,
+                     */
+                    conditionalAssign: boolean;
+                    /**
+                     * @default true
+                     */
+                    returnAssign: boolean;
+                    /**
+                     * @default true
+                     */
+                    nestedBinaryExpressions: boolean;
+                    /**
+                     * @default 'none'
+                     */
+                    ignoreJSX: "none" | "all" | "multi-line" | "single-line";
+                    /**
+                     * @default true
+                     */
+                    enforceForArrowConditionals: boolean;
+                }>,
+            ]
+        >
+        | Linter.RuleEntry<["functions"]>;
+
+    /**
+     * Rule to disallow unnecessary semicolons.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-extra-semi
+     */
+    "no-extra-semi": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow reassigning `function` declarations.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-func-assign
+     */
+    "no-func-assign": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow variable or `function` declarations in nested blocks.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.6.0
+     * @see https://eslint.org/docs/rules/no-inner-declarations
+     */
+    "no-inner-declarations": Linter.RuleEntry<["functions" | "both"]>;
+
+    /**
+     * Rule to disallow invalid regular expression strings in `RegExp` constructors.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.1.4
+     * @see https://eslint.org/docs/rules/no-invalid-regexp
+     */
+    "no-invalid-regexp": Linter.RuleEntry<
+        [
+            Partial<{
+                allowConstructorFlags: string[];
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow irregular whitespace.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.9.0
+     * @see https://eslint.org/docs/rules/no-irregular-whitespace
+     */
+    "no-irregular-whitespace": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default true
+                 */
+                skipStrings: boolean;
+                /**
+                 * @default false
+                 */
+                skipComments: boolean;
+                /**
+                 * @default false
+                 */
+                skipRegExps: boolean;
+                /**
+                 * @default false
+                 */
+                skipTemplates: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Disallow literal numbers that lose precision.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 7.1.0
+     * @see https://eslint.org/docs/latest/rules/no-loss-of-precision
+     */
+    "no-loss-of-precision": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow characters which are made with multiple code points in character class syntax.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 5.3.0
+     * @see https://eslint.org/docs/rules/no-misleading-character-class
+     */
+    "no-misleading-character-class": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow calling global object properties as functions.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-obj-calls
+     */
+    "no-obj-calls": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow returning values from Promise executor functions.
+     *
+     * @since 7.3.0
+     * @see https://eslint.org/docs/rules/no-promise-executor-return
+     */
+    "no-promise-executor-return": Linter.RuleEntry<[
+        {
+            /**
+             * @default false
+             */
+            allowVoid?: boolean;
+        },
+    ]>;
+
+    /**
+     * Rule to disallow use of `Object.prototypes` builtins directly.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 2.11.0
+     * @see https://eslint.org/docs/rules/no-prototype-builtins
+     */
+    "no-prototype-builtins": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow multiple spaces in regular expressions.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.4.0
+     * @see https://eslint.org/docs/rules/no-regex-spaces
+     */
+    "no-regex-spaces": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow sparse arrays.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.4.0
+     * @see https://eslint.org/docs/rules/no-sparse-arrays
+     */
+    "no-sparse-arrays": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow template literal placeholder syntax in regular strings.
+     *
+     * @since 3.3.0
+     * @see https://eslint.org/docs/rules/no-template-curly-in-string
+     */
+    "no-template-curly-in-string": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow confusing multiline expressions.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.24.0
+     * @see https://eslint.org/docs/rules/no-unexpected-multiline
+     */
+    "no-unexpected-multiline": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unreachable code after `return`, `throw`, `continue`, and `break` statements.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.6
+     * @see https://eslint.org/docs/rules/no-unreachable
+     */
+    "no-unreachable": Linter.RuleEntry<[]>;
+
+    /**
+     * Disallow loops with a body that allows only one iteration.
+     *
+     * @since 7.3.0
+     * @see https://eslint.org/docs/latest/rules/no-unreachable-loop
+     */
+    "no-unreachable-loop": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default []
+                 */
+                ignore: "WhileStatement" | "DoWhileStatement" | "ForStatement" | "ForInStatement" | "ForOfStatement";
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow control flow statements in `finally` blocks.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 2.9.0
+     * @see https://eslint.org/docs/rules/no-unsafe-finally
+     */
+    "no-unsafe-finally": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow negating the left operand of relational operators.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 3.3.0
+     * @see https://eslint.org/docs/rules/no-unsafe-negation
+     */
+    "no-unsafe-negation": Linter.RuleEntry<[]>;
+
+    /**
+     * Disallow use of optional chaining in contexts where the `undefined` value is not allowed.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 7.15.0
+     * @see https://eslint.org/docs/rules/no-unsafe-optional-chaining
+     */
+    "no-unsafe-optional-chaining": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                disallowArithmeticOperators: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow assignments that can lead to race conditions due to usage of `await` or `yield`.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 5.3.0
+     * @see https://eslint.org/docs/rules/require-atomic-updates
+     */
+    "require-atomic-updates": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to require calls to `isNaN()` when checking for `NaN`.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.6
+     * @see https://eslint.org/docs/rules/use-isnan
+     */
+    "use-isnan": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default true
+                 */
+                enforceForSwitchCase: boolean;
+                /**
+                 * @default true
+                 */
+                enforceForIndexOf: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to enforce comparing `typeof` expressions against valid strings.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.5.0
+     * @see https://eslint.org/docs/rules/valid-typeof
+     */
+    "valid-typeof": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                requireStringLiterals: boolean;
+            }>,
+        ]
+    >;
+}

node_modules/@types/eslint/rules/strict-mode.d.ts

@@ -0,0 +1,11 @@
+import { Linter } from "../index";
+
+export interface StrictMode extends Linter.RulesRecord {
+    /**
+     * Rule to require or disallow strict mode directives.
+     *
+     * @since 0.1.0
+     * @see https://eslint.org/docs/rules/strict
+     */
+    strict: Linter.RuleEntry<["safe" | "global" | "function" | "never"]>;
+}

node_modules/@types/eslint/rules/variables.d.ts

@@ -0,0 +1,194 @@
+import { Linter } from "../index";
+
+export interface Variables extends Linter.RulesRecord {
+    /**
+     * Rule to require or disallow initialization in variable declarations.
+     *
+     * @since 1.0.0-rc-1
+     * @see https://eslint.org/docs/rules/init-declarations
+     */
+    "init-declarations":
+        | Linter.RuleEntry<["always"]>
+        | Linter.RuleEntry<
+            [
+                "never",
+                Partial<{
+                    ignoreForLoopInit: boolean;
+                }>,
+            ]
+        >;
+
+    /**
+     * Rule to disallow deleting variables.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-delete-var
+     */
+    "no-delete-var": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow labels that share a name with a variable.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-label-var
+     */
+    "no-label-var": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow specified global variables.
+     *
+     * @since 2.3.0
+     * @see https://eslint.org/docs/rules/no-restricted-globals
+     */
+    "no-restricted-globals": Linter.RuleEntry<
+        [
+            ...Array<
+                | string
+                | {
+                    name: string;
+                    message?: string | undefined;
+                }
+            >,
+        ]
+    >;
+
+    /**
+     * Rule to disallow variable declarations from shadowing variables declared in the outer scope.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-shadow
+     */
+    "no-shadow": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                builtinGlobals: boolean;
+                /**
+                 * @default 'functions'
+                 */
+                hoist: "functions" | "all" | "never";
+                allow: string[];
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow identifiers from shadowing restricted names.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.1.4
+     * @see https://eslint.org/docs/rules/no-shadow-restricted-names
+     */
+    "no-shadow-restricted-names": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow the use of undeclared variables unless mentioned in `global` comments.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-undef
+     */
+    "no-undef": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                typeof: boolean;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow initializing variables to `undefined`.
+     *
+     * @since 0.0.6
+     * @see https://eslint.org/docs/rules/no-undef-init
+     */
+    "no-undef-init": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow the use of `undefined` as an identifier.
+     *
+     * @since 0.7.1
+     * @see https://eslint.org/docs/rules/no-undefined
+     */
+    "no-undefined": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow unused variables.
+     *
+     * @remarks
+     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-unused-vars
+     */
+    "no-unused-vars": Linter.RuleEntry<
+        [
+            | "all"
+            | "local"
+            | Partial<{
+                /**
+                 * @default 'all'
+                 */
+                vars: "all" | "local";
+                varsIgnorePattern: string;
+                /**
+                 * @default 'after-used'
+                 */
+                args: "after-used" | "all" | "none";
+                /**
+                 * @default false
+                 */
+                ignoreRestSiblings: boolean;
+                argsIgnorePattern: string;
+                /**
+                 * @default 'none'
+                 */
+                caughtErrors: "none" | "all";
+                caughtErrorsIgnorePattern: string;
+                destructuredArrayIgnorePattern: string;
+            }>,
+        ]
+    >;
+
+    /**
+     * Rule to disallow the use of variables before they are defined.
+     *
+     * @since 0.0.9
+     * @see https://eslint.org/docs/rules/no-use-before-define
+     */
+    "no-use-before-define": Linter.RuleEntry<
+        [
+            | Partial<{
+                /**
+                 * @default true
+                 */
+                functions: boolean;
+                /**
+                 * @default true
+                 */
+                classes: boolean;
+                /**
+                 * @default true
+                 */
+                variables: boolean;
+                /**
+                 * @default false
+                 */
+                allowNamedExports: boolean;
+            }>
+            | "nofunc",
+        ]
+    >;
+}

node_modules/@types/eslint/use-at-your-own-risk.d.ts

@@ -0,0 +1,19 @@
+/** @deprecated */
+export const builtinRules: Map<string, import("./index.js").Rule.RuleModule>;
+/** @deprecated */
+export class FileEnumerator {
+    constructor(
+        params?: {
+            cwd?: string;
+            configArrayFactory?: any;
+            extensions?: any;
+            globInputPaths?: boolean;
+            errorOnUnmatchedPattern?: boolean;
+            ignore?: boolean;
+        },
+    );
+    isTargetPath(filePath: string, providedConfig?: any): boolean;
+    iterateFiles(
+        patternOrPatterns: string | string[],
+    ): IterableIterator<{ config: any; filePath: string; ignored: boolean }>;
+}

node_modules/@types/estree-jsx/LICENSE

@@ -0,0 +1,21 @@
+    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/estree-jsx/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/estree-jsx`
+
+# Summary
+This package contains type definitions for estree-jsx (https://github.com/facebook/jsx).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/estree-jsx.
+
+### Additional Details
+ * Last updated: Fri, 23 Feb 2024 02:11:41 GMT
+ * Dependencies: [@types/estree](https://npmjs.com/package/@types/estree)
+
+# Credits
+These definitions were written by [Tony Ross](https://github.com/antross).

node_modules/@types/estree-jsx/index.d.ts

@@ -0,0 +1,114 @@
+// Based on https://github.com/facebook/jsx/blob/master/AST.md.
+// Extends existing types for ESTree AST from `@types/estree`.
+
+import { BaseExpression, BaseNode, Expression, Literal } from "estree";
+
+export * from "estree";
+
+declare module "estree" {
+    interface ExpressionMap {
+        JSXElement: JSXElement;
+        JSXFragment: JSXFragment;
+    }
+
+    interface NodeMap {
+        JSXIdentifier: JSXIdentifier;
+        JSXNamespacedName: JSXNamespacedName;
+        JSXMemberExpression: JSXMemberExpression;
+        JSXEmptyExpression: JSXEmptyExpression;
+        JSXExpressionContainer: JSXExpressionContainer;
+        JSXSpreadAttribute: JSXSpreadAttribute;
+        JSXAttribute: JSXAttribute;
+        JSXOpeningElement: JSXOpeningElement;
+        JSXOpeningFragment: JSXOpeningFragment;
+        JSXClosingElement: JSXClosingElement;
+        JSXClosingFragment: JSXClosingFragment;
+        JSXElement: JSXElement;
+        JSXFragment: JSXFragment;
+        JSXText: JSXText;
+    }
+}
+
+export interface JSXIdentifier extends BaseNode {
+    type: "JSXIdentifier";
+    name: string;
+}
+
+export interface JSXMemberExpression extends BaseExpression {
+    type: "JSXMemberExpression";
+    object: JSXMemberExpression | JSXIdentifier;
+    property: JSXIdentifier;
+}
+
+export interface JSXNamespacedName extends BaseExpression {
+    type: "JSXNamespacedName";
+    namespace: JSXIdentifier;
+    name: JSXIdentifier;
+}
+
+export interface JSXEmptyExpression extends BaseNode {
+    type: "JSXEmptyExpression";
+}
+
+export interface JSXExpressionContainer extends BaseNode {
+    type: "JSXExpressionContainer";
+    expression: Expression | JSXEmptyExpression;
+}
+
+export interface JSXSpreadChild extends BaseNode {
+    type: "JSXSpreadChild";
+    expression: Expression;
+}
+
+interface JSXBoundaryElement extends BaseNode {
+    name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
+}
+
+export interface JSXOpeningElement extends JSXBoundaryElement {
+    type: "JSXOpeningElement";
+    attributes: Array<JSXAttribute | JSXSpreadAttribute>;
+    selfClosing: boolean;
+}
+
+export interface JSXClosingElement extends JSXBoundaryElement {
+    type: "JSXClosingElement";
+}
+
+export interface JSXAttribute extends BaseNode {
+    type: "JSXAttribute";
+    name: JSXIdentifier | JSXNamespacedName;
+    value: Literal | JSXExpressionContainer | JSXElement | JSXFragment | null;
+}
+
+export interface JSXSpreadAttribute extends BaseNode {
+    type: "JSXSpreadAttribute";
+    argument: Expression;
+}
+
+export interface JSXText extends BaseNode {
+    type: "JSXText";
+    value: string;
+    raw: string;
+}
+
+export interface JSXElement extends BaseExpression {
+    type: "JSXElement";
+    openingElement: JSXOpeningElement;
+    children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>;
+    closingElement: JSXClosingElement | null;
+}
+
+export interface JSXFragment extends BaseExpression {
+    type: "JSXFragment";
+    openingFragment: JSXOpeningFragment;
+    children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>;
+    closingFragment: JSXClosingFragment;
+}
+
+export interface JSXOpeningFragment extends BaseNode {
+    type: "JSXOpeningFragment";
+}
+
+export interface JSXClosingFragment extends BaseNode {
+    type: "JSXClosingFragment";
+}

node_modules/@types/estree-jsx/package.json

@@ -0,0 +1,27 @@
+{
+    "name": "@types/estree-jsx",
+    "version": "1.0.5",
+    "description": "TypeScript definitions for estree-jsx",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/estree-jsx",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Tony Ross",
+            "githubUsername": "antross",
+            "url": "https://github.com/antross"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/estree-jsx"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/estree": "*"
+    },
+    "typesPublisherContentHash": "42fda803cc34f935c5a60a45e66b78e18fac56ef350d2d47c00759e16d4fef7f",
+    "typeScriptVersion": "4.6"
+}

node_modules/@types/estree/LICENSE

@@ -0,0 +1,21 @@
+    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/estree/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/estree`
+
+# Summary
+This package contains type definitions for estree (https://github.com/estree/estree).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/estree.
+
+### Additional Details
+ * Last updated: Mon, 06 Nov 2023 22:41:05 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [RReverser](https://github.com/RReverser).

node_modules/@types/estree/flow.d.ts

@@ -0,0 +1,167 @@
+declare namespace ESTree {
+    interface FlowTypeAnnotation extends Node {}
+
+    interface FlowBaseTypeAnnotation extends FlowTypeAnnotation {}
+
+    interface FlowLiteralTypeAnnotation extends FlowTypeAnnotation, Literal {}
+
+    interface FlowDeclaration extends Declaration {}
+
+    interface AnyTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+    interface ArrayTypeAnnotation extends FlowTypeAnnotation {
+        elementType: FlowTypeAnnotation;
+    }
+
+    interface BooleanLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
+
+    interface BooleanTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+    interface ClassImplements extends Node {
+        id: Identifier;
+        typeParameters?: TypeParameterInstantiation | null;
+    }
+
+    interface ClassProperty {
+        key: Expression;
+        value?: Expression | null;
+        typeAnnotation?: TypeAnnotation | null;
+        computed: boolean;
+        static: boolean;
+    }
+
+    interface DeclareClass extends FlowDeclaration {
+        id: Identifier;
+        typeParameters?: TypeParameterDeclaration | null;
+        body: ObjectTypeAnnotation;
+        extends: InterfaceExtends[];
+    }
+
+    interface DeclareFunction extends FlowDeclaration {
+        id: Identifier;
+    }
+
+    interface DeclareModule extends FlowDeclaration {
+        id: Literal | Identifier;
+        body: BlockStatement;
+    }
+
+    interface DeclareVariable extends FlowDeclaration {
+        id: Identifier;
+    }
+
+    interface FunctionTypeAnnotation extends FlowTypeAnnotation {
+        params: FunctionTypeParam[];
+        returnType: FlowTypeAnnotation;
+        rest?: FunctionTypeParam | null;
+        typeParameters?: TypeParameterDeclaration | null;
+    }
+
+    interface FunctionTypeParam {
+        name: Identifier;
+        typeAnnotation: FlowTypeAnnotation;
+        optional: boolean;
+    }
+
+    interface GenericTypeAnnotation extends FlowTypeAnnotation {
+        id: Identifier | QualifiedTypeIdentifier;
+        typeParameters?: TypeParameterInstantiation | null;
+    }
+
+    interface InterfaceExtends extends Node {
+        id: Identifier | QualifiedTypeIdentifier;
+        typeParameters?: TypeParameterInstantiation | null;
+    }
+
+    interface InterfaceDeclaration extends FlowDeclaration {
+        id: Identifier;
+        typeParameters?: TypeParameterDeclaration | null;
+        extends: InterfaceExtends[];
+        body: ObjectTypeAnnotation;
+    }
+
+    interface IntersectionTypeAnnotation extends FlowTypeAnnotation {
+        types: FlowTypeAnnotation[];
+    }
+
+    interface MixedTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+    interface NullableTypeAnnotation extends FlowTypeAnnotation {
+        typeAnnotation: TypeAnnotation;
+    }
+
+    interface NumberLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
+
+    interface NumberTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+    interface StringLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
+
+    interface StringTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+    interface TupleTypeAnnotation extends FlowTypeAnnotation {
+        types: FlowTypeAnnotation[];
+    }
+
+    interface TypeofTypeAnnotation extends FlowTypeAnnotation {
+        argument: FlowTypeAnnotation;
+    }
+
+    interface TypeAlias extends FlowDeclaration {
+        id: Identifier;
+        typeParameters?: TypeParameterDeclaration | null;
+        right: FlowTypeAnnotation;
+    }
+
+    interface TypeAnnotation extends Node {
+        typeAnnotation: FlowTypeAnnotation;
+    }
+
+    interface TypeCastExpression extends Expression {
+        expression: Expression;
+        typeAnnotation: TypeAnnotation;
+    }
+
+    interface TypeParameterDeclaration extends Node {
+        params: Identifier[];
+    }
+
+    interface TypeParameterInstantiation extends Node {
+        params: FlowTypeAnnotation[];
+    }
+
+    interface ObjectTypeAnnotation extends FlowTypeAnnotation {
+        properties: ObjectTypeProperty[];
+        indexers: ObjectTypeIndexer[];
+        callProperties: ObjectTypeCallProperty[];
+    }
+
+    interface ObjectTypeCallProperty extends Node {
+        value: FunctionTypeAnnotation;
+        static: boolean;
+    }
+
+    interface ObjectTypeIndexer extends Node {
+        id: Identifier;
+        key: FlowTypeAnnotation;
+        value: FlowTypeAnnotation;
+        static: boolean;
+    }
+
+    interface ObjectTypeProperty extends Node {
+        key: Expression;
+        value: FlowTypeAnnotation;
+        optional: boolean;
+        static: boolean;
+    }
+
+    interface QualifiedTypeIdentifier extends Node {
+        qualification: Identifier | QualifiedTypeIdentifier;
+        id: Identifier;
+    }
+
+    interface UnionTypeAnnotation extends FlowTypeAnnotation {
+        types: FlowTypeAnnotation[];
+    }
+
+    interface VoidTypeAnnotation extends FlowBaseTypeAnnotation {}
+}

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

@@ -0,0 +1,683 @@
+// This definition file follows a somewhat unusual format. ESTree allows
+// runtime type checks based on the `type` parameter. In order to explain this
+// to typescript we want to use discriminated union types:
+// https://github.com/Microsoft/TypeScript/pull/9163
+//
+// For ESTree this is a bit tricky because the high level interfaces like
+// Node or Function are pulling double duty. We want to pass common fields down
+// to the interfaces that extend them (like Identifier or
+// ArrowFunctionExpression), but you can't extend a type union or enforce
+// common fields on them. So we've split the high level interfaces into two
+// types, a base type which passes down inherited fields, and a type union of
+// all types which extend the base type. Only the type union is exported, and
+// the union is how other types refer to the collection of inheriting types.
+//
+// This makes the definitions file here somewhat more difficult to maintain,
+// but it has the notable advantage of making ESTree much easier to use as
+// an end user.
+
+export interface BaseNodeWithoutComments {
+    // Every leaf interface that extends BaseNode must specify a type property.
+    // The type property should be a string literal. For example, Identifier
+    // has: `type: "Identifier"`
+    type: string;
+    loc?: SourceLocation | null | undefined;
+    range?: [number, number] | undefined;
+}
+
+export interface BaseNode extends BaseNodeWithoutComments {
+    leadingComments?: Comment[] | undefined;
+    trailingComments?: Comment[] | undefined;
+}
+
+export interface NodeMap {
+    AssignmentProperty: AssignmentProperty;
+    CatchClause: CatchClause;
+    Class: Class;
+    ClassBody: ClassBody;
+    Expression: Expression;
+    Function: Function;
+    Identifier: Identifier;
+    Literal: Literal;
+    MethodDefinition: MethodDefinition;
+    ModuleDeclaration: ModuleDeclaration;
+    ModuleSpecifier: ModuleSpecifier;
+    Pattern: Pattern;
+    PrivateIdentifier: PrivateIdentifier;
+    Program: Program;
+    Property: Property;
+    PropertyDefinition: PropertyDefinition;
+    SpreadElement: SpreadElement;
+    Statement: Statement;
+    Super: Super;
+    SwitchCase: SwitchCase;
+    TemplateElement: TemplateElement;
+    VariableDeclarator: VariableDeclarator;
+}
+
+export type Node = NodeMap[keyof NodeMap];
+
+export interface Comment extends BaseNodeWithoutComments {
+    type: "Line" | "Block";
+    value: string;
+}
+
+export interface SourceLocation {
+    source?: string | null | undefined;
+    start: Position;
+    end: Position;
+}
+
+export interface Position {
+    /** >= 1 */
+    line: number;
+    /** >= 0 */
+    column: number;
+}
+
+export interface Program extends BaseNode {
+    type: "Program";
+    sourceType: "script" | "module";
+    body: Array<Directive | Statement | ModuleDeclaration>;
+    comments?: Comment[] | undefined;
+}
+
+export interface Directive extends BaseNode {
+    type: "ExpressionStatement";
+    expression: Literal;
+    directive: string;
+}
+
+export interface BaseFunction extends BaseNode {
+    params: Pattern[];
+    generator?: boolean | undefined;
+    async?: boolean | undefined;
+    // The body is either BlockStatement or Expression because arrow functions
+    // can have a body that's either. FunctionDeclarations and
+    // FunctionExpressions have only BlockStatement bodies.
+    body: BlockStatement | Expression;
+}
+
+export type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+
+export type Statement =
+    | ExpressionStatement
+    | BlockStatement
+    | StaticBlock
+    | EmptyStatement
+    | DebuggerStatement
+    | WithStatement
+    | ReturnStatement
+    | LabeledStatement
+    | BreakStatement
+    | ContinueStatement
+    | IfStatement
+    | SwitchStatement
+    | ThrowStatement
+    | TryStatement
+    | WhileStatement
+    | DoWhileStatement
+    | ForStatement
+    | ForInStatement
+    | ForOfStatement
+    | Declaration;
+
+export interface BaseStatement extends BaseNode {}
+
+export interface EmptyStatement extends BaseStatement {
+    type: "EmptyStatement";
+}
+
+export interface BlockStatement extends BaseStatement {
+    type: "BlockStatement";
+    body: Statement[];
+    innerComments?: Comment[] | undefined;
+}
+
+export interface StaticBlock extends Omit<BlockStatement, "type"> {
+    type: "StaticBlock";
+}
+
+export interface ExpressionStatement extends BaseStatement {
+    type: "ExpressionStatement";
+    expression: Expression;
+}
+
+export interface IfStatement extends BaseStatement {
+    type: "IfStatement";
+    test: Expression;
+    consequent: Statement;
+    alternate?: Statement | null | undefined;
+}
+
+export interface LabeledStatement extends BaseStatement {
+    type: "LabeledStatement";
+    label: Identifier;
+    body: Statement;
+}
+
+export interface BreakStatement extends BaseStatement {
+    type: "BreakStatement";
+    label?: Identifier | null | undefined;
+}
+
+export interface ContinueStatement extends BaseStatement {
+    type: "ContinueStatement";
+    label?: Identifier | null | undefined;
+}
+
+export interface WithStatement extends BaseStatement {
+    type: "WithStatement";
+    object: Expression;
+    body: Statement;
+}
+
+export interface SwitchStatement extends BaseStatement {
+    type: "SwitchStatement";
+    discriminant: Expression;
+    cases: SwitchCase[];
+}
+
+export interface ReturnStatement extends BaseStatement {
+    type: "ReturnStatement";
+    argument?: Expression | null | undefined;
+}
+
+export interface ThrowStatement extends BaseStatement {
+    type: "ThrowStatement";
+    argument: Expression;
+}
+
+export interface TryStatement extends BaseStatement {
+    type: "TryStatement";
+    block: BlockStatement;
+    handler?: CatchClause | null | undefined;
+    finalizer?: BlockStatement | null | undefined;
+}
+
+export interface WhileStatement extends BaseStatement {
+    type: "WhileStatement";
+    test: Expression;
+    body: Statement;
+}
+
+export interface DoWhileStatement extends BaseStatement {
+    type: "DoWhileStatement";
+    body: Statement;
+    test: Expression;
+}
+
+export interface ForStatement extends BaseStatement {
+    type: "ForStatement";
+    init?: VariableDeclaration | Expression | null | undefined;
+    test?: Expression | null | undefined;
+    update?: Expression | null | undefined;
+    body: Statement;
+}
+
+export interface BaseForXStatement extends BaseStatement {
+    left: VariableDeclaration | Pattern;
+    right: Expression;
+    body: Statement;
+}
+
+export interface ForInStatement extends BaseForXStatement {
+    type: "ForInStatement";
+}
+
+export interface DebuggerStatement extends BaseStatement {
+    type: "DebuggerStatement";
+}
+
+export type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+
+export interface BaseDeclaration extends BaseStatement {}
+
+export interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
+    type: "FunctionDeclaration";
+    /** It is null when a function declaration is a part of the `export default function` statement */
+    id: Identifier | null;
+    body: BlockStatement;
+}
+
+export interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
+    id: Identifier;
+}
+
+export interface VariableDeclaration extends BaseDeclaration {
+    type: "VariableDeclaration";
+    declarations: VariableDeclarator[];
+    kind: "var" | "let" | "const";
+}
+
+export interface VariableDeclarator extends BaseNode {
+    type: "VariableDeclarator";
+    id: Pattern;
+    init?: Expression | null | undefined;
+}
+
+export interface ExpressionMap {
+    ArrayExpression: ArrayExpression;
+    ArrowFunctionExpression: ArrowFunctionExpression;
+    AssignmentExpression: AssignmentExpression;
+    AwaitExpression: AwaitExpression;
+    BinaryExpression: BinaryExpression;
+    CallExpression: CallExpression;
+    ChainExpression: ChainExpression;
+    ClassExpression: ClassExpression;
+    ConditionalExpression: ConditionalExpression;
+    FunctionExpression: FunctionExpression;
+    Identifier: Identifier;
+    ImportExpression: ImportExpression;
+    Literal: Literal;
+    LogicalExpression: LogicalExpression;
+    MemberExpression: MemberExpression;
+    MetaProperty: MetaProperty;
+    NewExpression: NewExpression;
+    ObjectExpression: ObjectExpression;
+    SequenceExpression: SequenceExpression;
+    TaggedTemplateExpression: TaggedTemplateExpression;
+    TemplateLiteral: TemplateLiteral;
+    ThisExpression: ThisExpression;
+    UnaryExpression: UnaryExpression;
+    UpdateExpression: UpdateExpression;
+    YieldExpression: YieldExpression;
+}
+
+export type Expression = ExpressionMap[keyof ExpressionMap];
+
+export interface BaseExpression extends BaseNode {}
+
+export type ChainElement = SimpleCallExpression | MemberExpression;
+
+export interface ChainExpression extends BaseExpression {
+    type: "ChainExpression";
+    expression: ChainElement;
+}
+
+export interface ThisExpression extends BaseExpression {
+    type: "ThisExpression";
+}
+
+export interface ArrayExpression extends BaseExpression {
+    type: "ArrayExpression";
+    elements: Array<Expression | SpreadElement | null>;
+}
+
+export interface ObjectExpression extends BaseExpression {
+    type: "ObjectExpression";
+    properties: Array<Property | SpreadElement>;
+}
+
+export interface PrivateIdentifier extends BaseNode {
+    type: "PrivateIdentifier";
+    name: string;
+}
+
+export interface Property extends BaseNode {
+    type: "Property";
+    key: Expression | PrivateIdentifier;
+    value: Expression | Pattern; // Could be an AssignmentProperty
+    kind: "init" | "get" | "set";
+    method: boolean;
+    shorthand: boolean;
+    computed: boolean;
+}
+
+export interface PropertyDefinition extends BaseNode {
+    type: "PropertyDefinition";
+    key: Expression | PrivateIdentifier;
+    value?: Expression | null | undefined;
+    computed: boolean;
+    static: boolean;
+}
+
+export interface FunctionExpression extends BaseFunction, BaseExpression {
+    id?: Identifier | null | undefined;
+    type: "FunctionExpression";
+    body: BlockStatement;
+}
+
+export interface SequenceExpression extends BaseExpression {
+    type: "SequenceExpression";
+    expressions: Expression[];
+}
+
+export interface UnaryExpression extends BaseExpression {
+    type: "UnaryExpression";
+    operator: UnaryOperator;
+    prefix: true;
+    argument: Expression;
+}
+
+export interface BinaryExpression extends BaseExpression {
+    type: "BinaryExpression";
+    operator: BinaryOperator;
+    left: Expression;
+    right: Expression;
+}
+
+export interface AssignmentExpression extends BaseExpression {
+    type: "AssignmentExpression";
+    operator: AssignmentOperator;
+    left: Pattern | MemberExpression;
+    right: Expression;
+}
+
+export interface UpdateExpression extends BaseExpression {
+    type: "UpdateExpression";
+    operator: UpdateOperator;
+    argument: Expression;
+    prefix: boolean;
+}
+
+export interface LogicalExpression extends BaseExpression {
+    type: "LogicalExpression";
+    operator: LogicalOperator;
+    left: Expression;
+    right: Expression;
+}
+
+export interface ConditionalExpression extends BaseExpression {
+    type: "ConditionalExpression";
+    test: Expression;
+    alternate: Expression;
+    consequent: Expression;
+}
+
+export interface BaseCallExpression extends BaseExpression {
+    callee: Expression | Super;
+    arguments: Array<Expression | SpreadElement>;
+}
+export type CallExpression = SimpleCallExpression | NewExpression;
+
+export interface SimpleCallExpression extends BaseCallExpression {
+    type: "CallExpression";
+    optional: boolean;
+}
+
+export interface NewExpression extends BaseCallExpression {
+    type: "NewExpression";
+}
+
+export interface MemberExpression extends BaseExpression, BasePattern {
+    type: "MemberExpression";
+    object: Expression | Super;
+    property: Expression | PrivateIdentifier;
+    computed: boolean;
+    optional: boolean;
+}
+
+export type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
+
+export interface BasePattern extends BaseNode {}
+
+export interface SwitchCase extends BaseNode {
+    type: "SwitchCase";
+    test?: Expression | null | undefined;
+    consequent: Statement[];
+}
+
+export interface CatchClause extends BaseNode {
+    type: "CatchClause";
+    param: Pattern | null;
+    body: BlockStatement;
+}
+
+export interface Identifier extends BaseNode, BaseExpression, BasePattern {
+    type: "Identifier";
+    name: string;
+}
+
+export type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+
+export interface SimpleLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value: string | boolean | number | null;
+    raw?: string | undefined;
+}
+
+export interface RegExpLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value?: RegExp | null | undefined;
+    regex: {
+        pattern: string;
+        flags: string;
+    };
+    raw?: string | undefined;
+}
+
+export interface BigIntLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value?: bigint | null | undefined;
+    bigint: string;
+    raw?: string | undefined;
+}
+
+export type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+
+export type BinaryOperator =
+    | "=="
+    | "!="
+    | "==="
+    | "!=="
+    | "<"
+    | "<="
+    | ">"
+    | ">="
+    | "<<"
+    | ">>"
+    | ">>>"
+    | "+"
+    | "-"
+    | "*"
+    | "/"
+    | "%"
+    | "**"
+    | "|"
+    | "^"
+    | "&"
+    | "in"
+    | "instanceof";
+
+export type LogicalOperator = "||" | "&&" | "??";
+
+export type AssignmentOperator =
+    | "="
+    | "+="
+    | "-="
+    | "*="
+    | "/="
+    | "%="
+    | "**="
+    | "<<="
+    | ">>="
+    | ">>>="
+    | "|="
+    | "^="
+    | "&="
+    | "||="
+    | "&&="
+    | "??=";
+
+export type UpdateOperator = "++" | "--";
+
+export interface ForOfStatement extends BaseForXStatement {
+    type: "ForOfStatement";
+    await: boolean;
+}
+
+export interface Super extends BaseNode {
+    type: "Super";
+}
+
+export interface SpreadElement extends BaseNode {
+    type: "SpreadElement";
+    argument: Expression;
+}
+
+export interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+    type: "ArrowFunctionExpression";
+    expression: boolean;
+    body: BlockStatement | Expression;
+}
+
+export interface YieldExpression extends BaseExpression {
+    type: "YieldExpression";
+    argument?: Expression | null | undefined;
+    delegate: boolean;
+}
+
+export interface TemplateLiteral extends BaseExpression {
+    type: "TemplateLiteral";
+    quasis: TemplateElement[];
+    expressions: Expression[];
+}
+
+export interface TaggedTemplateExpression extends BaseExpression {
+    type: "TaggedTemplateExpression";
+    tag: Expression;
+    quasi: TemplateLiteral;
+}
+
+export interface TemplateElement extends BaseNode {
+    type: "TemplateElement";
+    tail: boolean;
+    value: {
+        /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
+        cooked?: string | null | undefined;
+        raw: string;
+    };
+}
+
+export interface AssignmentProperty extends Property {
+    value: Pattern;
+    kind: "init";
+    method: boolean; // false
+}
+
+export interface ObjectPattern extends BasePattern {
+    type: "ObjectPattern";
+    properties: Array<AssignmentProperty | RestElement>;
+}
+
+export interface ArrayPattern extends BasePattern {
+    type: "ArrayPattern";
+    elements: Array<Pattern | null>;
+}
+
+export interface RestElement extends BasePattern {
+    type: "RestElement";
+    argument: Pattern;
+}
+
+export interface AssignmentPattern extends BasePattern {
+    type: "AssignmentPattern";
+    left: Pattern;
+    right: Expression;
+}
+
+export type Class = ClassDeclaration | ClassExpression;
+export interface BaseClass extends BaseNode {
+    superClass?: Expression | null | undefined;
+    body: ClassBody;
+}
+
+export interface ClassBody extends BaseNode {
+    type: "ClassBody";
+    body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
+}
+
+export interface MethodDefinition extends BaseNode {
+    type: "MethodDefinition";
+    key: Expression | PrivateIdentifier;
+    value: FunctionExpression;
+    kind: "constructor" | "method" | "get" | "set";
+    computed: boolean;
+    static: boolean;
+}
+
+export interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
+    type: "ClassDeclaration";
+    /** It is null when a class declaration is a part of the `export default class` statement */
+    id: Identifier | null;
+}
+
+export interface ClassDeclaration extends MaybeNamedClassDeclaration {
+    id: Identifier;
+}
+
+export interface ClassExpression extends BaseClass, BaseExpression {
+    type: "ClassExpression";
+    id?: Identifier | null | undefined;
+}
+
+export interface MetaProperty extends BaseExpression {
+    type: "MetaProperty";
+    meta: Identifier;
+    property: Identifier;
+}
+
+export type ModuleDeclaration =
+    | ImportDeclaration
+    | ExportNamedDeclaration
+    | ExportDefaultDeclaration
+    | ExportAllDeclaration;
+export interface BaseModuleDeclaration extends BaseNode {}
+
+export type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
+export interface BaseModuleSpecifier extends BaseNode {
+    local: Identifier;
+}
+
+export interface ImportDeclaration extends BaseModuleDeclaration {
+    type: "ImportDeclaration";
+    specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+    source: Literal;
+}
+
+export interface ImportSpecifier extends BaseModuleSpecifier {
+    type: "ImportSpecifier";
+    imported: Identifier;
+}
+
+export interface ImportExpression extends BaseExpression {
+    type: "ImportExpression";
+    source: Expression;
+}
+
+export interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+    type: "ImportDefaultSpecifier";
+}
+
+export interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+    type: "ImportNamespaceSpecifier";
+}
+
+export interface ExportNamedDeclaration extends BaseModuleDeclaration {
+    type: "ExportNamedDeclaration";
+    declaration?: Declaration | null | undefined;
+    specifiers: ExportSpecifier[];
+    source?: Literal | null | undefined;
+}
+
+export interface ExportSpecifier extends BaseModuleSpecifier {
+    type: "ExportSpecifier";
+    exported: Identifier;
+}
+
+export interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+    type: "ExportDefaultDeclaration";
+    declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
+}
+
+export interface ExportAllDeclaration extends BaseModuleDeclaration {
+    type: "ExportAllDeclaration";
+    exported: Identifier | null;
+    source: Literal;
+}
+
+export interface AwaitExpression extends BaseExpression {
+    type: "AwaitExpression";
+    argument: Expression;
+}

node_modules/@types/estree/package.json

@@ -0,0 +1,26 @@
+{
+    "name": "@types/estree",
+    "version": "1.0.5",
+    "description": "TypeScript definitions for estree",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/estree",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "RReverser",
+            "githubUsername": "RReverser",
+            "url": "https://github.com/RReverser"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/estree"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "6f0eeaffe488ce594e73f8df619c677d752a279b51edbc744e4aebb20db4b3a7",
+    "typeScriptVersion": "4.5",
+    "nonNpm": true
+}

node_modules/@types/express-serve-static-core/LICENSE

@@ -0,0 +1,21 @@
+    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/express-serve-static-core/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/express-serve-static-core`
+
+# Summary
+This package contains type definitions for express-serve-static-core (http://expressjs.com).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/express-serve-static-core.
+
+### Additional Details
+ * Last updated: Sat, 03 Feb 2024 13:07:19 GMT
+ * Dependencies: [@types/node](https://npmjs.com/package/@types/node), [@types/qs](https://npmjs.com/package/@types/qs), [@types/range-parser](https://npmjs.com/package/@types/range-parser), [@types/send](https://npmjs.com/package/@types/send)
+
+# Credits
+These definitions were written by [Boris Yankov](https://github.com/borisyankov), [Satana Charuwichitratana](https://github.com/micksatana), [Sami Jaber](https://github.com/samijaber), [Jose Luis Leon](https://github.com/JoseLion), [David Stephens](https://github.com/dwrss), and [Shin Ando](https://github.com/andoshin11).

node_modules/@types/express-serve-static-core/package.json

@@ -0,0 +1,55 @@
+{
+    "name": "@types/express-serve-static-core",
+    "version": "4.17.43",
+    "description": "TypeScript definitions for express-serve-static-core",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/express-serve-static-core",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Boris Yankov",
+            "githubUsername": "borisyankov",
+            "url": "https://github.com/borisyankov"
+        },
+        {
+            "name": "Satana Charuwichitratana",
+            "githubUsername": "micksatana",
+            "url": "https://github.com/micksatana"
+        },
+        {
+            "name": "Sami Jaber",
+            "githubUsername": "samijaber",
+            "url": "https://github.com/samijaber"
+        },
+        {
+            "name": "Jose Luis Leon",
+            "githubUsername": "JoseLion",
+            "url": "https://github.com/JoseLion"
+        },
+        {
+            "name": "David Stephens",
+            "githubUsername": "dwrss",
+            "url": "https://github.com/dwrss"
+        },
+        {
+            "name": "Shin Ando",
+            "githubUsername": "andoshin11",
+            "url": "https://github.com/andoshin11"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/express-serve-static-core"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/node": "*",
+        "@types/qs": "*",
+        "@types/range-parser": "*",
+        "@types/send": "*"
+    },
+    "typesPublisherContentHash": "78d46eee40ea01a0a5a181e980560de1263e59fb351c3ff23dc4b43718d9e6f6",
+    "typeScriptVersion": "4.6"
+}

node_modules/@types/express/LICENSE

@@ -0,0 +1,21 @@
+    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/express/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/express`
+
+# Summary
+This package contains type definitions for express (http://expressjs.com).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/express.
+
+### Additional Details
+ * Last updated: Tue, 07 Nov 2023 03:09:36 GMT
+ * Dependencies: [@types/body-parser](https://npmjs.com/package/@types/body-parser), [@types/express-serve-static-core](https://npmjs.com/package/@types/express-serve-static-core), [@types/qs](https://npmjs.com/package/@types/qs), [@types/serve-static](https://npmjs.com/package/@types/serve-static)
+
+# Credits
+These definitions were written by [Boris Yankov](https://github.com/borisyankov), [China Medical University Hospital](https://github.com/CMUH), [Puneet Arora](https://github.com/puneetar), and [Dylan Frankland](https://github.com/dfrankland).

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

@@ -0,0 +1,128 @@
+/* =================== USAGE ===================
+
+    import express = require("express");
+    var app = express();
+
+ =============================================== */
+
+/// <reference types="express-serve-static-core" />
+/// <reference types="serve-static" />
+
+import * as bodyParser from "body-parser";
+import * as core from "express-serve-static-core";
+import * as qs from "qs";
+import * as serveStatic from "serve-static";
+
+/**
+ * Creates an Express application. The express() function is a top-level function exported by the express module.
+ */
+declare function e(): core.Express;
+
+declare namespace e {
+    /**
+     * This is a built-in middleware function in Express. It parses incoming requests with JSON payloads and is based on body-parser.
+     * @since 4.16.0
+     */
+    var json: typeof bodyParser.json;
+
+    /**
+     * This is a built-in middleware function in Express. It parses incoming requests with Buffer payloads and is based on body-parser.
+     * @since 4.17.0
+     */
+    var raw: typeof bodyParser.raw;
+
+    /**
+     * This is a built-in middleware function in Express. It parses incoming requests with text payloads and is based on body-parser.
+     * @since 4.17.0
+     */
+    var text: typeof bodyParser.text;
+
+    /**
+     * These are the exposed prototypes.
+     */
+    var application: Application;
+    var request: Request;
+    var response: Response;
+
+    /**
+     * This is a built-in middleware function in Express. It serves static files and is based on serve-static.
+     */
+    var static: serveStatic.RequestHandlerConstructor<Response>;
+
+    /**
+     * This is a built-in middleware function in Express. It parses incoming requests with urlencoded payloads and is based on body-parser.
+     * @since 4.16.0
+     */
+    var urlencoded: typeof bodyParser.urlencoded;
+
+    /**
+     * This is a built-in middleware function in Express. It parses incoming request query parameters.
+     */
+    export function query(options: qs.IParseOptions | typeof qs.parse): Handler;
+
+    export function Router(options?: RouterOptions): core.Router;
+
+    interface RouterOptions {
+        /**
+         * Enable case sensitivity.
+         */
+        caseSensitive?: boolean | undefined;
+
+        /**
+         * Preserve the req.params values from the parent router.
+         * If the parent and the child have conflicting param names, the child’s value take precedence.
+         *
+         * @default false
+         * @since 4.5.0
+         */
+        mergeParams?: boolean | undefined;
+
+        /**
+         * Enable strict routing.
+         */
+        strict?: boolean | undefined;
+    }
+
+    interface Application extends core.Application {}
+    interface CookieOptions extends core.CookieOptions {}
+    interface Errback extends core.Errback {}
+    interface ErrorRequestHandler<
+        P = core.ParamsDictionary,
+        ResBody = any,
+        ReqBody = any,
+        ReqQuery = core.Query,
+        Locals extends Record<string, any> = Record<string, any>,
+    > extends core.ErrorRequestHandler<P, ResBody, ReqBody, ReqQuery, Locals> {}
+    interface Express extends core.Express {}
+    interface Handler extends core.Handler {}
+    interface IRoute extends core.IRoute {}
+    interface IRouter extends core.IRouter {}
+    interface IRouterHandler<T> extends core.IRouterHandler<T> {}
+    interface IRouterMatcher<T> extends core.IRouterMatcher<T> {}
+    interface MediaType extends core.MediaType {}
+    interface NextFunction extends core.NextFunction {}
+    interface Locals extends core.Locals {}
+    interface Request<
+        P = core.ParamsDictionary,
+        ResBody = any,
+        ReqBody = any,
+        ReqQuery = core.Query,
+        Locals extends Record<string, any> = Record<string, any>,
+    > extends core.Request<P, ResBody, ReqBody, ReqQuery, Locals> {}
+    interface RequestHandler<
+        P = core.ParamsDictionary,
+        ResBody = any,
+        ReqBody = any,
+        ReqQuery = core.Query,
+        Locals extends Record<string, any> = Record<string, any>,
+    > extends core.RequestHandler<P, ResBody, ReqBody, ReqQuery, Locals> {}
+    interface RequestParamHandler extends core.RequestParamHandler {}
+    interface Response<
+        ResBody = any,
+        Locals extends Record<string, any> = Record<string, any>,
+    > extends core.Response<ResBody, Locals> {}
+    interface Router extends core.Router {}
+    interface Send extends core.Send {}
+}
+
+export = e;

node_modules/@types/express/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "@types/express",
+    "version": "4.17.21",
+    "description": "TypeScript definitions for express",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/express",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Boris Yankov",
+            "githubUsername": "borisyankov",
+            "url": "https://github.com/borisyankov"
+        },
+        {
+            "name": "China Medical University Hospital",
+            "githubUsername": "CMUH",
+            "url": "https://github.com/CMUH"
+        },
+        {
+            "name": "Puneet Arora",
+            "githubUsername": "puneetar",
+            "url": "https://github.com/puneetar"
+        },
+        {
+            "name": "Dylan Frankland",
+            "githubUsername": "dfrankland",
+            "url": "https://github.com/dfrankland"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/express"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/body-parser": "*",
+        "@types/express-serve-static-core": "^4.17.33",
+        "@types/qs": "*",
+        "@types/serve-static": "*"
+    },
+    "typesPublisherContentHash": "fa18ce9be07653182e2674f9a13cf8347ffb270031a7a8d22ba0e785bbc16ce4",
+    "typeScriptVersion": "4.5"
+}

node_modules/@types/gtag.js/LICENSE

@@ -0,0 +1,21 @@
+    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/gtag.js/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/gtag.js`
+
+# Summary
+This package contains type definitions for Google gtag.js API (https://developers.google.com/gtagjs).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/gtag.js.
+
+### Additional Details
+ * Last updated: Tue, 04 Oct 2022 21:02:53 GMT
+ * Dependencies: none
+ * Global values: `gtag`
+
+# Credits
+These definitions were written by [ Junyoung Choi](https://github.com/rokt33r), and [Lucas Akira Uehara](https://github.com/KsAkira10).

node_modules/@types/gtag.js/index.d.ts

@@ -0,0 +1,157 @@
+// Type definitions for non-npm package Google gtag.js API
+// Project: https://developers.google.com/gtagjs
+// Definitions by:  Junyoung Choi <https://github.com/rokt33r>
+//                  Lucas Akira Uehara <https://github.com/KsAkira10>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare var gtag: Gtag.Gtag;
+declare namespace Gtag {
+  interface Gtag {
+    (command: 'config', targetId: string, config?: ControlParams | EventParams | ConfigParams | CustomParams): void;
+    (command: 'set', targetId: string, config: CustomParams | boolean | string): void;
+    (command: 'set', config: CustomParams): void;
+    (command: 'js', config: Date): void;
+    (
+      command: 'event',
+      eventName: EventNames | (string & {}),
+      eventParams?: ControlParams | EventParams | CustomParams,
+    ): void;
+    (command: 'get', targetId: string, fieldName: FieldNames | string, callback?: (field: string | CustomParams | undefined) => any): void;
+    (command: 'consent', consentArg: ConsentArg | string, consentParams: ConsentParams): void;
+  }
+
+  interface ConfigParams {
+    page_title?: string | undefined;
+    page_location?: string | undefined;
+    page_path?: string | undefined;
+    send_page_view?: boolean | undefined;
+  }
+
+  interface CustomParams {
+    [key: string]: any;
+  }
+
+  interface ControlParams {
+    groups?: string | string[] | undefined;
+    send_to?: string | string[] | undefined;
+    event_callback?: (() => void) | undefined;
+    event_timeout?: number | undefined;
+  }
+
+  type EventNames =
+    | 'add_payment_info'
+    | 'add_shipping_info'
+    | 'add_to_cart'
+    | 'add_to_wishlist'
+    | 'begin_checkout'
+    | 'checkout_progress'
+    | 'earn_virtual_currency'
+    | 'exception'
+    | 'generate_lead'
+    | 'join_group'
+    | 'level_end'
+    | 'level_start'
+    | 'level_up'
+    | 'login'
+    | 'page_view'
+    | 'post_score'
+    | 'purchase'
+    | 'refund'
+    | 'remove_from_cart'
+    | 'screen_view'
+    | 'search'
+    | 'select_content'
+    | 'select_item'
+    | 'select_promotion'
+    | 'set_checkout_option'
+    | 'share'
+    | 'sign_up'
+    | 'spend_virtual_currency'
+    | 'tutorial_begin'
+    | 'tutorial_complete'
+    | 'unlock_achievement'
+    | 'timing_complete'
+    | 'view_cart'
+    | 'view_item'
+    | 'view_item_list'
+    | 'view_promotion'
+    | 'view_search_results';
+
+  interface EventParams {
+    checkout_option?: string | undefined;
+    checkout_step?: number | undefined;
+    content_id?: string | undefined;
+    content_type?: string | undefined;
+    coupon?: string | undefined;
+    currency?: string | undefined;
+    description?: string | undefined;
+    fatal?: boolean | undefined;
+    items?: Item[] | undefined;
+    method?: string | undefined;
+    number?: string | undefined;
+    promotions?: Promotion[] | undefined;
+    screen_name?: string | undefined;
+    search_term?: string | undefined;
+    shipping?: Currency | undefined;
+    tax?: Currency | undefined;
+    transaction_id?: string | undefined;
+    value?: number | undefined;
+    event_label?: string | undefined;
+    event_category?: string | undefined;
+  }
+
+  type Currency = string | number;
+
+  /**
+   * Interface of an item object used in lists for this event.
+   *
+   * Reference:
+   * @see {@link https://developers.google.com/analytics/devguides/collection/ga4/reference/events#view_item_item view_item_item}
+   * @see {@link https://developers.google.com/analytics/devguides/collection/ga4/reference/events#view_item_list_item view_item_list_item}
+   * @see {@link https://developers.google.com/analytics/devguides/collection/ga4/reference/events#select_item_item select_item_item}
+   * @see {@link https://developers.google.com/analytics/devguides/collection/ga4/reference/events#add_to_cart_item add_to_cart_item}
+   * @see {@link https://developers.google.com/analytics/devguides/collection/ga4/reference/events#view_cart_item view_cart_item}
+   */
+  interface Item {
+    item_id?: string | undefined;
+    item_name?: string | undefined;
+    affiliation?: string | undefined;
+    coupon?: string | undefined;
+    currency?: string | undefined;
+    creative_name?: string | undefined;
+    creative_slot?: string | undefined;
+    discount?: Currency | undefined;
+    index?: number | undefined;
+    item_brand?: string | undefined;
+    item_category?: string | undefined;
+    item_category2?: string | undefined;
+    item_category3?: string | undefined;
+    item_category4?: string | undefined;
+    item_category5?: string | undefined;
+    item_list_id?: string | undefined;
+    item_list_name?: string | undefined;
+    item_variant?: string | undefined;
+    location_id?: string | undefined;
+    price?: Currency | undefined;
+    promotion_id?: string | undefined;
+    promotion_name?: string | undefined;
+    quantity?: number | undefined;
+  }
+
+  interface Promotion {
+    creative_name?: string | undefined;
+    creative_slot?: string | undefined;
+    promotion_id?: string | undefined;
+    promotion_name?: string | undefined;
+  }
+
+  type FieldNames = 'client_id' | 'session_id' | 'gclid';
+
+  type ConsentArg = 'default' | 'update';
+  interface ConsentParams {
+    ad_storage?: 'granted' | 'denied' | undefined;
+    analytics_storage?: 'granted' | 'denied' | undefined;
+    wait_for_update?: number | undefined;
+    region?: string[] | undefined;
+  }
+}

node_modules/@types/gtag.js/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@types/gtag.js",
+    "version": "0.0.12",
+    "description": "TypeScript definitions for Google gtag.js API",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/gtag.js",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": " Junyoung Choi",
+            "url": "https://github.com/rokt33r",
+            "githubUsername": "rokt33r"
+        },
+        {
+            "name": "Lucas Akira Uehara",
+            "url": "https://github.com/KsAkira10",
+            "githubUsername": "KsAkira10"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/gtag.js"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "1919d74395982c9beb3bb1bcbc26d9e298c9ee94bc454000c7a49d8333da0d28",
+    "typeScriptVersion": "4.1"
+}

node_modules/@types/hast/LICENSE

@@ -0,0 +1,21 @@
+    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/hast/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/hast`
+
+# Summary
+This package contains type definitions for hast (https://github.com/syntax-tree/hast).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/hast.
+
+### Additional Details
+ * Last updated: Tue, 30 Jan 2024 21:35:45 GMT
+ * Dependencies: [@types/unist](https://npmjs.com/package/@types/unist)
+
+# Credits
+These definitions were written by [lukeggchapman](https://github.com/lukeggchapman), [Junyoung Choi](https://github.com/rokt33r), [Christian Murphy](https://github.com/ChristianMurphy), and [Remco Haszing](https://github.com/remcohaszing).

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

@@ -0,0 +1,282 @@
+import type { Data as UnistData, Literal as UnistLiteral, Node as UnistNode, Parent as UnistParent } from "unist";
+
+// ## Interfaces
+
+/**
+ * Info associated with hast nodes by the ecosystem.
+ *
+ * This space is guaranteed to never be specified by unist or hast.
+ * But you can use it in utilities and plugins to store data.
+ *
+ * This type can be augmented to register custom data.
+ * For example:
+ *
+ * ```ts
+ * declare module 'hast' {
+ *   interface Data {
+ *     // `someNode.data.myId` is typed as `number | undefined`
+ *     myId?: number | undefined
+ *   }
+ * }
+ * ```
+ */
+export interface Data extends UnistData {}
+
+/**
+ * Info associated with an element.
+ */
+export interface Properties {
+    [PropertyName: string]: boolean | number | string | null | undefined | Array<string | number>;
+}
+
+// ## Content maps
+
+/**
+ * Union of registered hast nodes that can occur in {@link Element}.
+ *
+ * To register mote custom hast nodes, add them to {@link ElementContentMap}.
+ * They will be automatically added here.
+ */
+export type ElementContent = ElementContentMap[keyof ElementContentMap];
+
+/**
+ * Registry of all hast nodes that can occur as children of {@link Element}.
+ *
+ * For a union of all {@link Element} children, see {@link ElementContent}.
+ */
+export interface ElementContentMap {
+    comment: Comment;
+    element: Element;
+    text: Text;
+}
+
+/**
+ * Union of registered hast nodes that can occur in {@link Root}.
+ *
+ * To register custom hast nodes, add them to {@link RootContentMap}.
+ * They will be automatically added here.
+ */
+export type RootContent = RootContentMap[keyof RootContentMap];
+
+/**
+ * Registry of all hast nodes that can occur as children of {@link Root}.
+ *
+ * > 👉 **Note**: {@link Root} does not need to be an entire document.
+ * > it can also be a fragment.
+ *
+ * For a union of all {@link Root} children, see {@link RootContent}.
+ */
+export interface RootContentMap {
+    comment: Comment;
+    doctype: Doctype;
+    element: Element;
+    text: Text;
+}
+
+// ### Special content types
+
+/**
+ * Union of registered hast nodes that can occur in {@link Root}.
+ *
+ * @deprecated Use {@link RootContent} instead.
+ */
+export type Content = RootContent;
+
+/**
+ * Union of registered hast literals.
+ *
+ * To register custom hast nodes, add them to {@link RootContentMap} and other
+ * places where relevant.
+ * They will be automatically added here.
+ */
+export type Literals = Extract<Nodes, UnistLiteral>;
+
+/**
+ * Union of registered hast nodes.
+ *
+ * To register custom hast nodes, add them to {@link RootContentMap} and other
+ * places where relevant.
+ * They will be automatically added here.
+ */
+export type Nodes = Root | RootContent;
+
+/**
+ * Union of registered hast parents.
+ *
+ * To register custom hast nodes, add them to {@link RootContentMap} and other
+ * places where relevant.
+ * They will be automatically added here.
+ */
+export type Parents = Extract<Nodes, UnistParent>;
+
+// ## Abstract nodes
+
+/**
+ * Abstract hast node.
+ *
+ * This interface is supposed to be extended.
+ * If you can use {@link Literal} or {@link Parent}, you should.
+ * But for example in HTML, a `Doctype` is neither literal nor parent, but
+ * still a node.
+ *
+ * To register custom hast nodes, add them to {@link RootContentMap} and other
+ * places where relevant (such as {@link ElementContentMap}).
+ *
+ * For a union of all registered hast nodes, see {@link Nodes}.
+ */
+export interface Node extends UnistNode {
+    /**
+     * Info from the ecosystem.
+     */
+    data?: Data | undefined;
+}
+
+/**
+ * Abstract hast node that contains the smallest possible value.
+ *
+ * This interface is supposed to be extended if you make custom hast nodes.
+ *
+ * For a union of all registered hast literals, see {@link Literals}.
+ */
+export interface Literal extends Node {
+    /**
+     * Plain-text value.
+     */
+    value: string;
+}
+
+/**
+ * Abstract hast node that contains other hast nodes (*children*).
+ *
+ * This interface is supposed to be extended if you make custom hast nodes.
+ *
+ * For a union of all registered hast parents, see {@link Parents}.
+ */
+export interface Parent extends Node {
+    /**
+     * List of children.
+     */
+    children: RootContent[];
+}
+
+// ## Concrete nodes
+
+/**
+ * HTML comment.
+ */
+export interface Comment extends Literal {
+    /**
+     * Node type of HTML comments in hast.
+     */
+    type: "comment";
+    /**
+     * Data associated with the comment.
+     */
+    data?: CommentData | undefined;
+}
+
+/**
+ * Info associated with hast comments by the ecosystem.
+ */
+export interface CommentData extends Data {}
+
+/**
+ * HTML document type.
+ */
+export interface Doctype extends UnistNode {
+    /**
+     * Node type of HTML document types in hast.
+     */
+    type: "doctype";
+    /**
+     * Data associated with the doctype.
+     */
+    data?: DoctypeData | undefined;
+}
+
+/**
+ * Info associated with hast doctypes by the ecosystem.
+ */
+export interface DoctypeData extends Data {}
+
+/**
+ * HTML element.
+ */
+export interface Element extends Parent {
+    /**
+     * Node type of elements.
+     */
+    type: "element";
+    /**
+     * Tag name (such as `'body'`) of the element.
+     */
+    tagName: string;
+    /**
+     * Info associated with the element.
+     */
+    properties: Properties;
+    /**
+     * Children of element.
+     */
+    children: ElementContent[];
+    /**
+     * When the `tagName` field is `'template'`, a `content` field can be
+     * present.
+     */
+    content?: Root | undefined;
+    /**
+     * Data associated with the element.
+     */
+    data?: ElementData | undefined;
+}
+
+/**
+ * Info associated with hast elements by the ecosystem.
+ */
+export interface ElementData extends Data {}
+
+/**
+ * Document fragment or a whole document.
+ *
+ * Should be used as the root of a tree and must not be used as a child.
+ *
+ * Can also be used as the value for the content field on a `'template'` element.
+ */
+export interface Root extends Parent {
+    /**
+     * Node type of hast root.
+     */
+    type: "root";
+    /**
+     * Children of root.
+     */
+    children: RootContent[];
+    /**
+     * Data associated with the hast root.
+     */
+    data?: RootData | undefined;
+}
+
+/**
+ * Info associated with hast root nodes by the ecosystem.
+ */
+export interface RootData extends Data {}
+
+/**
+ * HTML character data (plain text).
+ */
+export interface Text extends Literal {
+    /**
+     * Node type of HTML character data (plain text) in hast.
+     */
+    type: "text";
+    /**
+     * Data associated with the text.
+     */
+    data?: TextData | undefined;
+}
+
+/**
+ * Info associated with hast texts by the ecosystem.
+ */
+export interface TextData extends Data {}

node_modules/@types/hast/package.json

@@ -0,0 +1,42 @@
+{
+    "name": "@types/hast",
+    "version": "3.0.4",
+    "description": "TypeScript definitions for hast",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/hast",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "lukeggchapman",
+            "githubUsername": "lukeggchapman",
+            "url": "https://github.com/lukeggchapman"
+        },
+        {
+            "name": "Junyoung Choi",
+            "githubUsername": "rokt33r",
+            "url": "https://github.com/rokt33r"
+        },
+        {
+            "name": "Christian Murphy",
+            "githubUsername": "ChristianMurphy",
+            "url": "https://github.com/ChristianMurphy"
+        },
+        {
+            "name": "Remco Haszing",
+            "githubUsername": "remcohaszing",
+            "url": "https://github.com/remcohaszing"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/hast"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/unist": "*"
+    },
+    "typesPublisherContentHash": "3f3f73826d79157c12087f5bb36195319c6f435b9e218fa7a8de88d1cc64d097",
+    "typeScriptVersion": "4.6"
+}

node_modules/@types/history/DOMUtils.d.ts

@@ -0,0 +1,17 @@
+declare global {
+    // Some users of this package are don't use "dom" libs
+    interface EventTarget {}
+    interface EventListener {}
+    interface EventListenerObject {}
+}
+
+export const isExtraneousPopstateEvent: boolean;
+export function addEventListener(node: EventTarget, event: string, listener: EventListener | EventListenerObject): void;
+export function removeEventListener(
+    node: EventTarget,
+    event: string,
+    listener: EventListener | EventListenerObject,
+): void;
+export function getConfirmation(message: string, callback: (result: boolean) => void): void;
+export function supportsHistory(): boolean;
+export function supportsGoWithoutReloadUsingHash(): boolean;

node_modules/@types/history/ExecutionEnvironment.d.ts

@@ -0,0 +1 @@
+export const canUseDOM: boolean;

node_modules/@types/history/LICENSE

@@ -0,0 +1,21 @@
+    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/history/LocationUtils.d.ts

@@ -0,0 +1,9 @@
+import { Path, LocationState, LocationKey, Location, LocationDescriptor } from './index';
+
+export function locationsAreEqual<S = LocationState>(lv: LocationDescriptor<S>, rv: LocationDescriptor<S>): boolean;
+export function createLocation<S = LocationState>(
+    path: LocationDescriptor<S>,
+    state?: S,
+    key?: LocationKey,
+    currentLocation?: Location<S>,
+): Location<S>;

node_modules/@types/history/PathUtils.d.ts

@@ -0,0 +1,9 @@
+import { Path, Location, LocationDescriptorObject } from './index';
+
+export function addLeadingSlash(path: Path): Path;
+export function stripLeadingSlash(path: Path): Path;
+export function hasBasename(path: Path): boolean;
+export function stripBasename(path: Path, prefix: string): Path;
+export function stripTrailingSlash(path: Path): Path;
+export function parsePath(path: Path): Location;
+export function createPath<S>(location: LocationDescriptorObject<S>): Path;

node_modules/@types/history/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/history`
+
+# Summary
+This package contains type definitions for history (https://github.com/mjackson/history).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/history.
+
+### Additional Details
+ * Last updated: Sun, 16 Jan 2022 17:31:24 GMT
+ * Dependencies: none
+ * Global values: `History`
+
+# Credits
+These definitions were written by [Sergey Buturlakin](https://github.com/sergey-buturlakin), [Nathan Brown](https://github.com/ngbrown), [Young Rok Kim](https://github.com/rokoroku), and [Daniel Nixon](https://github.com/danielnixon).

node_modules/@types/history/createBrowserHistory.d.ts

@@ -0,0 +1,11 @@
+import { History, LocationState } from './index';
+import { getConfirmation } from './DOMUtils';
+
+export interface BrowserHistoryBuildOptions {
+    basename?: string | undefined;
+    forceRefresh?: boolean | undefined;
+    getUserConfirmation?: typeof getConfirmation | undefined;
+    keyLength?: number | undefined;
+}
+
+export default function createBrowserHistory<S = LocationState>(options?: BrowserHistoryBuildOptions): History<S>;

node_modules/@types/history/createHashHistory.d.ts

@@ -0,0 +1,12 @@
+import { History, LocationState } from './index';
+import { getConfirmation } from './DOMUtils';
+
+export type HashType = 'hashbang' | 'noslash' | 'slash';
+
+export interface HashHistoryBuildOptions {
+    basename?: string | undefined;
+    hashType?: HashType | undefined;
+    getUserConfirmation?: typeof getConfirmation | undefined;
+}
+
+export default function createHashHistory<S = LocationState>(options?: HashHistoryBuildOptions): History<S>;

node_modules/@types/history/createMemoryHistory.d.ts

@@ -0,0 +1,19 @@
+import { History, Location, LocationState } from './index';
+import { getConfirmation } from './DOMUtils';
+
+export type InitialEntry = string | Partial<Location>;
+
+export interface MemoryHistoryBuildOptions {
+    getUserConfirmation?: typeof getConfirmation | undefined;
+    initialEntries?: InitialEntry[] | undefined;
+    initialIndex?: number | undefined;
+    keyLength?: number | undefined;
+}
+
+export interface MemoryHistory<HistoryLocationState = LocationState> extends History<HistoryLocationState> {
+    index: number;
+    entries: Location<HistoryLocationState>[];
+    canGo(n: number): boolean;
+}
+
+export default function createMemoryHistory<S = LocationState>(options?: MemoryHistoryBuildOptions): MemoryHistory<S>;

node_modules/@types/history/createTransitionManager.d.ts

@@ -0,0 +1,20 @@
+import { Location, Action, LocationListener, LocationState, UnregisterCallback } from './index';
+import { getConfirmation } from './DOMUtils';
+
+export type PromptFunction<S = LocationState> = (location: Location<S>, action: Action) => any;
+
+export type Prompt<S = LocationState> = PromptFunction<S> | boolean;
+
+export interface TransitionManager<S = LocationState> {
+    setPrompt(nextPrompt?: Prompt<S>): UnregisterCallback;
+    appendListener(listener: LocationListener<S>): UnregisterCallback;
+    notifyListeners(location: Location<S>, action: Action): void;
+    confirmTransitionTo(
+        location: Location<S>,
+        action: Action,
+        getUserConfirmation: typeof getConfirmation,
+        callback: (result: boolean) => void,
+    ): void;
+}
+
+export default function createTransitionManager<S = LocationState>(): TransitionManager<S>;

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

@@ -0,0 +1,95 @@
+// Type definitions for history 4.7.2
+// Project: https://github.com/mjackson/history
+// Definitions by: Sergey Buturlakin <https://github.com/sergey-buturlakin>, Nathan Brown <https://github.com/ngbrown>, Young Rok Kim <https://github.com/rokoroku>, Daniel Nixon <https://github.com/danielnixon>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+export as namespace History;
+
+export type Action = 'PUSH' | 'POP' | 'REPLACE';
+export type UnregisterCallback = () => void;
+
+export interface History<HistoryLocationState = LocationState> {
+    length: number;
+    action: Action;
+    location: Location<HistoryLocationState>;
+    push(location: Path | LocationDescriptor<HistoryLocationState>, state?: HistoryLocationState): void;
+    replace(location: Path | LocationDescriptor<HistoryLocationState>, state?: HistoryLocationState): void;
+    go(n: number): void;
+    goBack(): void;
+    goForward(): void;
+    block(prompt?: boolean | string | TransitionPromptHook<HistoryLocationState>): UnregisterCallback;
+    listen(listener: LocationListener<HistoryLocationState>): UnregisterCallback;
+    createHref(location: LocationDescriptorObject<HistoryLocationState>): Href;
+}
+
+export interface Location<S = LocationState> {
+    pathname: Pathname;
+    search: Search;
+    state: S;
+    hash: Hash;
+    key?: LocationKey | undefined;
+}
+
+export interface LocationDescriptorObject<S = LocationState> {
+    pathname?: Pathname | undefined;
+    search?: Search | undefined;
+    state?: S | undefined;
+    hash?: Hash | undefined;
+    key?: LocationKey | undefined;
+}
+
+export namespace History {
+    export type LocationDescriptor<S = LocationState> = Path | LocationDescriptorObject<S>;
+    export type LocationKey = string;
+    export type LocationListener<S = LocationState> = (location: Location<S>, action: Action) => void;
+
+    export type LocationState = unknown;
+    export type Path = string;
+    export type Pathname = string;
+    export type Search = string;
+    export type TransitionHook<S = LocationState> = (location: Location<S>, callback: (result: any) => void) => any;
+    export type TransitionPromptHook<S = LocationState> = (
+        location: Location<S>,
+        action: Action,
+    ) => string | false | void;
+    export type Hash = string;
+    export type Href = string;
+}
+
+export type LocationDescriptor<S = LocationState> = History.LocationDescriptor<S>;
+export type LocationKey = History.LocationKey;
+export type LocationListener<S = LocationState> = History.LocationListener<S>;
+export type LocationState = History.LocationState;
+export type Path = History.Path;
+export type Pathname = History.Pathname;
+export type Search = History.Search;
+export type TransitionHook<S = LocationState> = History.TransitionHook<S>;
+export type TransitionPromptHook<S = LocationState> = History.TransitionPromptHook<S>;
+export type Hash = History.Hash;
+export type Href = History.Href;
+
+import { default as createBrowserHistory } from './createBrowserHistory';
+import { default as createHashHistory } from './createHashHistory';
+import { default as createMemoryHistory } from './createMemoryHistory';
+import { createLocation, locationsAreEqual } from './LocationUtils';
+import { parsePath, createPath } from './PathUtils';
+
+// Global usage, without modules, needs the small trick, because lib.d.ts
+// already has `history` and `History` global definitions:
+// var createHistory = ((window as any).History as HistoryModule.Module).createHistory;
+export interface Module {
+    createBrowserHistory: typeof createBrowserHistory;
+    createHashHistory: typeof createHashHistory;
+    createMemoryHistory: typeof createMemoryHistory;
+    createLocation: typeof createLocation;
+    locationsAreEqual: typeof locationsAreEqual;
+    parsePath: typeof parsePath;
+    createPath: typeof createPath;
+}
+
+export * from './createBrowserHistory';
+export * from './createHashHistory';
+export * from './createMemoryHistory';
+export { createLocation, locationsAreEqual } from './LocationUtils';
+export { parsePath, createPath } from './PathUtils';
+export { createBrowserHistory, createHashHistory, createMemoryHistory };

node_modules/@types/history/package.json

@@ -0,0 +1,40 @@
+{
+    "name": "@types/history",
+    "version": "4.7.11",
+    "description": "TypeScript definitions for history",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/history",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Sergey Buturlakin",
+            "url": "https://github.com/sergey-buturlakin",
+            "githubUsername": "sergey-buturlakin"
+        },
+        {
+            "name": "Nathan Brown",
+            "url": "https://github.com/ngbrown",
+            "githubUsername": "ngbrown"
+        },
+        {
+            "name": "Young Rok Kim",
+            "url": "https://github.com/rokoroku",
+            "githubUsername": "rokoroku"
+        },
+        {
+            "name": "Daniel Nixon",
+            "url": "https://github.com/danielnixon",
+            "githubUsername": "danielnixon"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/history"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "141516ba36ab9f2b221dc957cba4ac21d9a06776c05786e6773c5581f8cf7455",
+    "typeScriptVersion": "3.8"
+}

node_modules/@types/html-minifier-terser/LICENSE

@@ -0,0 +1,21 @@
+    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/html-minifier-terser/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/html-minifier-terser`
+
+# Summary
+This package contains type definitions for html-minifier-terser (https://github.com/terser/html-minifier-terser#readme).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/html-minifier-terser.
+
+### Additional Details
+ * Last updated: Tue, 23 Nov 2021 21:01:04 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Piotr Błażejewicz](https://github.com/peterblazejewicz).

node_modules/@types/html-minifier-terser/index.d.ts

@@ -0,0 +1,211 @@
+// Type definitions for html-minifier-terser 6.1
+// Project: https://github.com/terser/html-minifier-terser#readme
+// Definitions by: Piotr Błażejewicz <https://github.com/peterblazejewicz>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/**
+ * HTMLMinifier is a highly configurable, well-tested, JavaScript-based HTML minifier.
+ * @async
+ */
+export function minify(value: string, options?: Options): Promise<string>;
+
+/**
+ * Most of the options are disabled by default
+ */
+export interface Options {
+    /**
+     * Treat attributes in case sensitive manner (useful for custom HTML tags)
+     * @default false
+     */
+    caseSensitive?: boolean | undefined;
+    /**
+     * Omit attribute values from boolean attributes
+     * @default false
+     */
+    collapseBooleanAttributes?: boolean | undefined;
+    /**
+     * Don't leave any spaces between display:inline;
+     * elements when collapsing. Must be used in conjunction with collapseWhitespace=true
+     * @default false
+     */
+    collapseInlineTagWhitespace?: boolean | undefined;
+    /**
+     * Collapse white space that contributes to text nodes in a document tree
+     * @default false
+     */
+    collapseWhitespace?: boolean | undefined;
+    /**
+     * Always collapse to 1 space (never remove it entirely). Must be used in conjunction with `collapseWhitespace=true`
+     * @default false
+     */
+    conservativeCollapse?: boolean | undefined;
+    /**
+     * Handle parse errors
+     * @default false
+     */
+    continueOnParseError?: boolean | undefined;
+    /**
+     * Arrays of regex'es that allow to support custom attribute assign expressions (e.g. `'<div flex?="{{mode != cover}}"></div>'`)
+     * @default []
+     */
+    customAttrAssign?: RegExp[] | undefined;
+    /**
+     * Regex that specifies custom attribute to strip newlines from (e.g. `/ng-class/`
+     */
+    customAttrCollapse?: RegExp | undefined;
+    /**
+     * Arrays of regex'es that allow to support custom attribute surround expressions (e.g. `<input {{#if value}}checked="checked"{{/if}}>`)
+     * @default []
+     */
+    customAttrSurround?: RegExp[] | undefined;
+    /**
+     * Arrays of regex'es that allow to support custom event attributes for `minifyJS` (e.g. `ng-click`)
+     * @default [/^on[a-z]{3,}$/]
+     */
+    customEventAttributes?: RegExp[] | undefined;
+    /**
+     * Use direct Unicode characters whenever possible
+     * @default false
+     */
+    decodeEntities?: boolean | undefined;
+    /**
+     * Parse input according to HTML5 specifications
+     * @default true
+     */
+    html5?: boolean | undefined;
+    /**
+     * Array of regex'es that allow to ignore certain comments, when matched
+     * @default [ /^!/, /^\s*#/ ]
+     */
+    ignoreCustomComments?: RegExp[] | undefined;
+    /**
+     * Array of regex'es that allow to ignore certain fragments, when matched (e.g. `<?php ... ?>`, `{{ ... }}`, etc.)
+     * @default [/<%[\s\S]*?%>/, /<\?[\s\S]\*?\?>/]
+     */
+    ignoreCustomFragments?: RegExp[] | undefined;
+    /**
+     * Insert tags generated by HTML parser
+     * @default true
+     */
+    includeAutoGeneratedTags?: boolean | undefined;
+    /**
+     * Keep the trailing slash on singleton elements
+     * @default false
+     */
+    keepClosingSlash?: boolean | undefined;
+    /**
+     * Specify a maximum line length. Compressed output will be split by newlines at valid HTML split-points
+     */
+    maxLineLength?: number | undefined;
+    /**
+     * Minify CSS in style elements and style attributes
+     * @default false
+     */
+    minifyCSS?: boolean | object | ((text: string, type?: string) => string) | undefined;
+    /**
+     * Minify JavaScript in script elements and event attributes
+     * @default false
+     */
+    minifyJS?: boolean | object | ((text: string, inline?: boolean) => string) | undefined;
+    /**
+     * Minify URLs in various attributes
+     * @default false
+     */
+    minifyURLs?: boolean | string | object | ((text: string) => string) | undefined;
+    /**
+     * Never add a newline before a tag that closes an element
+     * @default false
+     */
+    noNewlinesBeforeTagClose?: boolean | undefined;
+    /**
+     * Always collapse to 1 line break (never remove it entirely) when whitespace between tags include a line break.
+     * Must be used in conjunction with `collapseWhitespace=true`
+     * @default false
+     */
+    preserveLineBreaks?: boolean | undefined;
+    /**
+     * Prevents the escaping of the values of attributes
+     * @default false
+     */
+    preventAttributesEscaping?: boolean | undefined;
+    /**
+     * Process contents of conditional comments through minifier
+     * @default false
+     */
+    processConditionalComments?: boolean | undefined;
+    /**
+     * Array of strings corresponding to types of script elements to process through minifier
+     * (e.g. `text/ng-template`, `text/x-handlebars-template`, etc.)
+     * @default []
+     */
+    processScripts?: string[] | undefined;
+    /**
+     * Type of quote to use for attribute values (' or ")
+     */
+    quoteCharacter?: string | undefined;
+    /**
+     * Remove quotes around attributes when possible
+     * @default false
+     */
+    removeAttributeQuotes?: boolean | undefined;
+    /**
+     * Strip HTML comments
+     * @default false
+     */
+    removeComments?: boolean | undefined;
+    /**
+     * Remove all attributes with whitespace-only values
+     * @default false
+     */
+    removeEmptyAttributes?: boolean | ((attrName: string, tag: string) => boolean) | undefined;
+    /**
+     * Remove all elements with empty contents
+     * @default false
+     */
+    removeEmptyElements?: boolean | undefined;
+    /**
+     * Remove optional tags
+     * @default false
+     */
+    removeOptionalTags?: boolean | undefined;
+    /**
+     * Remove attributes when value matches default
+     * @default false
+     */
+    removeRedundantAttributes?: boolean | undefined;
+    /**
+     * Remove `type="text/javascript"` from `script` tags. Other `type` attribute values are left intact
+     * @default false
+     */
+    removeScriptTypeAttributes?: boolean | undefined;
+    /**
+     * Remove `type="text/css"` from `style` and `link` tags. Other `type` attribute values are left intact
+     * @default false
+     */
+    removeStyleLinkTypeAttributes?: boolean | undefined;
+    /**
+     * Remove space between attributes whenever possible. **Note that this will result in invalid HTML!**
+     * @default false
+     */
+    removeTagWhitespace?: boolean | undefined;
+    /**
+     * Sort attributes by frequency
+     * @default false
+     */
+    sortAttributes?: boolean | undefined;
+    /**
+     * Sort style classes by frequency
+     * @default false
+     */
+    sortClassName?: boolean | undefined;
+    /**
+     * Trim white space around `ignoreCustomFragments`
+     * @default false
+     */
+    trimCustomFragments?: boolean | undefined;
+    /**
+     * Replaces the `doctype` with the short (HTML5) doctype
+     * @default false
+     */
+    useShortDoctype?: boolean | undefined;
+}

node_modules/@types/html-minifier-terser/package.json

@@ -0,0 +1,25 @@
+{
+    "name": "@types/html-minifier-terser",
+    "version": "6.1.0",
+    "description": "TypeScript definitions for html-minifier-terser",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/html-minifier-terser",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Piotr Błażejewicz",
+            "url": "https://github.com/peterblazejewicz",
+            "githubUsername": "peterblazejewicz"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/html-minifier-terser"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "e851f65ded989d19a70b471ff32b156ed08fec7ed641ce4c5a7fdee809bd53e2",
+    "typeScriptVersion": "3.8"
+}

node_modules/@types/http-cache-semantics/LICENSE

@@ -0,0 +1,21 @@
+    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/http-cache-semantics/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/http-cache-semantics`
+
+# Summary
+This package contains type definitions for http-cache-semantics (https://github.com/kornelski/http-cache-semantics#readme).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/http-cache-semantics.
+
+### Additional Details
+ * Last updated: Tue, 07 Nov 2023 03:09:37 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [BendingBender](https://github.com/BendingBender).

node_modules/@types/http-cache-semantics/index.d.ts

@@ -0,0 +1,165 @@
+export = CachePolicy;
+
+declare class CachePolicy {
+    constructor(req: CachePolicy.Request, res: CachePolicy.Response, options?: CachePolicy.Options);
+
+    /**
+     * Returns `true` if the response can be stored in a cache.
+     * If it's `false` then you MUST NOT store either the request or the response.
+     */
+    storable(): boolean;
+
+    /**
+     * This is the most important method. Use this method to check whether the cached response is still fresh
+     * in the context of the new request.
+     *
+     * If it returns `true`, then the given `request` matches the original response this cache policy has been
+     * created with, and the response can be reused without contacting the server. Note that the old response
+     * can't be returned without being updated, see `responseHeaders()`.
+     *
+     * If it returns `false`, then the response may not be matching at all (e.g. it's for a different URL or method),
+     * or may require to be refreshed first (see `revalidationHeaders()`).
+     */
+    satisfiesWithoutRevalidation(newRequest: CachePolicy.Request): boolean;
+
+    /**
+     * Returns updated, filtered set of response headers to return to clients receiving the cached response.
+     * This function is necessary, because proxies MUST always remove hop-by-hop headers (such as `TE` and `Connection`)
+     * and update response's `Age` to avoid doubling cache time.
+     *
+     * @example
+     * cachedResponse.headers = cachePolicy.responseHeaders(cachedResponse);
+     */
+    responseHeaders(): CachePolicy.Headers;
+
+    /**
+     * Returns approximate time in milliseconds until the response becomes stale (i.e. not fresh).
+     *
+     * After that time (when `timeToLive() <= 0`) the response might not be usable without revalidation. However,
+     * there are exceptions, e.g. a client can explicitly allow stale responses, so always check with
+     * `satisfiesWithoutRevalidation()`.
+     */
+    timeToLive(): number;
+
+    /**
+     * Chances are you'll want to store the `CachePolicy` object along with the cached response.
+     * `obj = policy.toObject()` gives a plain JSON-serializable object.
+     */
+    toObject(): CachePolicy.CachePolicyObject;
+
+    /**
+     * `policy = CachePolicy.fromObject(obj)` creates an instance from object created by `toObject()`.
+     */
+    static fromObject(obj: CachePolicy.CachePolicyObject): CachePolicy;
+
+    /**
+     * Returns updated, filtered set of request headers to send to the origin server to check if the cached
+     * response can be reused. These headers allow the origin server to return status 304 indicating the
+     * response is still fresh. All headers unrelated to caching are passed through as-is.
+     *
+     * Use this method when updating cache from the origin server.
+     *
+     * @example
+     * updateRequest.headers = cachePolicy.revalidationHeaders(updateRequest);
+     */
+    revalidationHeaders(newRequest: CachePolicy.Request): CachePolicy.Headers;
+
+    /**
+     * Use this method to update the cache after receiving a new response from the origin server.
+     */
+    revalidatedPolicy(
+        revalidationRequest: CachePolicy.Request,
+        revalidationResponse: CachePolicy.Response,
+    ): CachePolicy.RevalidationPolicy;
+}
+
+declare namespace CachePolicy {
+    interface Request {
+        url?: string | undefined;
+        method?: string | undefined;
+        headers: Headers;
+    }
+
+    interface Response {
+        status?: number | undefined;
+        headers: Headers;
+    }
+
+    interface Options {
+        /**
+         * If `true`, then the response is evaluated from a perspective of a shared cache (i.e. `private` is not
+         * cacheable and `s-maxage` is respected). If `false`, then the response is evaluated from a perspective
+         * of a single-user cache (i.e. `private` is cacheable and `s-maxage` is ignored).
+         * `true` is recommended for HTTP clients.
+         * @default true
+         */
+        shared?: boolean | undefined;
+        /**
+         * A fraction of response's age that is used as a fallback cache duration. The default is 0.1 (10%),
+         * e.g. if a file hasn't been modified for 100 days, it'll be cached for 100*0.1 = 10 days.
+         * @default 0.1
+         */
+        cacheHeuristic?: number | undefined;
+        /**
+         * A number of milliseconds to assume as the default time to cache responses with `Cache-Control: immutable`.
+         * Note that [per RFC](https://httpwg.org/specs/rfc8246.html#the-immutable-cache-control-extension)
+         * these can become stale, so `max-age` still overrides the default.
+         * @default 24*3600*1000 (24h)
+         */
+        immutableMinTimeToLive?: number | undefined;
+        /**
+         * If `true`, common anti-cache directives will be completely ignored if the non-standard `pre-check`
+         * and `post-check` directives are present. These two useless directives are most commonly found
+         * in bad StackOverflow answers and PHP's "session limiter" defaults.
+         * @default false
+         */
+        ignoreCargoCult?: boolean | undefined;
+        /**
+         * If `false`, then server's `Date` header won't be used as the base for `max-age`. This is against the RFC,
+         * but it's useful if you want to cache responses with very short `max-age`, but your local clock
+         * is not exactly in sync with the server's.
+         * @default true
+         */
+        trustServerDate?: boolean | undefined;
+    }
+
+    interface CachePolicyObject {
+        v: number;
+        t: number;
+        sh: boolean;
+        ch: number;
+        imm: number;
+        st: number;
+        resh: Headers;
+        rescc: { [key: string]: string };
+        m: string;
+        u?: string | undefined;
+        h?: string | undefined;
+        a: boolean;
+        reqh: Headers | null;
+        reqcc: { [key: string]: string };
+    }
+
+    interface Headers {
+        [header: string]: string | string[] | undefined;
+    }
+
+    interface RevalidationPolicy {
+        /**
+         * A new `CachePolicy` with HTTP headers updated from `revalidationResponse`. You can always replace
+         * the old cached `CachePolicy` with the new one.
+         */
+        policy: CachePolicy;
+        /**
+         * Boolean indicating whether the response body has changed.
+         *
+         * - If `false`, then a valid 304 Not Modified response has been received, and you can reuse the old
+         * cached response body.
+         * - If `true`, you should use new response's body (if present), or make another request to the origin
+         * server without any conditional headers (i.e. don't use `revalidationHeaders()` this time) to get
+         * the new resource.
+         */
+        modified: boolean;
+        matches: boolean;
+    }
+}

node_modules/@types/http-cache-semantics/package.json

@@ -0,0 +1,25 @@
+{
+    "name": "@types/http-cache-semantics",
+    "version": "4.0.4",
+    "description": "TypeScript definitions for http-cache-semantics",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/http-cache-semantics",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "BendingBender",
+            "githubUsername": "BendingBender",
+            "url": "https://github.com/BendingBender"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/http-cache-semantics"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "6cf8e230d4a5ae72d31765a8facf404307c59791befc65343d177843c7bbae91",
+    "typeScriptVersion": "4.5"
+}

node_modules/@types/http-errors/LICENSE

@@ -0,0 +1,21 @@
+    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/http-errors/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/http-errors`
+
+# Summary
+This package contains type definitions for http-errors (https://github.com/jshttp/http-errors).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/http-errors.
+
+### Additional Details
+ * Last updated: Tue, 07 Nov 2023 03:09:37 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [Tanguy Krotoff](https://github.com/tkrotoff), and [BendingBender](https://github.com/BendingBender).

node_modules/@types/http-errors/index.d.ts

@@ -0,0 +1,77 @@
+export = createHttpError;
+
+declare const createHttpError: createHttpError.CreateHttpError & createHttpError.NamedConstructors & {
+    isHttpError: createHttpError.IsHttpError;
+};
+
+declare namespace createHttpError {
+    interface HttpError<N extends number = number> extends Error {
+        status: N;
+        statusCode: N;
+        expose: boolean;
+        headers?: {
+            [key: string]: string;
+        } | undefined;
+        [key: string]: any;
+    }
+
+    type UnknownError = Error | string | { [key: string]: any };
+
+    interface HttpErrorConstructor<N extends number = number> {
+        (msg?: string): HttpError<N>;
+        new(msg?: string): HttpError<N>;
+    }
+
+    interface CreateHttpError {
+        <N extends number = number>(arg: N, ...rest: UnknownError[]): HttpError<N>;
+        (...rest: UnknownError[]): HttpError;
+    }
+
+    type IsHttpError = (error: unknown) => error is HttpError;
+
+    type NamedConstructors =
+        & {
+            HttpError: HttpErrorConstructor;
+        }
+        & Record<"BadRequest" | "400", HttpErrorConstructor<400>>
+        & Record<"Unauthorized" | "401", HttpErrorConstructor<401>>
+        & Record<"PaymentRequired" | "402", HttpErrorConstructor<402>>
+        & Record<"Forbidden" | "403", HttpErrorConstructor<403>>
+        & Record<"NotFound" | "404", HttpErrorConstructor<404>>
+        & Record<"MethodNotAllowed" | "405", HttpErrorConstructor<405>>
+        & Record<"NotAcceptable" | "406", HttpErrorConstructor<406>>
+        & Record<"ProxyAuthenticationRequired" | "407", HttpErrorConstructor<407>>
+        & Record<"RequestTimeout" | "408", HttpErrorConstructor<408>>
+        & Record<"Conflict" | "409", HttpErrorConstructor<409>>
+        & Record<"Gone" | "410", HttpErrorConstructor<410>>
+        & Record<"LengthRequired" | "411", HttpErrorConstructor<411>>
+        & Record<"PreconditionFailed" | "412", HttpErrorConstructor<412>>
+        & Record<"PayloadTooLarge" | "413", HttpErrorConstructor<413>>
+        & Record<"URITooLong" | "414", HttpErrorConstructor<414>>
+        & Record<"UnsupportedMediaType" | "415", HttpErrorConstructor<415>>
+        & Record<"RangeNotSatisfiable" | "416", HttpErrorConstructor<416>>
+        & Record<"ExpectationFailed" | "417", HttpErrorConstructor<417>>
+        & Record<"ImATeapot" | "418", HttpErrorConstructor<418>>
+        & Record<"MisdirectedRequest" | "421", HttpErrorConstructor<421>>
+        & Record<"UnprocessableEntity" | "422", HttpErrorConstructor<422>>
+        & Record<"Locked" | "423", HttpErrorConstructor<423>>
+        & Record<"FailedDependency" | "424", HttpErrorConstructor<424>>
+        & Record<"TooEarly" | "425", HttpErrorConstructor<425>>
+        & Record<"UpgradeRequired" | "426", HttpErrorConstructor<426>>
+        & Record<"PreconditionRequired" | "428", HttpErrorConstructor<428>>
+        & Record<"TooManyRequests" | "429", HttpErrorConstructor<429>>
+        & Record<"RequestHeaderFieldsTooLarge" | "431", HttpErrorConstructor<431>>
+        & Record<"UnavailableForLegalReasons" | "451", HttpErrorConstructor<451>>
+        & Record<"InternalServerError" | "500", HttpErrorConstructor<500>>
+        & Record<"NotImplemented" | "501", HttpErrorConstructor<501>>
+        & Record<"BadGateway" | "502", HttpErrorConstructor<502>>
+        & Record<"ServiceUnavailable" | "503", HttpErrorConstructor<503>>
+        & Record<"GatewayTimeout" | "504", HttpErrorConstructor<504>>
+        & Record<"HTTPVersionNotSupported" | "505", HttpErrorConstructor<505>>
+        & Record<"VariantAlsoNegotiates" | "506", HttpErrorConstructor<506>>
+        & Record<"InsufficientStorage" | "507", HttpErrorConstructor<507>>
+        & Record<"LoopDetected" | "508", HttpErrorConstructor<508>>
+        & Record<"BandwidthLimitExceeded" | "509", HttpErrorConstructor<509>>
+        & Record<"NotExtended" | "510", HttpErrorConstructor<510>>
+        & Record<"NetworkAuthenticationRequire" | "511", HttpErrorConstructor<511>>;
+}

node_modules/@types/http-errors/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@types/http-errors",
+    "version": "2.0.4",
+    "description": "TypeScript definitions for http-errors",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/http-errors",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Tanguy Krotoff",
+            "githubUsername": "tkrotoff",
+            "url": "https://github.com/tkrotoff"
+        },
+        {
+            "name": "BendingBender",
+            "githubUsername": "BendingBender",
+            "url": "https://github.com/BendingBender"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/http-errors"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "06e33723b60f818facd3b7dd2025f043142fb7c56ab4832babafeb9470f2086f",
+    "typeScriptVersion": "4.5"
+}

node_modules/@types/http-proxy/LICENSE

@@ -0,0 +1,21 @@
+    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/http-proxy/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/http-proxy`
+
+# Summary
+This package contains type definitions for http-proxy (https://github.com/nodejitsu/node-http-proxy).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/http-proxy.
+
+### Additional Details
+ * Last updated: Tue, 07 Nov 2023 03:09:37 GMT
+ * Dependencies: [@types/node](https://npmjs.com/package/@types/node)
+
+# Credits
+These definitions were written by [Maxime LUCE](https://github.com/SomaticIT), [Florian Oellerich](https://github.com/Raigen), [Daniel Schmidt](https://github.com/DanielMSchmidt), [Jordan Abreu](https://github.com/jabreu610), and [Samuel Bodin](https://github.com/bodinsamuel).

node_modules/@types/http-proxy/index.d.ts

@@ -0,0 +1,250 @@
+/// <reference types="node" />
+
+import * as events from "events";
+import * as http from "http";
+import * as https from "https";
+import * as net from "net";
+import * as stream from "stream";
+import * as url from "url";
+
+interface ProxyTargetDetailed {
+    host: string;
+    port: number;
+    protocol?: string | undefined;
+    hostname?: string | undefined;
+    socketPath?: string | undefined;
+    key?: string | undefined;
+    passphrase?: string | undefined;
+    pfx?: Buffer | string | undefined;
+    cert?: string | undefined;
+    ca?: string | undefined;
+    ciphers?: string | undefined;
+    secureProtocol?: string | undefined;
+}
+
+declare class Server<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse>
+    extends events.EventEmitter
+{
+    /**
+     * Creates the proxy server with specified options.
+     * @param options - Config object passed to the proxy
+     */
+    constructor(options?: Server.ServerOptions);
+
+    /**
+     * Used for proxying regular HTTP(S) requests
+     * @param req - Client request.
+     * @param res - Client response.
+     * @param options - Additional options.
+     */
+    web(
+        req: http.IncomingMessage,
+        res: http.ServerResponse,
+        options?: Server.ServerOptions,
+        callback?: Server.ErrorCallback,
+    ): void;
+
+    /**
+     * Used for proxying regular HTTP(S) requests
+     * @param req - Client request.
+     * @param socket - Client socket.
+     * @param head - Client head.
+     * @param options - Additionnal options.
+     */
+    ws(
+        req: http.IncomingMessage,
+        socket: any,
+        head: any,
+        options?: Server.ServerOptions,
+        callback?: Server.ErrorCallback,
+    ): void;
+
+    /**
+     * A function that wraps the object in a webserver, for your convenience
+     * @param port - Port to listen on
+     * @param hostname - The hostname to listen on
+     */
+    listen(port: number, hostname?: string): Server<TIncomingMessage, TServerResponse>;
+
+    /**
+     * A function that closes the inner webserver and stops listening on given port
+     */
+    close(callback?: () => void): void;
+
+    /**
+     * Creates the proxy server with specified options.
+     * @param options Config object passed to the proxy
+     * @returns Proxy object with handlers for `ws` and `web` requests
+     */
+    // tslint:disable:no-unnecessary-generics
+    static createProxyServer<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse>(
+        options?: Server.ServerOptions,
+    ): Server<TIncomingMessage, TServerResponse>;
+
+    /**
+     * Creates the proxy server with specified options.
+     * @param options Config object passed to the proxy
+     * @returns Proxy object with handlers for `ws` and `web` requests
+     */
+    // tslint:disable:no-unnecessary-generics
+    static createServer<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse>(
+        options?: Server.ServerOptions,
+    ): Server<TIncomingMessage, TServerResponse>;
+
+    /**
+     * Creates the proxy server with specified options.
+     * @param options Config object passed to the proxy
+     * @returns Proxy object with handlers for `ws` and `web` requests
+     */
+    // tslint:disable:no-unnecessary-generics
+    static createProxy<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse>(
+        options?: Server.ServerOptions,
+    ): Server<TIncomingMessage, TServerResponse>;
+
+    addListener(event: string, listener: () => void): this;
+    on(event: string, listener: () => void): this;
+    on(event: "error", listener: Server.ErrorCallback<Error, TIncomingMessage, TServerResponse>): this;
+    on(event: "start", listener: Server.StartCallback<TIncomingMessage, TServerResponse>): this;
+    on(
+        event: "proxyReq",
+        listener: Server.ProxyReqCallback<http.ClientRequest, TIncomingMessage, TServerResponse>,
+    ): this;
+    on(event: "proxyRes", listener: Server.ProxyResCallback<TIncomingMessage, TServerResponse>): this;
+    on(event: "proxyReqWs", listener: Server.ProxyReqWsCallback<http.ClientRequest, TIncomingMessage>): this;
+    on(event: "econnreset", listener: Server.EconnresetCallback<Error, TIncomingMessage, TServerResponse>): this;
+    on(event: "end", listener: Server.EndCallback<TIncomingMessage, TServerResponse>): this;
+    on(event: "open", listener: Server.OpenCallback): this;
+    on(event: "close", listener: Server.CloseCallback<TIncomingMessage>): this;
+
+    once(event: string, listener: () => void): this;
+    once(event: "error", listener: Server.ErrorCallback<Error, TIncomingMessage, TServerResponse>): this;
+    once(event: "start", listener: Server.StartCallback<TIncomingMessage, TServerResponse>): this;
+    once(
+        event: "proxyReq",
+        listener: Server.ProxyReqCallback<http.ClientRequest, TIncomingMessage, TServerResponse>,
+    ): this;
+    once(event: "proxyRes", listener: Server.ProxyResCallback<TIncomingMessage, TServerResponse>): this;
+    once(event: "proxyReqWs", listener: Server.ProxyReqWsCallback<http.ClientRequest, TIncomingMessage>): this;
+    once(event: "econnreset", listener: Server.EconnresetCallback<Error, TIncomingMessage, TServerResponse>): this;
+    once(event: "end", listener: Server.EndCallback<TIncomingMessage, TServerResponse>): this;
+    once(event: "open", listener: Server.OpenCallback): this;
+    once(event: "close", listener: Server.CloseCallback<TIncomingMessage>): this;
+    removeListener(event: string, listener: () => void): this;
+    removeAllListeners(event?: string): this;
+    getMaxListeners(): number;
+    setMaxListeners(n: number): this;
+    listeners(event: string): Array<() => void>;
+    emit(event: string, ...args: any[]): boolean;
+    listenerCount(type: string): number;
+}
+
+declare namespace Server {
+    type ProxyTarget = ProxyTargetUrl | ProxyTargetDetailed;
+    type ProxyTargetUrl = string | Partial<url.Url>;
+
+    interface ServerOptions {
+        /** URL string to be parsed with the url module. */
+        target?: ProxyTarget | undefined;
+        /** URL string to be parsed with the url module. */
+        forward?: ProxyTargetUrl | undefined;
+        /** Object to be passed to http(s).request. */
+        agent?: any;
+        /** Object to be passed to https.createServer(). */
+        ssl?: any;
+        /** If you want to proxy websockets. */
+        ws?: boolean | undefined;
+        /** Adds x- forward headers. */
+        xfwd?: boolean | undefined;
+        /** Verify SSL certificate. */
+        secure?: boolean | undefined;
+        /** Explicitly specify if we are proxying to another proxy. */
+        toProxy?: boolean | undefined;
+        /** Specify whether you want to prepend the target's path to the proxy path. */
+        prependPath?: boolean | undefined;
+        /** Specify whether you want to ignore the proxy path of the incoming request. */
+        ignorePath?: boolean | undefined;
+        /** Local interface string to bind for outgoing connections. */
+        localAddress?: string | undefined;
+        /** Changes the origin of the host header to the target URL. */
+        changeOrigin?: boolean | undefined;
+        /** specify whether you want to keep letter case of response header key */
+        preserveHeaderKeyCase?: boolean | undefined;
+        /** Basic authentication i.e. 'user:password' to compute an Authorization header. */
+        auth?: string | undefined;
+        /** Rewrites the location hostname on (301 / 302 / 307 / 308) redirects, Default: null. */
+        hostRewrite?: string | undefined;
+        /** Rewrites the location host/ port on (301 / 302 / 307 / 308) redirects based on requested host/ port.Default: false. */
+        autoRewrite?: boolean | undefined;
+        /** Rewrites the location protocol on (301 / 302 / 307 / 308) redirects to 'http' or 'https'.Default: null. */
+        protocolRewrite?: string | undefined;
+        /** rewrites domain of set-cookie headers. */
+        cookieDomainRewrite?: false | string | { [oldDomain: string]: string } | undefined;
+        /** rewrites path of set-cookie headers. Default: false */
+        cookiePathRewrite?: false | string | { [oldPath: string]: string } | undefined;
+        /** object with extra headers to be added to target requests. */
+        headers?: { [header: string]: string } | undefined;
+        /** Timeout (in milliseconds) when proxy receives no response from target. Default: 120000 (2 minutes) */
+        proxyTimeout?: number | undefined;
+        /** Timeout (in milliseconds) for incoming requests */
+        timeout?: number | undefined;
+        /** Specify whether you want to follow redirects. Default: false */
+        followRedirects?: boolean | undefined;
+        /** If set to true, none of the webOutgoing passes are called and it's your responsibility to appropriately return the response by listening and acting on the proxyRes event */
+        selfHandleResponse?: boolean | undefined;
+        /** Buffer */
+        buffer?: stream.Stream | undefined;
+    }
+
+    type StartCallback<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse> = (
+        req: TIncomingMessage,
+        res: TServerResponse,
+        target: ProxyTargetUrl,
+    ) => void;
+    type ProxyReqCallback<
+        TClientRequest = http.ClientRequest,
+        TIncomingMessage = http.IncomingMessage,
+        TServerResponse = http.ServerResponse,
+    > = (proxyReq: TClientRequest, req: TIncomingMessage, res: TServerResponse, options: ServerOptions) => void;
+    type ProxyResCallback<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse> = (
+        proxyRes: TIncomingMessage,
+        req: TIncomingMessage,
+        res: TServerResponse,
+    ) => void;
+    type ProxyReqWsCallback<TClientRequest = http.ClientRequest, TIncomingMessage = http.IncomingMessage> = (
+        proxyReq: TClientRequest,
+        req: TIncomingMessage,
+        socket: net.Socket,
+        options: ServerOptions,
+        head: any,
+    ) => void;
+    type EconnresetCallback<
+        TError = Error,
+        TIncomingMessage = http.IncomingMessage,
+        TServerResponse = http.ServerResponse,
+    > = (
+        err: TError,
+        req: TIncomingMessage,
+        res: TServerResponse,
+        target: ProxyTargetUrl,
+    ) => void;
+    type EndCallback<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse> = (
+        req: TIncomingMessage,
+        res: TServerResponse,
+        proxyRes: TIncomingMessage,
+    ) => void;
+    type OpenCallback = (proxySocket: net.Socket) => void;
+    type CloseCallback<TIncomingMessage = http.IncomingMessage> = (
+        proxyRes: TIncomingMessage,
+        proxySocket: net.Socket,
+        proxyHead: any,
+    ) => void;
+    type ErrorCallback<TError = Error, TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse> =
+        (
+            err: TError,
+            req: TIncomingMessage,
+            res: TServerResponse | net.Socket,
+            target?: ProxyTargetUrl,
+        ) => void;
+}
+
+export = Server;

node_modules/@types/http-proxy/package.json

@@ -0,0 +1,47 @@
+{
+    "name": "@types/http-proxy",
+    "version": "1.17.14",
+    "description": "TypeScript definitions for http-proxy",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/http-proxy",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Maxime LUCE",
+            "githubUsername": "SomaticIT",
+            "url": "https://github.com/SomaticIT"
+        },
+        {
+            "name": "Florian Oellerich",
+            "githubUsername": "Raigen",
+            "url": "https://github.com/Raigen"
+        },
+        {
+            "name": "Daniel Schmidt",
+            "githubUsername": "DanielMSchmidt",
+            "url": "https://github.com/DanielMSchmidt"
+        },
+        {
+            "name": "Jordan Abreu",
+            "githubUsername": "jabreu610",
+            "url": "https://github.com/jabreu610"
+        },
+        {
+            "name": "Samuel Bodin",
+            "githubUsername": "bodinsamuel",
+            "url": "https://github.com/bodinsamuel"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/http-proxy"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/node": "*"
+    },
+    "typesPublisherContentHash": "3e198b1ca48b5a5de433fc322508d2fec21a03c1b52c9470ee47b725146db123",
+    "typeScriptVersion": "4.5"
+}

node_modules/@types/istanbul-lib-coverage/LICENSE

@@ -0,0 +1,21 @@
+    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/istanbul-lib-coverage/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/istanbul-lib-coverage`
+
+# Summary
+This package contains type definitions for istanbul-lib-coverage (https://istanbul.js.org).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/istanbul-lib-coverage.
+
+### Additional Details
+ * Last updated: Tue, 07 Nov 2023 03:09:37 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [Jason Cheatham](https://github.com/jason0x43).

node_modules/@types/istanbul-lib-coverage/index.d.ts

@@ -0,0 +1,111 @@
+export interface CoverageSummaryData {
+    lines: Totals;
+    statements: Totals;
+    branches: Totals;
+    functions: Totals;
+}
+
+export class CoverageSummary {
+    constructor(data: CoverageSummary | CoverageSummaryData);
+    merge(obj: CoverageSummary): CoverageSummary;
+    toJSON(): CoverageSummaryData;
+    isEmpty(): boolean;
+    data: CoverageSummaryData;
+    lines: Totals;
+    statements: Totals;
+    branches: Totals;
+    functions: Totals;
+}
+
+export interface CoverageMapData {
+    [key: string]: FileCoverage | FileCoverageData;
+}
+
+export class CoverageMap {
+    constructor(data: CoverageMapData | CoverageMap);
+    addFileCoverage(pathOrObject: string | FileCoverage | FileCoverageData): void;
+    files(): string[];
+    fileCoverageFor(filename: string): FileCoverage;
+    filter(callback: (key: string) => boolean): void;
+    getCoverageSummary(): CoverageSummary;
+    merge(data: CoverageMapData | CoverageMap): void;
+    toJSON(): CoverageMapData;
+    data: CoverageMapData;
+}
+
+export interface Location {
+    line: number;
+    column: number;
+}
+
+export interface Range {
+    start: Location;
+    end: Location;
+}
+
+export interface BranchMapping {
+    loc: Range;
+    type: string;
+    locations: Range[];
+    line: number;
+}
+
+export interface FunctionMapping {
+    name: string;
+    decl: Range;
+    loc: Range;
+    line: number;
+}
+
+export interface FileCoverageData {
+    path: string;
+    statementMap: { [key: string]: Range };
+    fnMap: { [key: string]: FunctionMapping };
+    branchMap: { [key: string]: BranchMapping };
+    s: { [key: string]: number };
+    f: { [key: string]: number };
+    b: { [key: string]: number[] };
+}
+
+export interface Totals {
+    total: number;
+    covered: number;
+    skipped: number;
+    pct: number;
+}
+
+export interface Coverage {
+    covered: number;
+    total: number;
+    coverage: number;
+}
+
+export class FileCoverage implements FileCoverageData {
+    constructor(data: string | FileCoverage | FileCoverageData);
+    merge(other: FileCoverageData): void;
+    getBranchCoverageByLine(): { [line: number]: Coverage };
+    getLineCoverage(): { [line: number]: number };
+    getUncoveredLines(): number[];
+    resetHits(): void;
+    computeBranchTotals(): Totals;
+    computeSimpleTotals(): Totals;
+    toSummary(): CoverageSummary;
+    toJSON(): object;
+
+    data: FileCoverageData;
+    path: string;
+    statementMap: { [key: string]: Range };
+    fnMap: { [key: string]: FunctionMapping };
+    branchMap: { [key: string]: BranchMapping };
+    s: { [key: string]: number };
+    f: { [key: string]: number };
+    b: { [key: string]: number[] };
+}
+
+export const classes: {
+    FileCoverage: FileCoverage;
+};
+
+export function createCoverageMap(data?: CoverageMap | CoverageMapData): CoverageMap;
+export function createCoverageSummary(obj?: CoverageSummary | CoverageSummaryData): CoverageSummary;
+export function createFileCoverage(pathOrObject: string | FileCoverage | FileCoverageData): FileCoverage;

node_modules/@types/istanbul-lib-coverage/package.json

@@ -0,0 +1,25 @@
+{
+    "name": "@types/istanbul-lib-coverage",
+    "version": "2.0.6",
+    "description": "TypeScript definitions for istanbul-lib-coverage",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/istanbul-lib-coverage",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Jason Cheatham",
+            "githubUsername": "jason0x43",
+            "url": "https://github.com/jason0x43"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/istanbul-lib-coverage"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "36c823c8b3f66dab91254b0f7299de71768ad8836bfbfcaa062409dd86fbbd61",
+    "typeScriptVersion": "4.5"
+}