@sprucelabs/spruce-cli 17.1.44 → 17.1.46

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

@@ -0,0 +1,231 @@
+import * as ts from 'typescript';
+import { TSESTree } from './ts-estree';
+import { AST_NODE_TYPES, AST_TOKEN_TYPES } from './ts-estree';
+declare const SyntaxKind: typeof ts.SyntaxKind;
+interface TokenToText extends TSESTree.PunctuatorTokenToText {
+    [SyntaxKind.ImportKeyword]: 'import';
+    [SyntaxKind.InKeyword]: 'in';
+    [SyntaxKind.InstanceOfKeyword]: 'instanceof';
+    [SyntaxKind.NewKeyword]: 'new';
+    [SyntaxKind.KeyOfKeyword]: 'keyof';
+    [SyntaxKind.ReadonlyKeyword]: 'readonly';
+    [SyntaxKind.UniqueKeyword]: 'unique';
+}
+/**
+ * Returns true if the given ts.Token is the assignment operator
+ * @param operator the operator token
+ * @returns is assignment
+ */
+export declare function isAssignmentOperator<T extends ts.SyntaxKind>(operator: ts.Token<T>): boolean;
+/**
+ * Returns true if the given ts.Token is a logical operator
+ * @param operator the operator token
+ * @returns is a logical operator
+ */
+export declare function isLogicalOperator<T extends ts.SyntaxKind>(operator: ts.Token<T>): boolean;
+/**
+ * Returns the string form of the given TSToken SyntaxKind
+ * @param kind the token's SyntaxKind
+ * @returns the token applicable token as a string
+ */
+export declare function getTextForTokenKind<T extends ts.SyntaxKind>(kind: T): T extends keyof TokenToText ? TokenToText[T] : string | undefined;
+/**
+ * Returns true if the given ts.Node is a valid ESTree class member
+ * @param node TypeScript AST node
+ * @returns is valid ESTree class member
+ */
+export declare function isESTreeClassMember(node: ts.Node): boolean;
+/**
+ * Checks if a ts.Node has a modifier
+ * @param modifierKind TypeScript SyntaxKind modifier
+ * @param node TypeScript AST node
+ * @returns has the modifier specified
+ */
+export declare function hasModifier(modifierKind: ts.KeywordSyntaxKind, node: ts.Node): boolean;
+/**
+ * Get last last modifier in ast
+ * @param node TypeScript AST node
+ * @returns returns last modifier if present or null
+ */
+export declare function getLastModifier(node: ts.Node): ts.Modifier | null;
+/**
+ * Returns true if the given ts.Token is a comma
+ * @param token the TypeScript token
+ * @returns is comma
+ */
+export declare function isComma(token: ts.Node): token is ts.Token<ts.SyntaxKind.CommaToken>;
+/**
+ * Returns true if the given ts.Node is a comment
+ * @param node the TypeScript node
+ * @returns is comment
+ */
+export declare function isComment(node: ts.Node): boolean;
+/**
+ * Returns true if the given ts.Node is a JSDoc comment
+ * @param node the TypeScript node
+ * @returns is JSDoc comment
+ */
+export declare function isJSDocComment(node: ts.Node): node is ts.JSDoc;
+/**
+ * Returns the binary expression type of the given ts.Token
+ * @param operator the operator token
+ * @returns the binary expression type
+ */
+export declare function getBinaryExpressionType<T extends ts.SyntaxKind>(operator: ts.Token<T>): AST_NODE_TYPES.AssignmentExpression | AST_NODE_TYPES.LogicalExpression | AST_NODE_TYPES.BinaryExpression;
+/**
+ * Returns line and column data for the given positions,
+ * @param pos position to check
+ * @param ast the AST object
+ * @returns line and column
+ */
+export declare function getLineAndCharacterFor(pos: number, ast: ts.SourceFile): TSESTree.Position;
+/**
+ * Returns line and column data for the given start and end positions,
+ * for the given AST
+ * @param start start data
+ * @param end   end data
+ * @param ast   the AST object
+ * @returns the loc data
+ */
+export declare function getLocFor(start: number, end: number, ast: ts.SourceFile): TSESTree.SourceLocation;
+/**
+ * Check whatever node can contain directive
+ * @param node
+ * @returns returns true if node can contain directive
+ */
+export declare function canContainDirective(node: ts.SourceFile | ts.Block | ts.ModuleBlock | ts.ClassStaticBlockDeclaration): boolean;
+/**
+ * Returns range for the given ts.Node
+ * @param node the ts.Node or ts.Token
+ * @param ast the AST object
+ * @returns the range data
+ */
+export declare function getRange(node: ts.Node, ast: ts.SourceFile): [
+    number,
+    number
+];
+/**
+ * Returns true if a given ts.Node is a token
+ * @param node the ts.Node
+ * @returns is a token
+ */
+export declare function isToken(node: ts.Node): node is ts.Token<ts.TokenSyntaxKind>;
+/**
+ * Returns true if a given ts.Node is a JSX token
+ * @param node ts.Node to be checked
+ * @returns is a JSX token
+ */
+export declare function isJSXToken(node: ts.Node): boolean;
+/**
+ * Returns the declaration kind of the given ts.Node
+ * @param node TypeScript AST node
+ * @returns declaration kind
+ */
+export declare function getDeclarationKind(node: ts.VariableDeclarationList): 'let' | 'const' | 'var';
+/**
+ * Gets a ts.Node's accessibility level
+ * @param node The ts.Node
+ * @returns accessibility "public", "protected", "private", or null
+ */
+export declare function getTSNodeAccessibility(node: ts.Node): 'public' | 'protected' | 'private' | null;
+/**
+ * Finds the next token based on the previous one and its parent
+ * Had to copy this from TS instead of using TS's version because theirs doesn't pass the ast to getChildren
+ * @param previousToken The previous TSToken
+ * @param parent The parent TSNode
+ * @param ast The TS AST
+ * @returns the next TSToken
+ */
+export declare function findNextToken(previousToken: ts.TextRange, parent: ts.Node, ast: ts.SourceFile): ts.Node | undefined;
+/**
+ * Find the first matching ancestor based on the given predicate function.
+ * @param node The current ts.Node
+ * @param predicate The predicate function to apply to each checked ancestor
+ * @returns a matching parent ts.Node
+ */
+export declare function findFirstMatchingAncestor(node: ts.Node, predicate: (node: ts.Node) => boolean): ts.Node | undefined;
+/**
+ * Returns true if a given ts.Node has a JSX token within its hierarchy
+ * @param node ts.Node to be checked
+ * @returns has JSX ancestor
+ */
+export declare function hasJSXAncestor(node: ts.Node): boolean;
+/**
+ * Unescape the text content of string literals, e.g. &amp; -> &
+ * @param text The escaped string literal text.
+ * @returns The unescaped string literal text.
+ */
+export declare function unescapeStringLiteralText(text: string): string;
+/**
+ * Returns true if a given ts.Node is a computed property
+ * @param node ts.Node to be checked
+ * @returns is Computed Property
+ */
+export declare function isComputedProperty(node: ts.Node): node is ts.ComputedPropertyName;
+/**
+ * Returns true if a given ts.Node is optional (has QuestionToken)
+ * @param node ts.Node to be checked
+ * @returns is Optional
+ */
+export declare function isOptional(node: {
+    questionToken?: ts.QuestionToken;
+}): boolean;
+/**
+ * Returns true if the node is an optional chain node
+ */
+export declare function isChainExpression(node: TSESTree.Node): node is TSESTree.ChainExpression;
+/**
+ * Returns true of the child of property access expression is an optional chain
+ */
+export declare function isChildUnwrappableOptionalChain(node: ts.PropertyAccessExpression | ts.ElementAccessExpression | ts.CallExpression | ts.NonNullExpression, child: TSESTree.Node): boolean;
+/**
+ * Returns the type of a given ts.Token
+ * @param token the ts.Token
+ * @returns the token type
+ */
+export declare function getTokenType(token: ts.Identifier | ts.Token<ts.SyntaxKind>): Exclude<AST_TOKEN_TYPES, AST_TOKEN_TYPES.Line | AST_TOKEN_TYPES.Block>;
+/**
+ * Extends and formats a given ts.Token, for a given AST
+ * @param token the ts.Token
+ * @param ast   the AST object
+ * @returns the converted Token
+ */
+export declare function convertToken(token: ts.Token<ts.TokenSyntaxKind>, ast: ts.SourceFile): TSESTree.Token;
+/**
+ * Converts all tokens for the given AST
+ * @param ast the AST object
+ * @returns the converted Tokens
+ */
+export declare function convertTokens(ast: ts.SourceFile): TSESTree.Token[];
+export declare class TSError extends Error {
+    readonly fileName: string;
+    readonly index: number;
+    readonly lineNumber: number;
+    readonly column: number;
+    constructor(message: string, fileName: string, index: number, lineNumber: number, column: number);
+}
+/**
+ * @param ast     the AST object
+ * @param start   the index at which the error starts
+ * @param message the error message
+ * @returns converted error object
+ */
+export declare function createError(ast: ts.SourceFile, start: number, message: string): TSError;
+/**
+ * @param n the TSNode
+ * @param ast the TS AST
+ */
+export declare function nodeHasTokens(n: ts.Node, ast: ts.SourceFile): boolean;
+/**
+ * Like `forEach`, but suitable for use with numbers and strings (which may be falsy).
+ * @template T
+ * @template U
+ * @param array
+ * @param callback
+ */
+export declare function firstDefined<T, U>(array: readonly T[] | undefined, callback: (element: T, index: number) => U | undefined): U | undefined;
+export declare function identifierIsThisKeyword(id: ts.Identifier): boolean;
+export declare function isThisIdentifier(node: ts.Node | undefined): node is ts.Identifier;
+export declare function isThisInTypeQuery(node: ts.Node): boolean;
+export {};
+//# sourceMappingURL=node-utils.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/parser-options.d.ts

@@ -0,0 +1,188 @@
+import { DebugLevel } from '@typescript-eslint/types';
+import * as ts from 'typescript';
+import { CanonicalPath } from './create-program/shared';
+import { TSESTree, TSESTreeToTSNode, TSNode, TSToken } from './ts-estree';
+declare type DebugModule = 'typescript-eslint' | 'eslint' | 'typescript';
+export interface Extra {
+    code: string;
+    comment: boolean;
+    comments: TSESTree.Comment[];
+    createDefaultProgram: boolean;
+    debugLevel: Set<DebugModule>;
+    errorOnTypeScriptSyntacticAndSemanticIssues: boolean;
+    errorOnUnknownASTType: boolean;
+    EXPERIMENTAL_useSourceOfProjectReferenceRedirect: boolean;
+    extraFileExtensions: string[];
+    filePath: string;
+    jsx: boolean;
+    loc: boolean;
+    singleRun: boolean;
+    log: (message: string) => void;
+    preserveNodeMaps?: boolean;
+    programs: null | Iterable<ts.Program>;
+    projects: CanonicalPath[];
+    range: boolean;
+    strict: boolean;
+    tokens: null | TSESTree.Token[];
+    tsconfigRootDir: string;
+    moduleResolver: string;
+}
+interface ParseOptions {
+    /**
+     * create a top-level comments array containing all comments
+     */
+    comment?: boolean;
+    /**
+     * An array of modules to turn explicit debugging on for.
+     * - 'typescript-eslint' is the same as setting the env var `DEBUG=typescript-eslint:*`
+     * - 'eslint' is the same as setting the env var `DEBUG=eslint:*`
+     * - 'typescript' is the same as setting `extendedDiagnostics: true` in your tsconfig compilerOptions
+     *
+     * For convenience, also supports a boolean:
+     * - true === ['typescript-eslint']
+     * - false === []
+     */
+    debugLevel?: DebugLevel;
+    /**
+     * Cause the parser to error if it encounters an unknown AST node type (useful for testing).
+     * This case only usually occurs when TypeScript releases new features.
+     */
+    errorOnUnknownASTType?: boolean;
+    /**
+     * Absolute (or relative to `cwd`) path to the file being parsed.
+     */
+    filePath?: string;
+    /**
+     * Enable parsing of JSX.
+     * For more details, see https://www.typescriptlang.org/docs/handbook/jsx.html
+     *
+     * NOTE: this setting does not effect known file types (.js, .cjs, .mjs, .jsx, .ts, .mts, .cts, .tsx, .json) because the
+     * TypeScript compiler has its own internal handling for known file extensions.
+     *
+     * For the exact behavior, see https://github.com/typescript-eslint/typescript-eslint/tree/main/packages/parser#parseroptionsecmafeaturesjsx
+     */
+    jsx?: boolean;
+    /**
+     * Controls whether the `loc` information to each node.
+     * The `loc` property is an object which contains the exact line/column the node starts/ends on.
+     * This is similar to the `range` property, except it is line/column relative.
+     */
+    loc?: boolean;
+    loggerFn?: ((message: string) => void) | false;
+    /**
+     * Controls whether the `range` property is included on AST nodes.
+     * The `range` property is a [number, number] which indicates the start/end index of the node in the file contents.
+     * This is similar to the `loc` property, except this is the absolute index.
+     */
+    range?: boolean;
+    /**
+     * Set to true to create a top-level array containing all tokens from the file.
+     */
+    tokens?: boolean;
+}
+interface ParseAndGenerateServicesOptions extends ParseOptions {
+    /**
+     * Causes the parser to error if the TypeScript compiler returns any unexpected syntax/semantic errors.
+     */
+    errorOnTypeScriptSyntacticAndSemanticIssues?: boolean;
+    /**
+     * ***EXPERIMENTAL FLAG*** - Use this at your own risk.
+     *
+     * Causes TS to use the source files for referenced projects instead of the compiled .d.ts files.
+     * This feature is not yet optimized, and is likely to cause OOMs for medium to large projects.
+     *
+     * This flag REQUIRES at least TS v3.9, otherwise it does nothing.
+     *
+     * See: https://github.com/typescript-eslint/typescript-eslint/issues/2094
+     */
+    EXPERIMENTAL_useSourceOfProjectReferenceRedirect?: boolean;
+    /**
+     * When `project` is provided, this controls the non-standard file extensions which will be parsed.
+     * It accepts an array of file extensions, each preceded by a `.`.
+     */
+    extraFileExtensions?: string[];
+    /**
+     * Absolute (or relative to `tsconfigRootDir`) path to the file being parsed.
+     * When `project` is provided, this is required, as it is used to fetch the file from the TypeScript compiler's cache.
+     */
+    filePath?: string;
+    /**
+     * Allows the user to control whether or not two-way AST node maps are preserved
+     * during the AST conversion process.
+     *
+     * By default: the AST node maps are NOT preserved, unless `project` has been specified,
+     * in which case the maps are made available on the returned `parserServices`.
+     *
+     * NOTE: If `preserveNodeMaps` is explicitly set by the user, it will be respected,
+     * regardless of whether or not `project` is in use.
+     */
+    preserveNodeMaps?: boolean;
+    /**
+     * Absolute (or relative to `tsconfigRootDir`) paths to the tsconfig(s).
+     * If this is provided, type information will be returned.
+     */
+    project?: string | string[];
+    /**
+     * If you provide a glob (or globs) to the project option, you can use this option to ignore certain folders from
+     * being matched by the globs.
+     * This accepts an array of globs to ignore.
+     *
+     * By default, this is set to ["**\/node_modules/**"]
+     */
+    projectFolderIgnoreList?: string[];
+    /**
+     * The absolute path to the root directory for all provided `project`s.
+     */
+    tsconfigRootDir?: string;
+    /**
+     * An array of one or more instances of TypeScript Program objects to be used for type information.
+     * This overrides any program or programs that would have been computed from the `project` option.
+     * All linted files must be part of the provided program(s).
+     */
+    programs?: ts.Program[];
+    /**
+     ***************************************************************************************
+     * IT IS RECOMMENDED THAT YOU DO NOT USE THIS OPTION, AS IT CAUSES PERFORMANCE ISSUES. *
+     ***************************************************************************************
+     *
+     * When passed with `project`, this allows the parser to create a catch-all, default program.
+     * This means that if the parser encounters a file not included in any of the provided `project`s,
+     * it will not error, but will instead parse the file and its dependencies in a new program.
+     */
+    createDefaultProgram?: boolean;
+    /**
+     * ESLint (and therefore typescript-eslint) is used in both "single run"/one-time contexts,
+     * such as an ESLint CLI invocation, and long-running sessions (such as continuous feedback
+     * on a file in an IDE).
+     *
+     * When typescript-eslint handles TypeScript Program management behind the scenes, this distinction
+     * is important because there is significant overhead to managing the so called Watch Programs
+     * needed for the long-running use-case.
+     *
+     * When allowAutomaticSingleRunInference is enabled, we will use common heuristics to infer
+     * whether or not ESLint is being used as part of a single run.
+     */
+    allowAutomaticSingleRunInference?: boolean;
+    moduleResolver?: string;
+}
+export declare type TSESTreeOptions = ParseAndGenerateServicesOptions;
+export interface ParserWeakMap<TKey, TValueBase> {
+    get<TValue extends TValueBase>(key: TKey): TValue;
+    has(key: unknown): boolean;
+}
+export interface ParserWeakMapESTreeToTSNode<TKey extends TSESTree.Node = TSESTree.Node> {
+    get<TKeyBase extends TKey>(key: TKeyBase): TSESTreeToTSNode<TKeyBase>;
+    has(key: unknown): boolean;
+}
+export interface ParserServices {
+    program: ts.Program;
+    esTreeNodeToTSNodeMap: ParserWeakMapESTreeToTSNode;
+    tsNodeToESTreeNodeMap: ParserWeakMap<TSNode | TSToken, TSESTree.Node>;
+    hasFullTypeInformation: boolean;
+}
+export interface ModuleResolver {
+    version: 1;
+    resolveModuleNames(moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions): (ts.ResolvedModule | undefined)[];
+}
+export {};
+//# sourceMappingURL=parser-options.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/parser.d.ts

@@ -0,0 +1,25 @@
+import { ParserServices, TSESTreeOptions } from './parser-options';
+import { TSESTree } from './ts-estree';
+declare function clearProgramCache(): void;
+interface EmptyObject {
+}
+declare type AST<T extends TSESTreeOptions> = TSESTree.Program & (T['tokens'] extends true ? {
+    tokens: TSESTree.Token[];
+} : EmptyObject) & (T['comment'] extends true ? {
+    comments: TSESTree.Comment[];
+} : EmptyObject);
+interface ParseAndGenerateServicesResult<T extends TSESTreeOptions> {
+    ast: AST<T>;
+    services: ParserServices;
+}
+interface ParseWithNodeMapsResult<T extends TSESTreeOptions> {
+    ast: AST<T>;
+    esTreeNodeToTSNodeMap: ParserServices['esTreeNodeToTSNodeMap'];
+    tsNodeToESTreeNodeMap: ParserServices['tsNodeToESTreeNodeMap'];
+}
+declare function parse<T extends TSESTreeOptions = TSESTreeOptions>(code: string, options?: T): AST<T>;
+declare function parseWithNodeMaps<T extends TSESTreeOptions = TSESTreeOptions>(code: string, options?: T): ParseWithNodeMapsResult<T>;
+declare function clearParseAndGenerateServicesCalls(): void;
+declare function parseAndGenerateServices<T extends TSESTreeOptions = TSESTreeOptions>(code: string, options: T): ParseAndGenerateServicesResult<T>;
+export { AST, parse, parseAndGenerateServices, parseWithNodeMaps, ParseAndGenerateServicesResult, ParseWithNodeMapsResult, clearProgramCache, clearParseAndGenerateServicesCalls, };
+//# sourceMappingURL=parser.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/semantic-or-syntactic-errors.d.ts

@@ -0,0 +1,13 @@
+import { Diagnostic, Program, SourceFile } from 'typescript';
+export interface SemanticOrSyntacticError extends Diagnostic {
+    message: string;
+}
+/**
+ * By default, diagnostics from the TypeScript compiler contain all errors - regardless of whether
+ * they are related to generic ECMAScript standards, or TypeScript-specific constructs.
+ *
+ * Therefore, we filter out all diagnostics, except for the ones we explicitly want to consider when
+ * the user opts in to throwing errors on semantic issues.
+ */
+export declare function getFirstSemanticOrSyntacticError(program: Program, ast: SourceFile): SemanticOrSyntacticError | undefined;
+//# sourceMappingURL=semantic-or-syntactic-errors.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/simple-traverse.d.ts

@@ -0,0 +1,9 @@
+import { TSESTree } from './ts-estree';
+declare type SimpleTraverseOptions = {
+    enter: (node: TSESTree.Node, parent: TSESTree.Node | undefined) => void;
+} | {
+    [key: string]: (node: TSESTree.Node, parent: TSESTree.Node | undefined) => void;
+};
+export declare function simpleTraverse(startingNode: TSESTree.Node, options: SimpleTraverseOptions, setParentPointers?: boolean): void;
+export {};
+//# sourceMappingURL=simple-traverse.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/ts-estree/estree-to-ts-node-types.d.ts

@@ -0,0 +1,175 @@
+import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/types';
+import * as ts from 'typescript';
+import { TSNode } from './ts-nodes';
+export interface EstreeToTsNodeTypes {
+    [AST_NODE_TYPES.ArrayExpression]: ts.ArrayLiteralExpression;
+    [AST_NODE_TYPES.ArrayPattern]: ts.ArrayLiteralExpression | ts.ArrayBindingPattern;
+    [AST_NODE_TYPES.ArrowFunctionExpression]: ts.ArrowFunction;
+    [AST_NODE_TYPES.AssignmentExpression]: ts.BinaryExpression;
+    [AST_NODE_TYPES.AssignmentPattern]: ts.ShorthandPropertyAssignment | ts.BindingElement | ts.BinaryExpression | ts.ParameterDeclaration;
+    [AST_NODE_TYPES.AwaitExpression]: ts.AwaitExpression;
+    [AST_NODE_TYPES.BinaryExpression]: ts.BinaryExpression;
+    [AST_NODE_TYPES.BlockStatement]: ts.Block;
+    [AST_NODE_TYPES.BreakStatement]: ts.BreakStatement;
+    [AST_NODE_TYPES.CallExpression]: ts.CallExpression;
+    [AST_NODE_TYPES.CatchClause]: ts.CatchClause;
+    [AST_NODE_TYPES.ChainExpression]: ts.CallExpression | ts.PropertyAccessExpression | ts.ElementAccessExpression | ts.NonNullExpression;
+    [AST_NODE_TYPES.ClassBody]: ts.ClassDeclaration | ts.ClassExpression;
+    [AST_NODE_TYPES.ClassDeclaration]: ts.ClassDeclaration;
+    [AST_NODE_TYPES.ClassExpression]: ts.ClassExpression;
+    [AST_NODE_TYPES.PropertyDefinition]: ts.PropertyDeclaration;
+    [AST_NODE_TYPES.ConditionalExpression]: ts.ConditionalExpression;
+    [AST_NODE_TYPES.ContinueStatement]: ts.ContinueStatement;
+    [AST_NODE_TYPES.DebuggerStatement]: ts.DebuggerStatement;
+    [AST_NODE_TYPES.Decorator]: ts.Decorator;
+    [AST_NODE_TYPES.DoWhileStatement]: ts.DoStatement;
+    [AST_NODE_TYPES.EmptyStatement]: ts.EmptyStatement;
+    [AST_NODE_TYPES.ExportAllDeclaration]: ts.ExportDeclaration;
+    [AST_NODE_TYPES.ExportDefaultDeclaration]: ts.ExportAssignment | ts.FunctionDeclaration | ts.VariableStatement | ts.ClassDeclaration | ts.ClassExpression | ts.TypeAliasDeclaration | ts.InterfaceDeclaration | ts.EnumDeclaration | ts.ModuleDeclaration;
+    [AST_NODE_TYPES.ExportNamedDeclaration]: ts.ExportDeclaration | ts.FunctionDeclaration | ts.VariableStatement | ts.ClassDeclaration | ts.ClassExpression | ts.TypeAliasDeclaration | ts.InterfaceDeclaration | ts.EnumDeclaration | ts.ModuleDeclaration;
+    [AST_NODE_TYPES.ExportSpecifier]: ts.ExportSpecifier;
+    [AST_NODE_TYPES.ExpressionStatement]: ts.ExpressionStatement;
+    [AST_NODE_TYPES.ForInStatement]: ts.ForInStatement;
+    [AST_NODE_TYPES.ForOfStatement]: ts.ForOfStatement;
+    [AST_NODE_TYPES.ForStatement]: ts.ForStatement;
+    [AST_NODE_TYPES.FunctionDeclaration]: ts.FunctionDeclaration;
+    [AST_NODE_TYPES.FunctionExpression]: ts.FunctionExpression | ts.ConstructorDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.MethodDeclaration;
+    [AST_NODE_TYPES.Identifier]: ts.Identifier | ts.ConstructorDeclaration | ts.Token<ts.SyntaxKind.NewKeyword | ts.SyntaxKind.ImportKeyword>;
+    [AST_NODE_TYPES.PrivateIdentifier]: ts.PrivateIdentifier;
+    [AST_NODE_TYPES.IfStatement]: ts.IfStatement;
+    [AST_NODE_TYPES.ImportAttribute]: ts.AssertEntry;
+    [AST_NODE_TYPES.ImportDeclaration]: ts.ImportDeclaration;
+    [AST_NODE_TYPES.ImportDefaultSpecifier]: ts.ImportClause;
+    [AST_NODE_TYPES.ImportExpression]: ts.CallExpression;
+    [AST_NODE_TYPES.ImportNamespaceSpecifier]: ts.NamespaceImport;
+    [AST_NODE_TYPES.ImportSpecifier]: ts.ImportSpecifier;
+    [AST_NODE_TYPES.JSXAttribute]: ts.JsxAttribute;
+    [AST_NODE_TYPES.JSXClosingElement]: ts.JsxClosingElement;
+    [AST_NODE_TYPES.JSXClosingFragment]: ts.JsxClosingFragment;
+    [AST_NODE_TYPES.JSXElement]: ts.JsxElement | ts.JsxSelfClosingElement;
+    [AST_NODE_TYPES.JSXEmptyExpression]: ts.JsxExpression;
+    [AST_NODE_TYPES.JSXExpressionContainer]: ts.JsxExpression;
+    [AST_NODE_TYPES.JSXFragment]: ts.JsxFragment;
+    [AST_NODE_TYPES.JSXIdentifier]: ts.Identifier | ts.ThisExpression;
+    [AST_NODE_TYPES.JSXOpeningElement]: ts.JsxOpeningElement | ts.JsxSelfClosingElement;
+    [AST_NODE_TYPES.JSXOpeningFragment]: ts.JsxOpeningFragment;
+    [AST_NODE_TYPES.JSXSpreadAttribute]: ts.JsxSpreadAttribute;
+    [AST_NODE_TYPES.JSXSpreadChild]: ts.JsxExpression;
+    [AST_NODE_TYPES.JSXMemberExpression]: ts.PropertyAccessExpression;
+    [AST_NODE_TYPES.JSXNamespacedName]: ts.Identifier | ts.ThisExpression;
+    [AST_NODE_TYPES.JSXText]: ts.JsxText;
+    [AST_NODE_TYPES.LabeledStatement]: ts.LabeledStatement;
+    [AST_NODE_TYPES.Literal]: ts.StringLiteral | ts.NumericLiteral | ts.RegularExpressionLiteral | ts.NullLiteral | ts.BooleanLiteral | ts.BigIntLiteral;
+    [AST_NODE_TYPES.LogicalExpression]: ts.BinaryExpression;
+    [AST_NODE_TYPES.MemberExpression]: ts.PropertyAccessExpression | ts.ElementAccessExpression;
+    [AST_NODE_TYPES.MetaProperty]: ts.MetaProperty;
+    [AST_NODE_TYPES.MethodDefinition]: ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.MethodDeclaration | ts.ConstructorDeclaration;
+    [AST_NODE_TYPES.NewExpression]: ts.NewExpression;
+    [AST_NODE_TYPES.ObjectExpression]: ts.ObjectLiteralExpression;
+    [AST_NODE_TYPES.ObjectPattern]: ts.ObjectLiteralExpression | ts.ObjectBindingPattern;
+    [AST_NODE_TYPES.Program]: ts.SourceFile;
+    [AST_NODE_TYPES.Property]: ts.PropertyAssignment | ts.ShorthandPropertyAssignment | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.MethodDeclaration | ts.BindingElement;
+    [AST_NODE_TYPES.RestElement]: ts.BindingElement | ts.SpreadAssignment | ts.SpreadElement | ts.ParameterDeclaration;
+    [AST_NODE_TYPES.ReturnStatement]: ts.ReturnStatement;
+    [AST_NODE_TYPES.SequenceExpression]: ts.BinaryExpression;
+    [AST_NODE_TYPES.SpreadElement]: ts.SpreadElement | ts.SpreadAssignment;
+    [AST_NODE_TYPES.StaticBlock]: ts.ClassStaticBlockDeclaration;
+    [AST_NODE_TYPES.Super]: ts.SuperExpression;
+    [AST_NODE_TYPES.SwitchCase]: ts.CaseClause | ts.DefaultClause;
+    [AST_NODE_TYPES.SwitchStatement]: ts.SwitchStatement;
+    [AST_NODE_TYPES.TaggedTemplateExpression]: ts.TaggedTemplateExpression;
+    [AST_NODE_TYPES.TemplateElement]: ts.NoSubstitutionTemplateLiteral | ts.TemplateHead | ts.TemplateMiddle | ts.TemplateTail;
+    [AST_NODE_TYPES.TemplateLiteral]: ts.NoSubstitutionTemplateLiteral | ts.TemplateExpression;
+    [AST_NODE_TYPES.ThisExpression]: ts.ThisExpression | ts.KeywordTypeNode | ts.Identifier;
+    [AST_NODE_TYPES.ThrowStatement]: ts.ThrowStatement;
+    [AST_NODE_TYPES.TryStatement]: ts.TryStatement;
+    [AST_NODE_TYPES.TSAbstractPropertyDefinition]: ts.PropertyDeclaration;
+    [AST_NODE_TYPES.TSAbstractMethodDefinition]: ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.MethodDeclaration | ts.ConstructorDeclaration;
+    [AST_NODE_TYPES.TSArrayType]: ts.ArrayTypeNode;
+    [AST_NODE_TYPES.TSAsExpression]: ts.AsExpression;
+    [AST_NODE_TYPES.TSCallSignatureDeclaration]: ts.CallSignatureDeclaration;
+    [AST_NODE_TYPES.TSClassImplements]: ts.ExpressionWithTypeArguments;
+    [AST_NODE_TYPES.TSConditionalType]: ts.ConditionalTypeNode;
+    [AST_NODE_TYPES.TSConstructorType]: ts.ConstructorTypeNode;
+    [AST_NODE_TYPES.TSConstructSignatureDeclaration]: ts.ConstructSignatureDeclaration;
+    [AST_NODE_TYPES.TSDeclareFunction]: ts.FunctionDeclaration;
+    [AST_NODE_TYPES.TSEnumDeclaration]: ts.EnumDeclaration;
+    [AST_NODE_TYPES.TSEnumMember]: ts.EnumMember;
+    [AST_NODE_TYPES.TSExportAssignment]: ts.ExportAssignment;
+    [AST_NODE_TYPES.TSExternalModuleReference]: ts.ExternalModuleReference;
+    [AST_NODE_TYPES.TSFunctionType]: ts.FunctionTypeNode;
+    [AST_NODE_TYPES.TSImportEqualsDeclaration]: ts.ImportEqualsDeclaration;
+    [AST_NODE_TYPES.TSImportType]: ts.ImportTypeNode;
+    [AST_NODE_TYPES.TSIndexedAccessType]: ts.IndexedAccessTypeNode;
+    [AST_NODE_TYPES.TSIndexSignature]: ts.IndexSignatureDeclaration;
+    [AST_NODE_TYPES.TSInferType]: ts.InferTypeNode;
+    [AST_NODE_TYPES.TSInterfaceDeclaration]: ts.InterfaceDeclaration;
+    [AST_NODE_TYPES.TSInterfaceBody]: ts.InterfaceDeclaration;
+    [AST_NODE_TYPES.TSInterfaceHeritage]: ts.ExpressionWithTypeArguments;
+    [AST_NODE_TYPES.TSIntersectionType]: ts.IntersectionTypeNode;
+    [AST_NODE_TYPES.TSInstantiationExpression]: ts.ExpressionWithTypeArguments;
+    [AST_NODE_TYPES.TSLiteralType]: ts.LiteralTypeNode;
+    [AST_NODE_TYPES.TSMappedType]: ts.MappedTypeNode;
+    [AST_NODE_TYPES.TSMethodSignature]: ts.MethodSignature | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration;
+    [AST_NODE_TYPES.TSModuleBlock]: ts.ModuleBlock;
+    [AST_NODE_TYPES.TSModuleDeclaration]: ts.ModuleDeclaration;
+    [AST_NODE_TYPES.TSNamedTupleMember]: ts.NamedTupleMember;
+    [AST_NODE_TYPES.TSNamespaceExportDeclaration]: ts.NamespaceExportDeclaration;
+    [AST_NODE_TYPES.TSNonNullExpression]: ts.NonNullExpression;
+    [AST_NODE_TYPES.TSOptionalType]: ts.OptionalTypeNode;
+    [AST_NODE_TYPES.TSParameterProperty]: ts.ParameterDeclaration;
+    [AST_NODE_TYPES.TSPropertySignature]: ts.PropertySignature;
+    [AST_NODE_TYPES.TSQualifiedName]: ts.QualifiedName;
+    [AST_NODE_TYPES.TSRestType]: ts.RestTypeNode | ts.NamedTupleMember;
+    [AST_NODE_TYPES.TSThisType]: ts.ThisTypeNode;
+    [AST_NODE_TYPES.TSTupleType]: ts.TupleTypeNode;
+    [AST_NODE_TYPES.TSTemplateLiteralType]: ts.TemplateLiteralTypeNode;
+    [AST_NODE_TYPES.TSTypeAliasDeclaration]: ts.TypeAliasDeclaration;
+    [AST_NODE_TYPES.TSTypeAnnotation]: undefined;
+    [AST_NODE_TYPES.TSTypeAssertion]: ts.TypeAssertion;
+    [AST_NODE_TYPES.TSTypeLiteral]: ts.TypeLiteralNode;
+    [AST_NODE_TYPES.TSTypeOperator]: ts.TypeOperatorNode;
+    [AST_NODE_TYPES.TSTypeParameter]: ts.TypeParameterDeclaration;
+    [AST_NODE_TYPES.TSTypeParameterDeclaration]: undefined;
+    [AST_NODE_TYPES.TSTypeParameterInstantiation]: ts.TaggedTemplateExpression | ts.ImportTypeNode | ts.ExpressionWithTypeArguments | ts.TypeReferenceNode | ts.JsxOpeningElement | ts.JsxSelfClosingElement | ts.NewExpression | ts.CallExpression | ts.TypeQueryNode;
+    [AST_NODE_TYPES.TSTypePredicate]: ts.TypePredicateNode;
+    [AST_NODE_TYPES.TSTypeQuery]: ts.TypeQueryNode;
+    [AST_NODE_TYPES.TSTypeReference]: ts.TypeReferenceNode;
+    [AST_NODE_TYPES.TSUnionType]: ts.UnionTypeNode;
+    [AST_NODE_TYPES.UpdateExpression]: ts.PrefixUnaryExpression | ts.PostfixUnaryExpression;
+    [AST_NODE_TYPES.UnaryExpression]: ts.PrefixUnaryExpression | ts.PostfixUnaryExpression | ts.DeleteExpression | ts.VoidExpression | ts.TypeOfExpression;
+    [AST_NODE_TYPES.VariableDeclaration]: ts.VariableDeclarationList | ts.VariableStatement;
+    [AST_NODE_TYPES.VariableDeclarator]: ts.VariableDeclaration;
+    [AST_NODE_TYPES.WhileStatement]: ts.WhileStatement;
+    [AST_NODE_TYPES.WithStatement]: ts.WithStatement;
+    [AST_NODE_TYPES.YieldExpression]: ts.YieldExpression;
+    [AST_NODE_TYPES.TSEmptyBodyFunctionExpression]: ts.FunctionExpression | ts.ConstructorDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.MethodDeclaration;
+    [AST_NODE_TYPES.TSAbstractKeyword]: ts.Token<ts.SyntaxKind.AbstractKeyword>;
+    [AST_NODE_TYPES.TSNullKeyword]: ts.NullLiteral | ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSAnyKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSBigIntKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSBooleanKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSIntrinsicKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSNeverKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSNumberKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSObjectKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSStringKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSSymbolKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSUnknownKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSVoidKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSUndefinedKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSAsyncKeyword]: ts.Token<ts.SyntaxKind.AsyncKeyword>;
+    [AST_NODE_TYPES.TSDeclareKeyword]: ts.Token<ts.SyntaxKind.DeclareKeyword>;
+    [AST_NODE_TYPES.TSExportKeyword]: ts.Token<ts.SyntaxKind.ExportKeyword>;
+    [AST_NODE_TYPES.TSStaticKeyword]: ts.Token<ts.SyntaxKind.StaticKeyword>;
+    [AST_NODE_TYPES.TSPublicKeyword]: ts.Token<ts.SyntaxKind.PublicKeyword>;
+    [AST_NODE_TYPES.TSPrivateKeyword]: ts.Token<ts.SyntaxKind.PrivateKeyword>;
+    [AST_NODE_TYPES.TSProtectedKeyword]: ts.Token<ts.SyntaxKind.ProtectedKeyword>;
+    [AST_NODE_TYPES.TSReadonlyKeyword]: ts.Token<ts.SyntaxKind.ReadonlyKeyword>;
+}
+/**
+ * Maps TSESTree AST Node type to the expected TypeScript AST Node type(s).
+ * This mapping is based on the internal logic of the parser.
+ */
+export declare type TSESTreeToTSNode<T extends TSESTree.Node = TSESTree.Node> = Extract<TSNode | ts.Token<ts.SyntaxKind.NewKeyword | ts.SyntaxKind.ImportKeyword>, EstreeToTsNodeTypes[T['type']]>;
+//# sourceMappingURL=estree-to-ts-node-types.d.ts.map

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

@@ -0,0 +1,4 @@
+export { AST_NODE_TYPES, AST_TOKEN_TYPES, TSESTree, } from '@typescript-eslint/types';
+export * from './ts-nodes';
+export * from './estree-to-ts-node-types';
+//# sourceMappingURL=index.d.ts.map