xo 0.51.0 → 0.52.0

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

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

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

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

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

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

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

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

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

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

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