xo 0.52.2 → 0.52.3

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/ts-eslint/SourceCode.d.ts

@@ -0,0 +1,342 @@
+import { ParserServices, TSESTree } from '../ts-estree';
+import { Scope } from './Scope';
+declare class TokenStore {
+    /**
+     * Checks whether any comments exist or not between the given 2 nodes.
+     * @param left The node to check.
+     * @param right The node to check.
+     * @returns `true` if one or more comments exist.
+     */
+    commentsExistBetween(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token): boolean;
+    /**
+     * Gets all comment tokens directly after the given node or token.
+     * @param nodeOrToken The AST node or token to check for adjacent comment tokens.
+     * @returns An array of comments in occurrence order.
+     */
+    getCommentsAfter(nodeOrToken: TSESTree.Node | TSESTree.Token): TSESTree.Comment[];
+    /**
+     * Gets all comment tokens directly before the given node or token.
+     * @param nodeOrToken The AST node or token to check for adjacent comment tokens.
+     * @returns An array of comments in occurrence order.
+     */
+    getCommentsBefore(nodeOrToken: TSESTree.Node | TSESTree.Token): TSESTree.Comment[];
+    /**
+     * Gets all comment tokens inside the given node.
+     * @param node The AST node to get the comments for.
+     * @returns An array of comments in occurrence order.
+     */
+    getCommentsInside(node: TSESTree.Node): TSESTree.Comment[];
+    /**
+     * Gets the first token of the given node.
+     * @param node The AST node.
+     * @param option The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`.
+     * @returns An object representing the token.
+     */
+    getFirstToken<T extends SourceCode.CursorWithSkipOptions>(node: TSESTree.Node, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
+    /**
+     * Gets the first token between two non-overlapping nodes.
+     * @param left Node before the desired token range.
+     * @param right Node after the desired token range.
+     * @param option The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`.
+     * @returns An object representing the token.
+     */
+    getFirstTokenBetween<T extends SourceCode.CursorWithSkipOptions>(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
+    /**
+     * Gets the first `count` tokens of the given node.
+     * @param node The AST node.
+     * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`.
+     * @returns Tokens.
+     */
+    getFirstTokens<T extends SourceCode.CursorWithCountOptions>(node: TSESTree.Node, options?: T): SourceCode.ReturnTypeFromOptions<T>[];
+    /**
+     * Gets the first `count` tokens between two non-overlapping nodes.
+     * @param left Node before the desired token range.
+     * @param right Node after the desired token range.
+     * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`.
+     * @returns Tokens between left and right.
+     */
+    getFirstTokensBetween<T extends SourceCode.CursorWithCountOptions>(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token, options?: T): SourceCode.ReturnTypeFromOptions<T>[];
+    /**
+     * Gets the last token of the given node.
+     * @param node The AST node.
+     * @param option The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`.
+     * @returns An object representing the token.
+     */
+    getLastToken<T extends SourceCode.CursorWithSkipOptions>(node: TSESTree.Node, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
+    /**
+     * Gets the last token between two non-overlapping nodes.
+     * @param left Node before the desired token range.
+     * @param right Node after the desired token range.
+     * @param option The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`.
+     * @returns An object representing the token.
+     */
+    getLastTokenBetween<T extends SourceCode.CursorWithSkipOptions>(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
+    /**
+     * Gets the last `count` tokens of the given node.
+     * @param node The AST node.
+     * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`.
+     * @returns Tokens.
+     */
+    getLastTokens<T extends SourceCode.CursorWithCountOptions>(node: TSESTree.Node, options?: T): SourceCode.ReturnTypeFromOptions<T>[];
+    /**
+     * Gets the last `count` tokens between two non-overlapping nodes.
+     * @param left Node before the desired token range.
+     * @param right Node after the desired token range.
+     * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`.
+     * @returns Tokens between left and right.
+     */
+    getLastTokensBetween<T extends SourceCode.CursorWithCountOptions>(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token, options?: T): SourceCode.ReturnTypeFromOptions<T>[];
+    /**
+     * Gets the token that follows a given node or token.
+     * @param node The AST node or token.
+     * @param option The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`.
+     * @returns An object representing the token.
+     */
+    getTokenAfter<T extends SourceCode.CursorWithSkipOptions>(node: TSESTree.Node | TSESTree.Token, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
+    /**
+     * Gets the token that precedes a given node or token.
+     * @param node The AST node or token.
+     * @param options The option object
+     * @returns An object representing the token.
+     */
+    getTokenBefore<T extends SourceCode.CursorWithSkipOptions>(node: TSESTree.Node | TSESTree.Token, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
+    /**
+     * Gets the token starting at the specified index.
+     * @param offset Index of the start of the token's range.
+     * @param option The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`.
+     * @returns The token starting at index, or null if no such token.
+     */
+    getTokenByRangeStart<T extends {
+        includeComments?: boolean;
+    }>(offset: number, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
+    /**
+     * Gets all tokens that are related to the given node.
+     * @param node The AST node.
+     * @param beforeCount The number of tokens before the node to retrieve.
+     * @param afterCount The number of tokens after the node to retrieve.
+     * @returns Array of objects representing tokens.
+     */
+    getTokens(node: TSESTree.Node, beforeCount?: number, afterCount?: number): TSESTree.Token[];
+    /**
+     * Gets all tokens that are related to the given node.
+     * @param node The AST node.
+     * @param options The option object. If this is a function then it's `options.filter`.
+     * @returns Array of objects representing tokens.
+     */
+    getTokens<T extends SourceCode.CursorWithCountOptions>(node: TSESTree.Node, options: T): SourceCode.ReturnTypeFromOptions<T>[];
+    /**
+     * Gets the `count` tokens that follows a given node or token.
+     * @param node The AST node.
+     * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`.
+     * @returns Tokens.
+     */
+    getTokensAfter<T extends SourceCode.CursorWithCountOptions>(node: TSESTree.Node | TSESTree.Token, options?: T): SourceCode.ReturnTypeFromOptions<T>[];
+    /**
+     * Gets the `count` tokens that precedes a given node or token.
+     * @param node The AST node.
+     * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`.
+     * @returns Tokens.
+     */
+    getTokensBefore<T extends SourceCode.CursorWithCountOptions>(node: TSESTree.Node | TSESTree.Token, options?: T): SourceCode.ReturnTypeFromOptions<T>[];
+    /**
+     * Gets all of the tokens between two non-overlapping nodes.
+     * @param left Node before the desired token range.
+     * @param right Node after the desired token range.
+     * @param options The option object. If this is a function then it's `options.filter`.
+     * @returns Tokens between left and right.
+     */
+    getTokensBetween<T extends SourceCode.CursorWithCountOptions>(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token, padding?: T): SourceCode.ReturnTypeFromOptions<T>[];
+    /**
+     * Gets all of the tokens between two non-overlapping nodes.
+     * @param left Node before the desired token range.
+     * @param right Node after the desired token range.
+     * @param padding Number of extra tokens on either side of center.
+     * @returns Tokens between left and right.
+     */
+    getTokensBetween<T extends SourceCode.CursorWithCountOptions>(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token, padding?: number): SourceCode.ReturnTypeFromOptions<T>[];
+}
+declare class SourceCodeBase extends TokenStore {
+    /**
+     * Represents parsed source code.
+     * @param text The source code text.
+     * @param ast The Program node of the AST representing the code. This AST should be created from the text that BOM was stripped.
+     */
+    constructor(text: string, ast: SourceCode.Program);
+    /**
+     * Represents parsed source code.
+     * @param config The config object.
+     */
+    constructor(config: SourceCode.SourceCodeConfig);
+    /**
+     * The parsed AST for the source code.
+     */
+    ast: SourceCode.Program;
+    /**
+     * Retrieves an array containing all comments in the source code.
+     * @returns An array of comment nodes.
+     */
+    getAllComments(): TSESTree.Comment[];
+    /**
+     * Converts a (line, column) pair into a range index.
+     * @param loc A line/column location
+     * @returns The range index of the location in the file.
+     */
+    getIndexFromLoc(location: TSESTree.Position): number;
+    /**
+     * Gets the entire source text split into an array of lines.
+     * @returns The source text as an array of lines.
+     */
+    getLines(): string[];
+    /**
+     * Converts a source text index into a (line, column) pair.
+     * @param index The index of a character in a file
+     * @returns A {line, column} location object with a 0-indexed column
+     */
+    getLocFromIndex(index: number): TSESTree.Position;
+    /**
+     * Gets the deepest node containing a range index.
+     * @param index Range index of the desired node.
+     * @returns The node if found or `null` if not found.
+     */
+    getNodeByRangeIndex(index: number): TSESTree.Node | null;
+    /**
+     * Gets the source code for the given node.
+     * @param node The AST node to get the text for.
+     * @param beforeCount The number of characters before the node to retrieve.
+     * @param afterCount The number of characters after the node to retrieve.
+     * @returns The text representing the AST node.
+     */
+    getText(node?: TSESTree.Node | TSESTree.Token, beforeCount?: number, afterCount?: number): string;
+    /**
+     * The flag to indicate that the source code has Unicode BOM.
+     */
+    hasBOM: boolean;
+    /**
+     * Determines if two nodes or tokens have at least one whitespace character
+     * between them. Order does not matter. Returns false if the given nodes or
+     * tokens overlap.
+     * @since 6.7.0
+     * @param first The first node or token to check between.
+     * @param second The second node or token to check between.
+     * @returns True if there is a whitespace character between any of the tokens found between the two given nodes or tokens.
+     */
+    isSpaceBetween?(first: TSESTree.Token | TSESTree.Node, second: TSESTree.Token | TSESTree.Node): boolean;
+    /**
+     * Determines if two nodes or tokens have at least one whitespace character
+     * between them. Order does not matter. Returns false if the given nodes or
+     * tokens overlap.
+     * For backward compatibility, this method returns true if there are
+     * `JSXText` tokens that contain whitespace between the two.
+     * @param first The first node or token to check between.
+     * @param second The second node or token to check between.
+     * @returns {boolean} True if there is a whitespace character between
+     * any of the tokens found between the two given nodes or tokens.
+     * @deprecated in favor of isSpaceBetween
+     */
+    isSpaceBetweenTokens(first: TSESTree.Token, second: TSESTree.Token): boolean;
+    /**
+     * The source code split into lines according to ECMA-262 specification.
+     * This is done to avoid each rule needing to do so separately.
+     */
+    lines: string[];
+    /**
+     * The indexes in `text` that each line starts
+     */
+    lineStartIndices: number[];
+    /**
+     * The parser services of this source code.
+     */
+    parserServices: ParserServices;
+    /**
+     * The scope of this source code.
+     */
+    scopeManager: Scope.ScopeManager | null;
+    /**
+     * The original text source code. BOM was stripped from this text.
+     */
+    text: string;
+    /**
+     * All of the tokens and comments in the AST.
+     *
+     * TODO: rename to 'tokens'
+     */
+    tokensAndComments: TSESTree.Token[];
+    /**
+     * The visitor keys to traverse AST.
+     */
+    visitorKeys: SourceCode.VisitorKeys;
+    /**
+     * Split the source code into multiple lines based on the line delimiters.
+     * @param text Source code as a string.
+     * @returns Array of source code lines.
+     */
+    static splitLines(text: string): string[];
+}
+declare namespace SourceCode {
+    interface Program extends TSESTree.Program {
+        comments: TSESTree.Comment[];
+        tokens: TSESTree.Token[];
+    }
+    interface SourceCodeConfig {
+        /**
+         * The Program node of the AST representing the code. This AST should be created from the text that BOM was stripped.
+         */
+        ast: Program;
+        /**
+         * The parser services.
+         */
+        parserServices: ParserServices | null;
+        /**
+         * The scope of this source code.
+         */
+        scopeManager: Scope.ScopeManager | null;
+        /**
+         * The source code text.
+         */
+        text: string;
+        /**
+         * The visitor keys to traverse AST.
+         */
+        visitorKeys: VisitorKeys | null;
+    }
+    interface VisitorKeys {
+        [nodeType: string]: string[];
+    }
+    type FilterPredicate = (token: TSESTree.Token) => boolean;
+    type ReturnTypeFromOptions<T> = T extends {
+        includeComments: true;
+    } ? TSESTree.Token : Exclude<TSESTree.Token, TSESTree.Comment>;
+    type CursorWithSkipOptions = number | FilterPredicate | {
+        /**
+         * The predicate function to choose tokens.
+         */
+        filter?: FilterPredicate;
+        /**
+         * The flag to iterate comments as well.
+         */
+        includeComments?: boolean;
+        /**
+         * The count of tokens the cursor skips.
+         */
+        skip?: number;
+    };
+    type CursorWithCountOptions = number | FilterPredicate | {
+        /**
+         * The predicate function to choose tokens.
+         */
+        filter?: FilterPredicate;
+        /**
+         * The flag to iterate comments as well.
+         */
+        includeComments?: boolean;
+        /**
+         * The maximum count of tokens the cursor iterates.
+         */
+        count?: number;
+    };
+}
+declare const SourceCode_base: typeof SourceCodeBase;
+declare class SourceCode extends SourceCode_base {
+}
+export { SourceCode };
+//# sourceMappingURL=SourceCode.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/ts-eslint/index.d.ts

@@ -0,0 +1,10 @@
+export * from './AST';
+export * from './CLIEngine';
+export * from './ESLint';
+export * from './Linter';
+export * from './ParserOptions';
+export * from './Rule';
+export * from './RuleTester';
+export * from './Scope';
+export * from './SourceCode';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/ts-eslint-scope/Definition.d.ts

@@ -0,0 +1,19 @@
+import { TSESTree } from '../ts-estree';
+interface Definition {
+    type: string;
+    name: TSESTree.BindingName;
+    node: TSESTree.Node;
+    parent?: TSESTree.Node | null;
+    index?: number | null;
+    kind?: string | null;
+    rest?: boolean;
+}
+interface DefinitionConstructor {
+    new (type: string, name: TSESTree.BindingName | TSESTree.PropertyName, node: TSESTree.Node, parent?: TSESTree.Node | null, index?: number | null, kind?: string | null): Definition;
+}
+declare const Definition: DefinitionConstructor;
+interface ParameterDefinition extends Definition {
+}
+declare const ParameterDefinition: DefinitionConstructor & (new (name: TSESTree.Node, node: TSESTree.Node, index?: number | null, rest?: boolean) => ParameterDefinition);
+export { Definition, ParameterDefinition };
+//# sourceMappingURL=Definition.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/ts-eslint-scope/Options.d.ts

@@ -0,0 +1,15 @@
+import { TSESTree } from '../ts-estree';
+declare type PatternVisitorCallback = (pattern: TSESTree.Identifier, info: {
+    rest: boolean;
+    topLevel: boolean;
+    assignments: TSESTree.AssignmentPattern[];
+}) => void;
+interface PatternVisitorOptions {
+    processRightHandNodes?: boolean;
+}
+interface Visitor {
+    visitChildren<T extends TSESTree.BaseNode | undefined | null>(node?: T): void;
+    visit<T extends TSESTree.BaseNode | undefined | null>(node?: T): void;
+}
+export { PatternVisitorCallback, PatternVisitorOptions, Visitor };
+//# sourceMappingURL=Options.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/ts-eslint-scope/PatternVisitor.d.ts

@@ -0,0 +1,25 @@
+import { TSESTree } from '../ts-estree';
+import { ScopeManager } from './ScopeManager';
+import { PatternVisitorCallback, PatternVisitorOptions, Visitor } from './Options';
+interface PatternVisitor extends Visitor {
+    options: PatternVisitorOptions;
+    scopeManager: ScopeManager;
+    parent?: TSESTree.Node;
+    rightHandNodes: TSESTree.Node[];
+    Identifier(pattern: TSESTree.Node): void;
+    Property(property: TSESTree.Node): void;
+    ArrayPattern(pattern: TSESTree.Node): void;
+    AssignmentPattern(pattern: TSESTree.Node): void;
+    RestElement(pattern: TSESTree.Node): void;
+    MemberExpression(node: TSESTree.Node): void;
+    SpreadElement(node: TSESTree.Node): void;
+    ArrayExpression(node: TSESTree.Node): void;
+    AssignmentExpression(node: TSESTree.Node): void;
+    CallExpression(node: TSESTree.Node): void;
+}
+declare const PatternVisitor: {
+    new (options: PatternVisitorOptions, rootPattern: TSESTree.BaseNode, callback: PatternVisitorCallback): PatternVisitor;
+    isPattern(node: TSESTree.Node): boolean;
+};
+export { PatternVisitor };
+//# sourceMappingURL=PatternVisitor.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/ts-eslint-scope/Reference.d.ts

@@ -0,0 +1,28 @@
+import { TSESTree } from '../ts-estree';
+import { Scope } from './Scope';
+import { Variable } from './Variable';
+export declare type ReferenceFlag = 0x1 | 0x2 | 0x3;
+interface Reference {
+    identifier: TSESTree.Identifier;
+    from: Scope;
+    resolved: Variable | null;
+    writeExpr: TSESTree.Node | null;
+    init: boolean;
+    partial: boolean;
+    __maybeImplicitGlobal: boolean;
+    tainted?: boolean;
+    typeMode?: boolean;
+    isWrite(): boolean;
+    isRead(): boolean;
+    isWriteOnly(): boolean;
+    isReadOnly(): boolean;
+    isReadWrite(): boolean;
+}
+declare const Reference: {
+    new (identifier: TSESTree.Identifier, scope: Scope, flag?: ReferenceFlag, writeExpr?: TSESTree.Node | null, maybeImplicitGlobal?: boolean, partial?: boolean, init?: boolean): Reference;
+    READ: 0x1;
+    WRITE: 0x2;
+    RW: 0x3;
+};
+export { Reference };
+//# sourceMappingURL=Reference.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/ts-eslint-scope/Referencer.d.ts

@@ -0,0 +1,55 @@
+import { TSESTree } from '../ts-estree';
+import { PatternVisitorCallback, PatternVisitorOptions, Visitor } from './Options';
+import { Scope } from './Scope';
+import { ScopeManager } from './ScopeManager';
+interface Referencer<SM extends ScopeManager> extends Visitor {
+    isInnerMethodDefinition: boolean;
+    options: any;
+    scopeManager: SM;
+    parent?: TSESTree.Node;
+    currentScope(): Scope;
+    close(node: TSESTree.Node): void;
+    pushInnerMethodDefinition(isInnerMethodDefinition: boolean): boolean;
+    popInnerMethodDefinition(isInnerMethodDefinition: boolean): void;
+    referencingDefaultValue(pattern: any, assignments: any, maybeImplicitGlobal: any, init: boolean): void;
+    visitPattern(node: TSESTree.Node, options: PatternVisitorOptions, callback: PatternVisitorCallback): void;
+    visitFunction(node: TSESTree.Node): void;
+    visitClass(node: TSESTree.Node): void;
+    visitProperty(node: TSESTree.Node): void;
+    visitForIn(node: TSESTree.Node): void;
+    visitVariableDeclaration(variableTargetScope: any, type: any, node: TSESTree.Node, index: any): void;
+    AssignmentExpression(node: TSESTree.Node): void;
+    CatchClause(node: TSESTree.Node): void;
+    Program(node: TSESTree.Program): void;
+    Identifier(node: TSESTree.Identifier): void;
+    UpdateExpression(node: TSESTree.Node): void;
+    MemberExpression(node: TSESTree.Node): void;
+    Property(node: TSESTree.Node): void;
+    MethodDefinition(node: TSESTree.Node): void;
+    BreakStatement(): void;
+    ContinueStatement(): void;
+    LabeledStatement(node: TSESTree.Node): void;
+    ForStatement(node: TSESTree.Node): void;
+    ClassExpression(node: TSESTree.Node): void;
+    ClassDeclaration(node: TSESTree.Node): void;
+    CallExpression(node: TSESTree.Node): void;
+    BlockStatement(node: TSESTree.Node): void;
+    ThisExpression(): void;
+    WithStatement(node: TSESTree.Node): void;
+    VariableDeclaration(node: TSESTree.Node): void;
+    SwitchStatement(node: TSESTree.Node): void;
+    FunctionDeclaration(node: TSESTree.Node): void;
+    FunctionExpression(node: TSESTree.Node): void;
+    ForOfStatement(node: TSESTree.Node): void;
+    ForInStatement(node: TSESTree.Node): void;
+    ArrowFunctionExpression(node: TSESTree.Node): void;
+    ImportDeclaration(node: TSESTree.Node): void;
+    visitExportDeclaration(node: TSESTree.Node): void;
+    ExportDeclaration(node: TSESTree.Node): void;
+    ExportNamedDeclaration(node: TSESTree.Node): void;
+    ExportSpecifier(node: TSESTree.Node): void;
+    MetaProperty(): void;
+}
+declare const Referencer: new <SM extends ScopeManager>(options: any, scopeManager: SM) => Referencer<SM>;
+export { Referencer };
+//# sourceMappingURL=Referencer.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/ts-eslint-scope/Scope.d.ts

@@ -0,0 +1,103 @@
+import { TSESTree } from '../ts-estree';
+import { Definition } from './Definition';
+import { Reference, ReferenceFlag } from './Reference';
+import { ScopeManager } from './ScopeManager';
+import { Variable } from './Variable';
+declare type ScopeType = 'block' | 'catch' | 'class' | 'for' | 'function' | 'function-expression-name' | 'global' | 'module' | 'switch' | 'with' | 'TDZ' | 'enum' | 'empty-function';
+interface Scope {
+    type: ScopeType;
+    isStrict: boolean;
+    upper: Scope | null;
+    childScopes: Scope[];
+    variableScope: Scope;
+    block: TSESTree.Node;
+    variables: Variable[];
+    set: Map<string, Variable>;
+    references: Reference[];
+    through: Reference[];
+    thisFound?: boolean;
+    taints: Map<string, boolean>;
+    functionExpressionScope: boolean;
+    __left: Reference[];
+    __shouldStaticallyClose(scopeManager: ScopeManager): boolean;
+    __shouldStaticallyCloseForGlobal(ref: any): boolean;
+    __staticCloseRef(ref: any): void;
+    __dynamicCloseRef(ref: any): void;
+    __globalCloseRef(ref: any): void;
+    __close(scopeManager: ScopeManager): Scope;
+    __isValidResolution(ref: any, variable: any): variable is Variable;
+    __resolve(ref: Reference): boolean;
+    __delegateToUpperScope(ref: any): void;
+    __addDeclaredVariablesOfNode(variable: any, node: TSESTree.Node): void;
+    __defineGeneric(name: string, set: Map<string, Variable>, variables: Variable[], node: TSESTree.Identifier, def: Definition): void;
+    __define(node: TSESTree.Node, def: Definition): void;
+    __referencing(node: TSESTree.Node, assign?: ReferenceFlag, writeExpr?: TSESTree.Node, maybeImplicitGlobal?: any, partial?: any, init?: any): void;
+    __detectEval(): void;
+    __detectThis(): void;
+    __isClosed(): boolean;
+    /**
+     * returns resolved {Reference}
+     * @method Scope#resolve
+     * @param {Espree.Identifier} ident - identifier to be resolved.
+     * @returns {Reference} reference
+     */
+    resolve(ident: TSESTree.Node): Reference;
+    /**
+     * returns this scope is static
+     * @method Scope#isStatic
+     * @returns {boolean} static
+     */
+    isStatic(): boolean;
+    /**
+     * returns this scope has materialized arguments
+     * @method Scope#isArgumentsMaterialized
+     * @returns {boolean} arguments materialized
+     */
+    isArgumentsMaterialized(): boolean;
+    /**
+     * returns this scope has materialized `this` reference
+     * @method Scope#isThisMaterialized
+     * @returns {boolean} this materialized
+     */
+    isThisMaterialized(): boolean;
+    isUsedName(name: any): boolean;
+}
+interface ScopeConstructor {
+    new (scopeManager: ScopeManager, type: ScopeType, upperScope: Scope | null, block: TSESTree.Node | null, isMethodDefinition: boolean): Scope;
+}
+declare const Scope: ScopeConstructor;
+interface ScopeChildConstructorWithUpperScope<T> {
+    new (scopeManager: ScopeManager, upperScope: Scope, block: TSESTree.Node | null): T;
+}
+interface GlobalScope extends Scope {
+}
+declare const GlobalScope: ScopeConstructor & (new (scopeManager: ScopeManager, block: TSESTree.Node | null) => GlobalScope);
+interface ModuleScope extends Scope {
+}
+declare const ModuleScope: ScopeConstructor & ScopeChildConstructorWithUpperScope<ModuleScope>;
+interface FunctionExpressionNameScope extends Scope {
+}
+declare const FunctionExpressionNameScope: ScopeConstructor & ScopeChildConstructorWithUpperScope<FunctionExpressionNameScope>;
+interface CatchScope extends Scope {
+}
+declare const CatchScope: ScopeConstructor & ScopeChildConstructorWithUpperScope<CatchScope>;
+interface WithScope extends Scope {
+}
+declare const WithScope: ScopeConstructor & ScopeChildConstructorWithUpperScope<WithScope>;
+interface BlockScope extends Scope {
+}
+declare const BlockScope: ScopeConstructor & ScopeChildConstructorWithUpperScope<BlockScope>;
+interface SwitchScope extends Scope {
+}
+declare const SwitchScope: ScopeConstructor & ScopeChildConstructorWithUpperScope<SwitchScope>;
+interface FunctionScope extends Scope {
+}
+declare const FunctionScope: ScopeConstructor & (new (scopeManager: ScopeManager, upperScope: Scope, block: TSESTree.Node | null, isMethodDefinition: boolean) => FunctionScope);
+interface ForScope extends Scope {
+}
+declare const ForScope: ScopeConstructor & ScopeChildConstructorWithUpperScope<ForScope>;
+interface ClassScope extends Scope {
+}
+declare const ClassScope: ScopeConstructor & ScopeChildConstructorWithUpperScope<ClassScope>;
+export { ScopeType, Scope, GlobalScope, ModuleScope, FunctionExpressionNameScope, CatchScope, WithScope, BlockScope, SwitchScope, FunctionScope, ForScope, ClassScope, };
+//# sourceMappingURL=Scope.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/ts-eslint-scope/ScopeManager.d.ts

@@ -0,0 +1,50 @@
+import { TSESTree } from '../ts-estree';
+import { EcmaVersion } from '../ts-eslint';
+import { Scope } from './Scope';
+import { Variable } from './Variable';
+interface ScopeManagerOptions {
+    directive?: boolean;
+    optimistic?: boolean;
+    ignoreEval?: boolean;
+    nodejsScope?: boolean;
+    sourceType?: 'module' | 'script';
+    impliedStrict?: boolean;
+    ecmaVersion?: EcmaVersion;
+}
+interface ScopeManager {
+    __options: ScopeManagerOptions;
+    __currentScope: Scope;
+    __nodeToScope: WeakMap<TSESTree.Node, Scope[]>;
+    __declaredVariables: WeakMap<TSESTree.Node, Variable[]>;
+    scopes: Scope[];
+    globalScope: Scope;
+    __useDirective(): boolean;
+    __isOptimistic(): boolean;
+    __ignoreEval(): boolean;
+    __isNodejsScope(): boolean;
+    isModule(): boolean;
+    isImpliedStrict(): boolean;
+    isStrictModeSupported(): boolean;
+    __get(node: TSESTree.Node): Scope | undefined;
+    getDeclaredVariables(node: TSESTree.Node): Variable[];
+    acquire(node: TSESTree.Node, inner?: boolean): Scope | null;
+    acquireAll(node: TSESTree.Node): Scope | null;
+    release(node: TSESTree.Node, inner?: boolean): Scope | null;
+    attach(): void;
+    detach(): void;
+    __nestScope<T extends Scope>(scope: T): T;
+    __nestGlobalScope(node: TSESTree.Node): Scope;
+    __nestBlockScope(node: TSESTree.Node): Scope;
+    __nestFunctionScope(node: TSESTree.Node, isMethodDefinition: boolean): Scope;
+    __nestForScope(node: TSESTree.Node): Scope;
+    __nestCatchScope(node: TSESTree.Node): Scope;
+    __nestWithScope(node: TSESTree.Node): Scope;
+    __nestClassScope(node: TSESTree.Node): Scope;
+    __nestSwitchScope(node: TSESTree.Node): Scope;
+    __nestModuleScope(node: TSESTree.Node): Scope;
+    __nestFunctionExpressionNameScope(node: TSESTree.Node): Scope;
+    __isES6(): boolean;
+}
+declare const ScopeManager: new (options: ScopeManagerOptions) => ScopeManager;
+export { ScopeManager, ScopeManagerOptions };
+//# sourceMappingURL=ScopeManager.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/ts-eslint-scope/Variable.d.ts

@@ -0,0 +1,17 @@
+import { TSESTree } from '../ts-estree';
+import { Reference } from './Reference';
+import { Definition } from './Definition';
+import { Scope } from './Scope';
+interface Variable {
+    name: string;
+    identifiers: TSESTree.Identifier[];
+    references: Reference[];
+    defs: Definition[];
+    eslintUsed?: boolean;
+    stack?: unknown;
+    tainted?: boolean;
+    scope?: Scope;
+}
+declare const Variable: new () => Variable;
+export { Variable };
+//# sourceMappingURL=Variable.d.ts.map