first commit

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, 24 Mar 2025 07:34:10 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,694 @@
+// 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 | PrivateIdentifier;
+    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>;
+    attributes: ImportAttribute[];
+    source: Literal;
+}
+
+export interface ImportSpecifier extends BaseModuleSpecifier {
+    type: "ImportSpecifier";
+    imported: Identifier | Literal;
+}
+
+export interface ImportAttribute extends BaseNode {
+    type: "ImportAttribute";
+    key: Identifier | Literal;
+    value: Literal;
+}
+
+export interface ImportExpression extends BaseExpression {
+    type: "ImportExpression";
+    source: Expression;
+    options?: Expression | null | undefined;
+}
+
+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[];
+    attributes: ImportAttribute[];
+    source?: Literal | null | undefined;
+}
+
+export interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
+    type: "ExportSpecifier";
+    local: Identifier | Literal;
+    exported: Identifier | Literal;
+}
+
+export interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+    type: "ExportDefaultDeclaration";
+    declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
+}
+
+export interface ExportAllDeclaration extends BaseModuleDeclaration {
+    type: "ExportAllDeclaration";
+    exported: Identifier | Literal | null;
+    attributes: ImportAttribute[];
+    source: Literal;
+}
+
+export interface AwaitExpression extends BaseExpression {
+    type: "AwaitExpression";
+    argument: Expression;
+}

node_modules/@types/estree/package.json

@@ -0,0 +1,27 @@
+{
+    "name": "@types/estree",
+    "version": "1.0.7",
+    "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": {},
+    "peerDependencies": {},
+    "typesPublisherContentHash": "1ab11f4e78319f80655b4ca20a073da0dc035be5f3290fb0bfa1e08a055d0c7d",
+    "typeScriptVersion": "5.0",
+    "nonNpm": true
+}

node_modules/@types/pako/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/pako/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/pako`
+
+# Summary
+This package contains type definitions for pako (https://github.com/nodeca/pako).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/pako/v1.
+
+### Additional Details
+ * Last updated: Tue, 07 Nov 2023 20:08:00 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [Caleb Eggensperger](https://github.com/calebegg), and [Muhammet Öztürk](https://github.com/hlthi).

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

@@ -0,0 +1,141 @@
+export = Pako;
+export as namespace pako;
+
+declare namespace Pako {
+    enum FlushValues {
+        Z_NO_FLUSH = 0,
+        Z_PARTIAL_FLUSH = 1,
+        Z_SYNC_FLUSH = 2,
+        Z_FULL_FLUSH = 3,
+        Z_FINISH = 4,
+        Z_BLOCK = 5,
+        Z_TREES = 6,
+    }
+
+    enum StrategyValues {
+        Z_FILTERED = 1,
+        Z_HUFFMAN_ONLY = 2,
+        Z_RLE = 3,
+        Z_FIXED = 4,
+        Z_DEFAULT_STRATEGY = 0,
+    }
+
+    enum ReturnCodes {
+        Z_OK = 0,
+        Z_STREAM_END = 1,
+        Z_NEED_DICT = 2,
+        Z_ERRNO = -1,
+        Z_STREAM_ERROR = -2,
+        Z_DATA_ERROR = -3,
+        Z_BUF_ERROR = -5,
+    }
+
+    interface DeflateOptions {
+        level?: -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | undefined;
+        windowBits?: number | undefined;
+        memLevel?: number | undefined;
+        strategy?: StrategyValues | undefined;
+        dictionary?: any;
+        raw?: boolean | undefined;
+        to?: "string" | undefined;
+        chunkSize?: number | undefined;
+        gzip?: boolean | undefined;
+        header?: Header | undefined;
+    }
+
+    interface DeflateFunctionOptions {
+        level?: -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | undefined;
+        windowBits?: number | undefined;
+        memLevel?: number | undefined;
+        strategy?: StrategyValues | undefined;
+        dictionary?: any;
+        raw?: boolean | undefined;
+        to?: "string" | undefined;
+    }
+
+    interface InflateOptions {
+        windowBits?: number | undefined;
+        dictionary?: any;
+        raw?: boolean | undefined;
+        to?: "string" | undefined;
+        chunkSize?: number | undefined;
+    }
+
+    interface InflateFunctionOptions {
+        windowBits?: number | undefined;
+        raw?: boolean | undefined;
+        to?: "string" | undefined;
+    }
+
+    interface Header {
+        text?: boolean | undefined;
+        time?: number | undefined;
+        os?: number | undefined;
+        extra?: number[] | undefined;
+        name?: string | undefined;
+        comment?: string | undefined;
+        hcrc?: boolean | undefined;
+    }
+
+    type Data = Uint8Array | number[] | string;
+
+    /**
+     * Compress data with deflate algorithm and options.
+     */
+    function deflate(data: Data, options: DeflateFunctionOptions & { to: "string" }): string;
+    function deflate(data: Data, options?: DeflateFunctionOptions): Uint8Array;
+
+    /**
+     * The same as deflate, but creates raw data, without wrapper (header and adler32 crc).
+     */
+    function deflateRaw(data: Data, options: DeflateFunctionOptions & { to: "string" }): string;
+    function deflateRaw(data: Data, options?: DeflateFunctionOptions): Uint8Array;
+
+    /**
+     * The same as deflate, but create gzip wrapper instead of deflate one.
+     */
+    function gzip(data: Data, options: DeflateFunctionOptions & { to: "string" }): string;
+    function gzip(data: Data, options?: DeflateFunctionOptions): Uint8Array;
+
+    /**
+     * Decompress data with inflate/ungzip and options. Autodetect format via wrapper header
+     * by default. That's why we don't provide separate ungzip method.
+     */
+    function inflate(data: Data, options: InflateFunctionOptions & { to: "string" }): string;
+    function inflate(data: Data, options?: InflateFunctionOptions): Uint8Array;
+
+    /**
+     * The same as inflate, but creates raw data, without wrapper (header and adler32 crc).
+     */
+    function inflateRaw(data: Data, options: InflateFunctionOptions & { to: "string" }): string;
+    function inflateRaw(data: Data, options?: InflateFunctionOptions): Uint8Array;
+
+    /**
+     * Just shortcut to inflate, because it autodetects format by header.content. Done for convenience.
+     */
+    function ungzip(data: Data, options: InflateFunctionOptions & { to: "string" }): string;
+    function ungzip(data: Data, options?: InflateFunctionOptions): Uint8Array;
+
+    // https://github.com/nodeca/pako/blob/893381abcafa10fa2081ce60dae7d4d8e873a658/lib/deflate.js
+    class Deflate {
+        constructor(options?: DeflateOptions);
+        err: ReturnCodes;
+        msg: string;
+        result: Uint8Array | number[];
+        onData(chunk: Data): void;
+        onEnd(status: number): void;
+        push(data: Data | ArrayBuffer, mode?: FlushValues | boolean): boolean;
+    }
+
+    // https://github.com/nodeca/pako/blob/893381abcafa10fa2081ce60dae7d4d8e873a658/lib/inflate.js
+    class Inflate {
+        constructor(options?: InflateOptions);
+        header?: Header | undefined;
+        err: ReturnCodes;
+        msg: string;
+        result: Data;
+        onData(chunk: Data): void;
+        onEnd(status: number): void;
+        push(data: Data | ArrayBuffer, mode?: FlushValues | boolean): boolean;
+    }
+}

node_modules/@types/pako/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@types/pako",
+    "version": "1.0.7",
+    "description": "TypeScript definitions for pako",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/pako",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Caleb Eggensperger",
+            "githubUsername": "calebegg",
+            "url": "https://github.com/calebegg"
+        },
+        {
+            "name": "Muhammet Öztürk",
+            "githubUsername": "hlthi",
+            "url": "https://github.com/hlthi"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/pako"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "37ebd0aefad5b8f68bbdc569acdb99d999649a17b23913a78498c75aa3ea41aa",
+    "typeScriptVersion": "4.5"
+}

node_modules/@types/pug/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/pug/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/pug`
+
+# Summary
+This package contains type definitions for pug (https://github.com/pugjs/pug).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/pug.
+
+### Additional Details
+ * Last updated: Mon, 20 Nov 2023 23:36:24 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [TonyYang](https://github.com/TonyPythoneer).

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

@@ -0,0 +1,142 @@
+/**
+ * Table of Contents
+ *
+ *  - Options https://pugjs.org/api/reference.html#options
+ *  - Methods https://pugjs.org/api/reference.html#methods
+ *
+ * The order of contents is according to pugjs API document.
+ */
+declare module "pug" {
+    ////////////////////////////////////////////////////////////
+    /// Options https://pugjs.org/api/reference.html#options ///
+    ////////////////////////////////////////////////////////////
+    export interface Options {
+        /** The name of the file being compiled. Used in exceptions, and required for relative includes and extends. Defaults to 'Pug'. */
+        filename?: string | undefined;
+        /** The root directory of all absolute inclusion. */
+        basedir?: string | undefined;
+        /** If the doctype is not specified as part of the template, you can specify it here. It is sometimes useful to get self-closing tags and remove mirroring of boolean attributes; see doctype documentation for more information. */
+        doctype?: string | undefined;
+        /** Adds whitespace to the resulting HTML to make it easier for a human to read using '  ' as indentation. If a string is specified, that will be used as indentation instead (e.g. '\t'). Defaults to false. */
+        pretty?: boolean | string | undefined;
+        /** Hash table of custom filters. Defaults to undefined. */
+        filters?: any;
+        /** Use a self namespace to hold the locals. It will speed up the compilation, but instead of writing variable you will have to write self.variable to access a property of the locals object. Defaults to false. */
+        self?: boolean | undefined;
+        /** If set to true, the tokens and function body are logged to stdout. */
+        debug?: boolean | undefined;
+        /** If set to true, the function source will be included in the compiled template for better error messages (sometimes useful in development). It is enabled by default unless used with Express in production mode. */
+        compileDebug?: boolean | undefined;
+        /** Add a list of global names to make accessible in templates. */
+        globals?: string[] | undefined;
+        /** If set to true, compiled functions are cached. filename must be set as the cache key. Only applies to render functions. Defaults to false. */
+        cache?: boolean | undefined;
+        /** Inline runtime functions instead of require-ing them from a shared version. For compileClient functions, the default is true so that one does not have to include the runtime. For all other compilation or rendering types, the default is false. */
+        inlineRuntimeFunctions?: boolean | undefined;
+        /** The name of the template function. Only applies to compileClient functions. Defaults to 'template'. */
+        name?: string | undefined;
+    }
+
+    ////////////////////////////////////////////////////////////
+    /// Methods https://pugjs.org/api/reference.html#methods ///
+    ////////////////////////////////////////////////////////////
+    /**
+     * Compile a Pug template to a function which can be rendered multiple times with different locals.
+     */
+    export function compile(template: string, options?: Options): compileTemplate;
+
+    /**
+     * Compile a Pug template from a file to a function which can be rendered multiple times with different locals.
+     */
+    export function compileFile(path: string, options?: Options): compileTemplate;
+
+    /**
+     * Compile a Pug template to a string of JavaScript that can be used client side along with the Pug runtime.
+     */
+    export function compileClient(template: string, options?: Options): string;
+
+    /**
+     * Compile a Pug template to an object of the form:
+     * {
+     *   'body': 'function (locals) {...}',
+     *   'dependencies': ['filename.pug']
+     * }
+     * that can be used client side along with the Pug runtime.
+     * You should only use this method if you need dependencies to implement something like watching for changes to the Pug files.
+     */
+    export function compileClientWithDependenciesTracked(template: string, options?: Options): {
+        body: string;
+        dependencies: string[];
+    };
+
+    /**
+     * Compile a Pug template file to a string of JavaScript that can be used client side along with the Pug runtime.
+     */
+    export function compileFileClient(path: string, options?: Options): string;
+
+    /**
+     * Compile a Pug template and render it without locals to html string.
+     */
+    export function render(template: string): string;
+    /**
+     * Compile a Pug template and render it with locals to html string.
+     * @param {(Options & LocalsObject)} options Pug Options and rendering locals
+     */
+    export function render(template: string, options: Options & LocalsObject): string;
+    /**
+     * Compile a Pug template and render it without locals to html string.
+     * @param {((err: Error | null, html: string) => void)} callback Node.js-style callback receiving the rendered results. This callback is called synchronously.
+     */
+    export function render(template: string, callback: (err: Error | null, html: string) => void): void;
+    /**
+     * Compile a Pug template and render it with locals to html string.
+     * @param {(Options & LocalsObject)} options Pug Options and rendering locals
+     * @param {((err: Error | null, html: string) => void)} callback Node.js-style callback receiving the rendered results. This callback is called synchronously.
+     */
+    export function render(
+        template: string,
+        options: Options & LocalsObject,
+        callback: (err: Error | null, html: string) => void,
+    ): void;
+
+    /**
+     * Compile a Pug template from a file and render it without locals to html string.
+     */
+    export function renderFile(path: string): string;
+    /**
+     * Compile a Pug template from a file and render it with locals to html string.
+     * @param {(Options & LocalsObject)} options Pug Options and rendering locals
+     */
+    export function renderFile(path: string, options: Options & LocalsObject): string;
+    /**
+     * Compile a Pug template from a file and render it without locals to html string.
+     * @param {((err: Error | null, html: string) => void)} callback Node.js-style callback receiving the rendered results. This callback is called synchronously.
+     */
+    export function renderFile(path: string, callback: (err: Error | null, html: string) => void): void;
+    /**
+     * Compile a Pug template from a file and render it with locals to html string.
+     * @param {(Options & LocalsObject)} options Pug Options and rendering locals
+     * @param {((err: Error | null, html: string) => void)} callback Node.js-style callback receiving the rendered results. This callback is called synchronously.
+     */
+    export function renderFile(
+        path: string,
+        options: Options & LocalsObject,
+        callback: (err: Error | null, html: string) => void,
+    ): void;
+
+    ///////////////////
+    ///    Types    ///
+    ///////////////////
+
+    /**
+     * A function that can be use to render html string of compiled template.
+     */
+    export type compileTemplate = (locals?: LocalsObject) => string;
+
+    /**
+     * An object that can have multiple properties of any type.
+     */
+    export interface LocalsObject {
+        [propName: string]: any;
+    }
+}

node_modules/@types/pug/package.json

@@ -0,0 +1,25 @@
+{
+    "name": "@types/pug",
+    "version": "2.0.10",
+    "description": "TypeScript definitions for pug",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/pug",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "TonyYang",
+            "githubUsername": "TonyPythoneer",
+            "url": "https://github.com/TonyPythoneer"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/pug"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "344780d8c4f7ed3963980a92cbd743c1a34c553240d2103b33eabb6b7f5a8cb3",
+    "typeScriptVersion": "4.5"
+}

node_modules/@types/trusted-types/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/trusted-types/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/trusted-types`
+
+# Summary
+This package contains type definitions for trusted-types (https://github.com/WICG/trusted-types).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/trusted-types.
+
+### Additional Details
+ * Last updated: Mon, 20 Nov 2023 23:36:24 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [Jakub Vrana](https://github.com/vrana), [Damien Engels](https://github.com/engelsdamien), [Emanuel Tesar](https://github.com/siegrift), [Bjarki](https://github.com/bjarkler), and [Sebastian Silbermann](https://github.com/eps1lon).

node_modules/@types/trusted-types/index.d.ts

@@ -0,0 +1,53 @@
+import * as lib from "./lib";
+
+// Re-export the type definitions globally.
+declare global {
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface -- interface to allow module augmentation
+    interface TrustedHTML extends lib.TrustedHTML {}
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface -- interface to allow module augmentation
+    interface TrustedScript extends lib.TrustedScript {}
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface -- interface to allow module augmentation
+    interface TrustedScriptURL extends lib.TrustedScriptURL {}
+
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface -- interface to allow module augmentation
+    interface TrustedTypePolicy extends lib.TrustedTypePolicy {}
+
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface -- interface to allow module augmentation
+    interface TrustedTypePolicyFactory extends lib.TrustedTypePolicyFactory {}
+
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface -- interface to allow module augmentation
+    interface TrustedTypePolicyOptions extends lib.TrustedTypePolicyOptions {}
+
+    // Attach the relevant Trusted Types properties to the Window object.
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface -- interface to allow module augmentation
+    interface Window extends lib.TrustedTypesWindow {}
+}
+
+// These are the available exports when using the polyfill as npm package (e.g. in nodejs)
+interface InternalTrustedTypePolicyFactory extends lib.TrustedTypePolicyFactory {
+    TrustedHTML: typeof lib.TrustedHTML;
+    TrustedScript: typeof lib.TrustedScript;
+    TrustedScriptURL: typeof lib.TrustedScriptURL;
+}
+
+declare const trustedTypes: InternalTrustedTypePolicyFactory;
+
+declare class TrustedTypesEnforcer {
+    constructor(config: TrustedTypeConfig);
+    install: () => void;
+    uninstall: () => void;
+}
+
+// tslint:disable-next-line no-unnecessary-class
+declare class TrustedTypeConfig {
+    constructor(
+        isLoggingEnabled: boolean,
+        isEnforcementEnabled: boolean,
+        allowedPolicyNames: string[],
+        allowDuplicates: boolean,
+        cspString?: string | null,
+        windowObject?: Window,
+    );
+}
+
+export { TrustedTypeConfig, TrustedTypePolicy, TrustedTypePolicyFactory, trustedTypes, TrustedTypesEnforcer };

node_modules/@types/trusted-types/lib/index.d.ts

@@ -0,0 +1,64 @@
+// The main type definitions. Packages that do not want to pollute the global
+// scope with Trusted Types (e.g. libraries whose users may not be using Trusted
+// Types) can import the types directly from 'trusted-types/lib'.
+
+export type FnNames = keyof TrustedTypePolicyOptions;
+export type Args<Options extends TrustedTypePolicyOptions, K extends FnNames> = Parameters<NonNullable<Options[K]>>;
+
+export class TrustedHTML {
+    private constructor(); // To prevent instantiting with 'new'.
+    private brand: true; // To prevent structural typing.
+}
+
+export class TrustedScript {
+    private constructor(); // To prevent instantiting with 'new'.
+    private brand: true; // To prevent structural typing.
+}
+
+export class TrustedScriptURL {
+    private constructor(); // To prevent instantiting with 'new'.
+    private brand: true; // To prevent structural typing.
+}
+
+export abstract class TrustedTypePolicyFactory {
+    createPolicy<Options extends TrustedTypePolicyOptions>(
+        policyName: string,
+        policyOptions?: Options,
+    ): Pick<TrustedTypePolicy<Options>, "name" | Extract<keyof Options, FnNames>>;
+    isHTML(value: unknown): value is TrustedHTML;
+    isScript(value: unknown): value is TrustedScript;
+    isScriptURL(value: unknown): value is TrustedScriptURL;
+    readonly emptyHTML: TrustedHTML;
+    readonly emptyScript: TrustedScript;
+    getAttributeType(tagName: string, attribute: string, elementNs?: string, attrNs?: string): string | null;
+    getPropertyType(tagName: string, property: string, elementNs?: string): string | null;
+    readonly defaultPolicy: TrustedTypePolicy | null;
+}
+
+export abstract class TrustedTypePolicy<Options extends TrustedTypePolicyOptions = TrustedTypePolicyOptions> {
+    readonly name: string;
+    createHTML(...args: Args<Options, "createHTML">): TrustedHTML;
+    createScript(...args: Args<Options, "createScript">): TrustedScript;
+    createScriptURL(...args: Args<Options, "createScriptURL">): TrustedScriptURL;
+}
+
+export interface TrustedTypePolicyOptions {
+    createHTML?: ((input: string, ...arguments: any[]) => string) | undefined;
+    createScript?: ((input: string, ...arguments: any[]) => string) | undefined;
+    createScriptURL?: ((input: string, ...arguments: any[]) => string) | undefined;
+}
+
+// The Window object is augmented with the following properties in browsers that
+// support Trusted Types. Users of the 'trusted-types/lib' entrypoint can cast
+// window as TrustedTypesWindow to access these properties.
+export interface TrustedTypesWindow {
+    // `trustedTypes` is left intentionally optional to make sure that
+    // people handle the case when their code is running in a browser not
+    // supporting trustedTypes.
+    trustedTypes?: TrustedTypePolicyFactory | undefined;
+    TrustedHTML: typeof TrustedHTML;
+    TrustedScript: typeof TrustedScript;
+    TrustedScriptURL: typeof TrustedScriptURL;
+    TrustedTypePolicyFactory: typeof TrustedTypePolicyFactory;
+    TrustedTypePolicy: typeof TrustedTypePolicy;
+}

node_modules/@types/trusted-types/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "@types/trusted-types",
+    "version": "2.0.7",
+    "description": "TypeScript definitions for trusted-types",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/trusted-types",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Jakub Vrana",
+            "githubUsername": "vrana",
+            "url": "https://github.com/vrana"
+        },
+        {
+            "name": "Damien Engels",
+            "githubUsername": "engelsdamien",
+            "url": "https://github.com/engelsdamien"
+        },
+        {
+            "name": "Emanuel Tesar",
+            "githubUsername": "siegrift",
+            "url": "https://github.com/siegrift"
+        },
+        {
+            "name": "Bjarki",
+            "githubUsername": "bjarkler",
+            "url": "https://github.com/bjarkler"
+        },
+        {
+            "name": "Sebastian Silbermann",
+            "githubUsername": "eps1lon",
+            "url": "https://github.com/eps1lon"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/trusted-types"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "20982c5e0452e662515e29b41f7be5a3c69e5918a9228929a563d9f1dfdfbbc5",
+    "typeScriptVersion": "4.5"
+}