@typescript-eslint/typescript-estree 6.2.2-alpha.0 → 6.2.2-alpha.10

package/_ts4.3/dist/node-utils.d.ts

@@ -1,254 +0,0 @@
-import * as ts from 'typescript';
-import type { TSESTree, TSNode } from './ts-estree';
-import { AST_NODE_TYPES, AST_TOKEN_TYPES } from './ts-estree';
-declare const SyntaxKind: typeof ts.SyntaxKind;
-type LogicalOperatorKind = ts.SyntaxKind.AmpersandAmpersandToken | ts.SyntaxKind.BarBarToken | ts.SyntaxKind.QuestionQuestionToken;
-interface TokenToText extends TSESTree.PunctuatorTokenToText, TSESTree.BinaryOperatorToText {
-    [SyntaxKind.ImportKeyword]: 'import';
-    [SyntaxKind.NewKeyword]: 'new';
-    [SyntaxKind.KeyOfKeyword]: 'keyof';
-    [SyntaxKind.ReadonlyKeyword]: 'readonly';
-    [SyntaxKind.UniqueKeyword]: 'unique';
-}
-type AssignmentOperatorKind = keyof TSESTree.AssignmentOperatorToText;
-type BinaryOperatorKind = keyof TSESTree.BinaryOperatorToText;
-/**
- * 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(operator: ts.BinaryOperatorToken): operator is ts.Token<LogicalOperatorKind>;
-export declare function isESTreeBinaryOperator(operator: ts.BinaryOperatorToken): operator is ts.Token<BinaryOperatorKind>;
-type TokenForTokenKind<T extends ts.SyntaxKind> = T extends keyof TokenToText ? TokenToText[T] : string | undefined;
-/**
- * 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): TokenForTokenKind<T>;
-/**
- * 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 the binary expression type of the given ts.Token
- * @param operator the operator token
- * @returns the binary expression type
- */
-export declare function getBinaryExpressionType(operator: ts.BinaryOperatorToken): {
-    type: AST_NODE_TYPES.AssignmentExpression;
-    operator: TokenForTokenKind<AssignmentOperatorKind>;
-} | {
-    type: AST_NODE_TYPES.BinaryExpression;
-    operator: TokenForTokenKind<BinaryOperatorKind>;
-} | {
-    type: AST_NODE_TYPES.LogicalExpression;
-    operator: TokenForTokenKind<LogicalOperatorKind>;
-};
-/**
- * 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 range start end data
- * @param ast   the AST object
- * @returns the loc data
- */
-export declare function getLocFor(range: TSESTree.Range, 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.Block | ts.ClassStaticBlockDeclaration | ts.ModuleBlock | ts.SourceFile): 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: Pick<ts.Node, 'getEnd' | 'getStart'>, ast: ts.SourceFile): [
-    number,
-    number
-];
-/**
- * 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): 'const' | 'let' | '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): 'private' | 'protected' | 'public' | undefined;
-/**
- * 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.CallExpression | ts.ElementAccessExpression | ts.NonNullExpression | ts.PropertyAccessExpression, 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.Block | AST_TOKEN_TYPES.Line>;
-/**
- * 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 location: {
-        start: {
-            line: number;
-            column: number;
-            offset: number;
-        };
-        end: {
-            line: number;
-            column: number;
-            offset: number;
-        };
-    };
-    constructor(message: string, fileName: string, location: {
-        start: {
-            line: number;
-            column: number;
-            offset: number;
-        };
-        end: {
-            line: number;
-            column: number;
-            offset: number;
-        };
-    });
-    get index(): number;
-    get lineNumber(): number;
-    get column(): number;
-}
-/**
- * @param message the error message
- * @param ast the AST object
- * @param startIndex the index at which the error starts
- * @param endIndex the index at which the error ends
- * @returns converted error object
- */
-export declare function createError(message: string, ast: ts.SourceFile, startIndex: number, endIndex?: number): TSError;
-export declare function nodeHasIllegalDecorators(node: ts.Node): node is ts.Node & {
-    illegalDecorators: ts.Node[];
-};
-/**
- * @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 declare function nodeIsPresent(node: ts.Node | undefined): node is ts.Node;
-export declare function getContainingFunction(node: ts.Node): ts.SignatureDeclaration | undefined;
-export declare function nodeCanBeDecorated(node: TSNode): boolean;
-export {};
-//# sourceMappingURL=node-utils.d.ts.map

package/_ts4.3/dist/parseSettings/ExpiringCache.d.ts

@@ -1,17 +0,0 @@
-import type { 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;
-    constructor(cacheDurationSeconds: CacheDurationSeconds);
-    set(key: TKey, value: TValue): this;
-    get(key: TKey): TValue | undefined;
-    clear(): void;
-}
-//# sourceMappingURL=ExpiringCache.d.ts.map

package/_ts4.3/dist/parseSettings/createParseSettings.d.ts

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

package/_ts4.3/dist/parseSettings/getProjectConfigFiles.d.ts

@@ -1,12 +0,0 @@
-import type { 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 | null | undefined): string[] | null;
-//# sourceMappingURL=getProjectConfigFiles.d.ts.map

package/_ts4.3/dist/parseSettings/index.d.ts

@@ -1,122 +0,0 @@
-import type * as ts from 'typescript';
-import type * as tsserverlibrary from 'typescript/lib/tsserverlibrary';
-import type { CanonicalPath } from '../create-program/shared';
-import type { TSESTree } from '../ts-estree';
-import type { CacheLike } from './ExpiringCache';
-type DebugModule = 'eslint' | 'typescript-eslint' | 'typescript';
-/**
- * Internal settings used by the parser to run on a file.
- */
-export interface MutableParseSettings {
-    /**
-     * Prevents the parser from throwing an error if it receives an invalid AST from TypeScript.
-     */
-    allowInvalidAST: boolean;
-    /**
-     * Code of the file being parsed, or raw source file containing it.
-     */
-    code: ts.SourceFile | string;
-    /**
-     * Full text of the file being parsed.
-     */
-    codeFullText: string;
-    /**
-     * Whether the `comment` parse option is enabled.
-     */
-    comment: boolean;
-    /**
-     * If the `comment` parse option is enabled, retrieved comments.
-     */
-    comments: TSESTree.Comment[];
-    /**
-     * @deprecated
-     * This is a legacy option that comes with severe performance penalties.
-     * Please do not use it.
-     */
-    DEPRECATED__createDefaultProgram: boolean;
-    /**
-     * Which debug areas should be logged.
-     */
-    debugLevel: Set<DebugModule>;
-    /**
-     * Whether to error if TypeScript reports a semantic or syntactic error diagnostic.
-     */
-    errorOnTypeScriptSyntacticAndSemanticIssues: boolean;
-    /**
-     * Whether to error if an unknown AST node type is encountered.
-     */
-    errorOnUnknownASTType: boolean;
-    /**
-     * Experimental: TypeScript server to power program creation.
-     */
-    EXPERIMENTAL_projectService: tsserverlibrary.server.ProjectService | undefined;
-    /**
-     * Whether TS should use the source files for referenced projects instead of the compiled .d.ts files.
-     *
-     * @remarks
-     * 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.
-     */
-    EXPERIMENTAL_useSourceOfProjectReferenceRedirect: boolean;
-    /**
-     * Any non-standard file extensions which will be parsed.
-     */
-    extraFileExtensions: string[];
-    /**
-     * Path of the file being parsed.
-     */
-    filePath: string;
-    /**
-     * Whether parsing of JSX is enabled.
-     *
-     * @remarks The applicable file extension is still required.
-     */
-    jsx: boolean;
-    /**
-     * Whether to add `loc` information to each node.
-     */
-    loc: boolean;
-    /**
-     * Log function, if not `console.log`.
-     */
-    log: (message: string) => void;
-    /**
-     * Whether two-way AST node maps are preserved during the AST conversion process.
-     */
-    preserveNodeMaps?: boolean;
-    /**
-     * One or more instances of TypeScript Program objects to be used for type information.
-     */
-    programs: Iterable<ts.Program> | null;
-    /**
-     * Normalized paths to provided project paths.
-     */
-    projects: readonly CanonicalPath[];
-    /**
-     * Whether to add the `range` property to AST nodes.
-     */
-    range: boolean;
-    /**
-     * Whether this is part of a single run, rather than a long-running process.
-     */
-    singleRun: boolean;
-    /**
-     * Whether deprecated AST properties should skip calling console.warn on accesses.
-     */
-    suppressDeprecatedPropertyWarnings: boolean;
-    /**
-     * If the `tokens` parse option is enabled, retrieved tokens.
-     */
-    tokens: TSESTree.Token[] | null;
-    /**
-     * Caches searches for TSConfigs from project directories.
-     */
-    tsconfigMatchCache: CacheLike<string, string>;
-    /**
-     * The absolute path to the root directory for all provided `project`s.
-     */
-    tsconfigRootDir: string;
-}
-export type ParseSettings = Readonly<MutableParseSettings>;
-export {};
-//# sourceMappingURL=index.d.ts.map

package/_ts4.3/dist/parseSettings/inferSingleRun.d.ts

@@ -1,15 +0,0 @@
-import type { TSESTreeOptions } from '../parser-options';
-/**
- * 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. We therefore use the following logic to figure out which
- * of these contexts applies to the current execution.
- *
- * @returns Whether this is part of a single run, rather than a long-running process.
- */
-export declare function inferSingleRun(options: TSESTreeOptions | undefined): boolean;
-//# sourceMappingURL=inferSingleRun.d.ts.map

package/_ts4.3/dist/parseSettings/resolveProjectList.d.ts

@@ -1,19 +0,0 @@
-import type { CanonicalPath } from '../create-program/shared';
-import type { TSESTreeOptions } from '../parser-options';
-export declare function clearGlobCache(): void;
-/**
- * Normalizes, sanitizes, resolves and filters the provided project paths
- */
-export declare function resolveProjectList(options: Readonly<{
-    cacheLifetime?: TSESTreeOptions['cacheLifetime'];
-    project: string[] | null;
-    projectFolderIgnoreList: TSESTreeOptions['projectFolderIgnoreList'];
-    singleRun: boolean;
-    tsconfigRootDir: string;
-}>): readonly CanonicalPath[];
-/**
- * Exported for testing purposes only
- * @internal
- */
-export declare function clearGlobResolutionCache(): void;
-//# sourceMappingURL=resolveProjectList.d.ts.map

package/_ts4.3/dist/parseSettings/warnAboutTSVersion.d.ts

@@ -1,3 +0,0 @@
-import type { ParseSettings } from './index';
-export declare function warnAboutTSVersion(parseSettings: ParseSettings): void;
-//# sourceMappingURL=warnAboutTSVersion.d.ts.map

package/_ts4.3/dist/parser-options.d.ts

@@ -1,192 +0,0 @@
-import type { CacheDurationSeconds, DebugLevel } from '@typescript-eslint/types';
-import type * as ts from 'typescript';
-import type { TSESTree, TSESTreeToTSNode, TSNode, TSToken } from './ts-estree';
-interface ParseOptions {
-    /**
-     * Prevents the parser from throwing an error if it receives an invalid AST from TypeScript.
-     * This case only usually occurs when attempting to lint invalid code.
-     */
-    allowInvalidAST?: boolean;
-    /**
-     * 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?: false | ((message: string) => void);
-    /**
-     * 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;
-    /**
-     * Whether deprecated AST properties should skip calling console.warn on accesses.
-     */
-    suppressDeprecatedPropertyWarnings?: 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.
-     *
-     * Whether to create a shared TypeScript server to power program creation.
-     *
-     * @see https://github.com/typescript-eslint/typescript-eslint/issues/6575
-     */
-    EXPERIMENTAL_useProjectService?: 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),
-     * or `true` to find the nearest tsconfig.json to the file.
-     * If this is provided, type information will be returned.
-     */
-    project?: string[] | string | true | null;
-    /**
-     * 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[] | null;
-    /**
-     * @deprecated - this flag will be removed in the next major.
-     * Do not rely on the behavior provided by this flag.
-     */
-    DEPRECATED__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;
-    /**
-     * Granular control of the expiry lifetime of our internal caches.
-     * You can specify the number of seconds as an integer number, or the string
-     * 'Infinity' if you never want the cache to expire.
-     *
-     * By default cache entries will be evicted after 30 seconds, or will persist
-     * indefinitely if `allowAutomaticSingleRunInference = true` AND the parser
-     * infers that it is a single run.
-     */
-    cacheLifetime?: {
-        /**
-         * Glob resolution for `parserOptions.project` values.
-         */
-        glob?: CacheDurationSeconds;
-    };
-}
-export 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 ParserServicesNodeMaps {
-    esTreeNodeToTSNodeMap: ParserWeakMapESTreeToTSNode;
-    tsNodeToESTreeNodeMap: ParserWeakMap<TSNode | TSToken, TSESTree.Node>;
-}
-export interface ParserServicesWithTypeInformation extends ParserServicesNodeMaps {
-    program: ts.Program;
-    getSymbolAtLocation: (node: TSESTree.Node) => ts.Symbol | undefined;
-    getTypeAtLocation: (node: TSESTree.Node) => ts.Type;
-}
-export interface ParserServicesWithoutTypeInformation extends ParserServicesNodeMaps {
-    program: null;
-}
-export type ParserServices = ParserServicesWithoutTypeInformation | ParserServicesWithTypeInformation;
-export {};
-//# sourceMappingURL=parser-options.d.ts.map

package/_ts4.3/dist/parser.d.ts

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