xo 0.54.2 → 0.55.0

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

@@ -1,9 +0,0 @@
-import { SourceFile } from 'typescript';
-import { ASTMaps } from './convert';
-import { ParseSettings } from './parseSettings';
-import { TSESTree } from './ts-estree';
-export declare function astConverter(ast: SourceFile, parseSettings: ParseSettings, shouldPreserveNodeMaps: boolean): {
-    estree: TSESTree.Program;
-    astMaps: ASTMaps;
-};
-//# sourceMappingURL=ast-converter.d.ts.map

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

@@ -1,10 +0,0 @@
-/**
- * Clears all of the internal caches.
- * Generally you shouldn't need or want to use this.
- * Examples of intended uses:
- * - In tests to reset parser state to keep tests isolated.
- * - In custom lint tooling that iteratively lints one project at a time to prevent OOMs.
- */
-export declare function clearCaches(): void;
-export declare const clearProgramCache: typeof clearCaches;
-//# sourceMappingURL=clear-caches.d.ts.map

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

@@ -1,11 +0,0 @@
-import * as ts from 'typescript';
-import { TSESTree } from './ts-estree';
-/**
- * Convert all comments for the given AST.
- * @param ast the AST object
- * @param code the TypeScript code
- * @returns the converted ESTreeComment
- * @private
- */
-export declare function convertComments(ast: ts.SourceFile, code: string): TSESTree.Comment[];
-//# sourceMappingURL=convert-comments.d.ts.map

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

@@ -1,159 +0,0 @@
-import * as ts from 'typescript';
-import { TSError } from './node-utils';
-import { ParserWeakMap, ParserWeakMapESTreeToTSNode } from './parser-options';
-import { SemanticOrSyntacticError } from './semantic-or-syntactic-errors';
-import { TSESTree, TSNode } from './ts-estree';
-interface ConverterOptions {
-    errorOnUnknownASTType: boolean;
-    shouldPreserveNodeMaps: boolean;
-}
-/**
- * Extends and formats a given error object
- * @param error the error object
- * @returns converted error object
- */
-export declare function convertError(error: ts.DiagnosticWithLocation | SemanticOrSyntacticError): TSError;
-export interface ASTMaps {
-    esTreeNodeToTSNodeMap: ParserWeakMapESTreeToTSNode;
-    tsNodeToESTreeNodeMap: ParserWeakMap<TSNode, TSESTree.Node>;
-}
-export declare class Converter {
-    private readonly ast;
-    private readonly options;
-    private readonly esTreeNodeToTSNodeMap;
-    private readonly tsNodeToESTreeNodeMap;
-    private allowPattern;
-    private inTypeMode;
-    /**
-     * Converts a TypeScript node into an ESTree node
-     * @param ast the full TypeScript AST
-     * @param options additional options for the conversion
-     * @returns the converted ESTreeNode
-     */
-    constructor(ast: ts.SourceFile, options: ConverterOptions);
-    getASTMaps(): ASTMaps;
-    convertProgram(): TSESTree.Program;
-    /**
-     * Converts a TypeScript node into an ESTree node.
-     * @param node the child ts.Node
-     * @param parent parentNode
-     * @param inTypeMode flag to determine if we are in typeMode
-     * @param allowPattern flag to determine if patterns are allowed
-     * @returns the converted ESTree node
-     */
-    private converter;
-    /**
-     * Fixes the exports of the given ts.Node
-     * @param node the ts.Node
-     * @param result result
-     * @returns the ESTreeNode with fixed exports
-     */
-    private fixExports;
-    /**
-     * Register specific TypeScript node into map with first ESTree node provided
-     */
-    private registerTSNodeInNodeMap;
-    /**
-     * Converts a TypeScript node into an ESTree node.
-     * @param child the child ts.Node
-     * @param parent parentNode
-     * @returns the converted ESTree node
-     */
-    private convertPattern;
-    /**
-     * Converts a TypeScript node into an ESTree node.
-     * @param child the child ts.Node
-     * @param parent parentNode
-     * @returns the converted ESTree node
-     */
-    private convertChild;
-    /**
-     * Converts a TypeScript node into an ESTree node.
-     * @param child the child ts.Node
-     * @param parent parentNode
-     * @returns the converted ESTree node
-     */
-    private convertType;
-    private createNode;
-    private convertBindingNameWithTypeAnnotation;
-    /**
-     * Converts a child into a type annotation. This creates an intermediary
-     * TypeAnnotation node to match what Flow does.
-     * @param child The TypeScript AST node to convert.
-     * @param parent parentNode
-     * @returns The type annotation node.
-     */
-    private convertTypeAnnotation;
-    /**
-     * Coverts body Nodes and add a directive field to StringLiterals
-     * @param nodes of ts.Node
-     * @param parent parentNode
-     * @returns Array of body statements
-     */
-    private convertBodyExpressions;
-    /**
-     * Converts a ts.Node's typeArguments to TSTypeParameterInstantiation node
-     * @param typeArguments ts.NodeArray typeArguments
-     * @param node parent used to create this node
-     * @returns TypeParameterInstantiation node
-     */
-    private convertTypeArgumentsToTypeParameters;
-    /**
-     * Converts a ts.Node's typeParameters to TSTypeParameterDeclaration node
-     * @param typeParameters ts.Node typeParameters
-     * @returns TypeParameterDeclaration node
-     */
-    private convertTSTypeParametersToTypeParametersDeclaration;
-    /**
-     * Converts an array of ts.Node parameters into an array of ESTreeNode params
-     * @param parameters An array of ts.Node params to be converted
-     * @returns an array of converted ESTreeNode params
-     */
-    private convertParameters;
-    private convertChainExpression;
-    /**
-     * For nodes that are copied directly from the TypeScript AST into
-     * ESTree mostly as-is. The only difference is the addition of a type
-     * property instead of a kind property. Recursively copies all children.
-     */
-    private deeplyCopy;
-    private convertJSXIdentifier;
-    private convertJSXNamespaceOrIdentifier;
-    /**
-     * Converts a TypeScript JSX node.tagName into an ESTree node.name
-     * @param node the tagName object from a JSX ts.Node
-     * @param parent
-     * @returns the converted ESTree name object
-     */
-    private convertJSXTagName;
-    private convertMethodSignature;
-    private convertAssertClasue;
-    /**
-     * Applies the given TS modifiers to the given result object.
-     *
-     * This method adds not standardized `modifiers` property in nodes
-     *
-     * @param result
-     * @param modifiers original ts.Nodes from the node.modifiers array
-     * @returns the current result object will be mutated
-     */
-    private applyModifiersToResult;
-    /**
-     * Uses the provided range location to adjust the location data of the given Node
-     * @param result The node that will have its location data mutated
-     * @param childRange The child node range used to expand location
-     */
-    private fixParentLocation;
-    private assertModuleSpecifier;
-    /**
-     * Converts a TypeScript node into an ESTree node.
-     * The core of the conversion logic:
-     * Identify and convert each relevant TypeScript SyntaxKind
-     * @param node the child ts.Node
-     * @param parent parentNode
-     * @returns the converted ESTree node
-     */
-    private convertNode;
-}
-export {};
-//# sourceMappingURL=convert.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/WatchCompilerHostOfConfigFile.d.ts

@@ -1,13 +0,0 @@
-import * as ts from 'typescript';
-interface DirectoryStructureHost {
-    readDirectory?(path: string, extensions?: ReadonlyArray<string>, exclude?: ReadonlyArray<string>, include?: ReadonlyArray<string>, depth?: number): string[];
-}
-interface CachedDirectoryStructureHost extends DirectoryStructureHost {
-    readDirectory(path: string, extensions?: ReadonlyArray<string>, exclude?: ReadonlyArray<string>, include?: ReadonlyArray<string>, depth?: number): string[];
-}
-interface WatchCompilerHostOfConfigFile<T extends ts.BuilderProgram> extends ts.WatchCompilerHostOfConfigFile<T> {
-    onCachedDirectoryStructureHostCreate(host: CachedDirectoryStructureHost): void;
-    extraFileExtensions?: readonly ts.FileExtensionInfo[];
-}
-export { WatchCompilerHostOfConfigFile };
-//# sourceMappingURL=WatchCompilerHostOfConfigFile.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/createDefaultProgram.d.ts

@@ -1,9 +0,0 @@
-import { ParseSettings } from '../parseSettings';
-import { ASTAndProgram } from './shared';
-/**
- * @param parseSettings Internal settings for parsing the file
- * @returns If found, returns the source file corresponding to the code and the containing program
- */
-declare function createDefaultProgram(parseSettings: ParseSettings): ASTAndProgram | undefined;
-export { createDefaultProgram };
-//# sourceMappingURL=createDefaultProgram.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/createIsolatedProgram.d.ts

@@ -1,9 +0,0 @@
-import { ParseSettings } from '../parseSettings';
-import { ASTAndProgram } from './shared';
-/**
- * @param code The code of the file being linted
- * @returns Returns a new source file and program corresponding to the linted code
- */
-declare function createIsolatedProgram(parseSettings: ParseSettings): ASTAndProgram;
-export { createIsolatedProgram };
-//# sourceMappingURL=createIsolatedProgram.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/createProjectProgram.d.ts

@@ -1,9 +0,0 @@
-import { ParseSettings } from '../parseSettings';
-import { ASTAndProgram } from './shared';
-/**
- * @param parseSettings Internal settings for parsing the file
- * @returns If found, the source file corresponding to the code and the containing program
- */
-declare function createProjectProgram(parseSettings: ParseSettings): ASTAndProgram | undefined;
-export { createProjectProgram };
-//# sourceMappingURL=createProjectProgram.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/createSourceFile.d.ts

@@ -1,5 +0,0 @@
-import * as ts from 'typescript';
-import { ParseSettings } from '../parseSettings';
-declare function createSourceFile(parseSettings: ParseSettings): ts.SourceFile;
-export { createSourceFile };
-//# sourceMappingURL=createSourceFile.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/describeFilePath.d.ts

@@ -1,2 +0,0 @@
-export declare function describeFilePath(filePath: string, tsconfigRootDir: string): string;
-//# sourceMappingURL=describeFilePath.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/getScriptKind.d.ts

@@ -1,5 +0,0 @@
-import * as ts from 'typescript';
-declare function getScriptKind(filePath: string, jsx: boolean): ts.ScriptKind;
-declare function getLanguageVariant(scriptKind: ts.ScriptKind): ts.LanguageVariant;
-export { getScriptKind, getLanguageVariant };
-//# sourceMappingURL=getScriptKind.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/getWatchProgramsForProjects.d.ts

@@ -1,15 +0,0 @@
-import * as ts from 'typescript';
-import { ParseSettings } from '../parseSettings';
-/**
- * Clear all of the parser caches.
- * This should only be used in testing to ensure the parser is clean between tests.
- */
-declare function clearWatchCaches(): void;
-/**
- * Calculate project environments using options provided by consumer and paths from config
- * @param parseSettings Internal settings for parsing the file
- * @returns The programs corresponding to the supplied tsconfig paths
- */
-declare function getWatchProgramsForProjects(parseSettings: ParseSettings): ts.Program[];
-export { clearWatchCaches, getWatchProgramsForProjects };
-//# sourceMappingURL=getWatchProgramsForProjects.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/shared.d.ts

@@ -1,29 +0,0 @@
-import { Program } from 'typescript';
-import * as ts from 'typescript';
-import { ModuleResolver } from '../parser-options';
-import { ParseSettings } from '../parseSettings';
-interface ASTAndProgram {
-    ast: ts.SourceFile;
-    program: ts.Program;
-}
-/**
- * Compiler options required to avoid critical functionality issues
- */
-declare const CORE_COMPILER_OPTIONS: ts.CompilerOptions;
-declare function createDefaultCompilerOptionsFromExtra(parseSettings: ParseSettings): ts.CompilerOptions;
-type CanonicalPath = string & {
-    __brand: unknown;
-};
-declare function getCanonicalFileName(filePath: string): CanonicalPath;
-declare function ensureAbsolutePath(p: string, tsconfigRootDir: string): string;
-declare function canonicalDirname(p: CanonicalPath): CanonicalPath;
-declare function getAstFromProgram(currentProgram: Program, parseSettings: ParseSettings): ASTAndProgram | undefined;
-declare function getModuleResolver(moduleResolverPath: string): ModuleResolver;
-/**
- * Hash content for compare content.
- * @param content hashed contend
- * @returns hashed result
- */
-declare function createHash(content: string): string;
-export { ASTAndProgram, CORE_COMPILER_OPTIONS, canonicalDirname, CanonicalPath, createDefaultCompilerOptionsFromExtra, createHash, ensureAbsolutePath, getCanonicalFileName, getAstFromProgram, getModuleResolver, };
-//# sourceMappingURL=shared.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/useProvidedPrograms.d.ts

@@ -1,13 +0,0 @@
-import * as ts from 'typescript';
-import { ParseSettings } from '../parseSettings';
-import { ASTAndProgram } from './shared';
-declare function useProvidedPrograms(programInstances: Iterable<ts.Program>, parseSettings: ParseSettings): ASTAndProgram | undefined;
-/**
- * Utility offered by parser to help consumers construct their own program instance.
- *
- * @param configFile the path to the tsconfig.json file, relative to `projectDirectory`
- * @param projectDirectory the project directory to use as the CWD, defaults to `process.cwd()`
- */
-declare function createProgramFromConfigFile(configFile: string, projectDirectory?: string): ts.Program;
-export { useProvidedPrograms, createProgramFromConfigFile };
-//# sourceMappingURL=useProvidedPrograms.d.ts.map

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

@@ -1,4 +0,0 @@
-import * as ts from 'typescript';
-export declare function getModifiers(node: ts.Node | null | undefined): undefined | ts.Modifier[];
-export declare function getDecorators(node: ts.Node | null | undefined): undefined | ts.Decorator[];
-//# sourceMappingURL=getModifiers.d.ts.map

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

@@ -1,12 +0,0 @@
-export { AST, parse, parseAndGenerateServices, parseWithNodeMaps, ParseAndGenerateServicesResult, ParseWithNodeMapsResult, } from './parser';
-export { ParserServices, TSESTreeOptions } from './parser-options';
-export { simpleTraverse } from './simple-traverse';
-export * from './ts-estree';
-export { createProgramFromConfigFile as createProgram } from './create-program/useProvidedPrograms';
-export * from './create-program/getScriptKind';
-export { typescriptVersionIsAtLeast } from './version-check';
-export * from './getModifiers';
-export * from './clear-caches';
-export { visitorKeys } from '@typescript-eslint/visitor-keys';
-export declare const version: string;
-//# sourceMappingURL=index.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/jsx/xhtml-entities.d.ts

@@ -1,2 +0,0 @@
-export declare const xhtmlEntities: Record<string, string>;
-//# sourceMappingURL=xhtml-entities.d.ts.map

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

@@ -1,231 +0,0 @@
-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/parseSettings/ExpiringCache.d.ts

@@ -1,17 +0,0 @@
-import { CacheDurationSeconds } from '@typescript-eslint/types';
-export declare const DEFAULT_TSCONFIG_CACHE_DURATION_SECONDS = 30;
-export interface CacheLike<Key, Value> {
-    get(key: Key): Value | void;
-    set(key: Key, value: Value): this;
-}
-/**
- * A map with key-level expiration.
- */
-export declare class ExpiringCache<TKey, TValue> implements CacheLike<TKey, TValue> {
-    private "ExpiringCache.#private";
-    constructor(cacheDurationSeconds: CacheDurationSeconds);
-    set(key: TKey, value: TValue): this;
-    get(key: TKey): TValue | undefined;
-    clear(): void;
-}
-//# sourceMappingURL=ExpiringCache.d.ts.map

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

@@ -1,5 +0,0 @@
-import { TSESTreeOptions } from '../parser-options';
-import { MutableParseSettings } from './index';
-export declare function createParseSettings(code: string, options?: Partial<TSESTreeOptions>): MutableParseSettings;
-export declare function clearTSConfigMatchCache(): void;
-//# sourceMappingURL=createParseSettings.d.ts.map

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

@@ -1,12 +0,0 @@
-import { ParseSettings } from '.';
-/**
- * Checks for a matching TSConfig to a file including its parent directories,
- * permanently caching results under each directory it checks.
- *
- * @remarks
- * We don't (yet!) have a way to attach file watchers on disk, but still need to
- * cache file checks for rapid subsequent calls to fs.existsSync. See discussion
- * in https://github.com/typescript-eslint/typescript-eslint/issues/101.
- */
-export declare function getProjectConfigFiles(parseSettings: Pick<ParseSettings, 'filePath' | 'tsconfigMatchCache' | 'tsconfigRootDir'>, project: string | string[] | true | undefined): string[] | undefined;
-//# sourceMappingURL=getProjectConfigFiles.d.ts.map