xo 0.53.1 → 0.54.0

package/node_modules/@typescript-eslint/typescript-estree/LICENSE

@@ -8,11 +8,11 @@ Copyright JS Foundation and other contributors, https://js.foundation
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
 
-  * Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-  * Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer in the
-    documentation and/or other materials provided with the distribution.
+- Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

package/node_modules/@typescript-eslint/typescript-estree/README.md

@@ -1,383 +1,10 @@
-<h1 align="center">TypeScript ESTree</h1>
+# `@typescript-eslint/typescript-estree`
 
-<p align="center">A parser that converts TypeScript source code into an <a href="https://github.com/estree/estree">ESTree</a>-compatible form</p>
-
-<p align="center">
-    <img src="https://github.com/typescript-eslint/typescript-eslint/workflows/CI/badge.svg" alt="CI" />
-    <a href="https://www.npmjs.com/package/@typescript-eslint/typescript-estree"><img src="https://img.shields.io/npm/v/@typescript-eslint/typescript-estree.svg?style=flat-square" alt="NPM Version" /></a>
-    <a href="https://www.npmjs.com/package/@typescript-eslint/typescript-estree"><img src="https://img.shields.io/npm/dm/@typescript-eslint/typescript-estree.svg?style=flat-square" alt="NPM Downloads" /></a>
-</p>
-
-## Getting Started
-
-**[You can find our Getting Started docs here](https://typescript-eslint.io/docs)**
-
-## About
-
-This parser is somewhat generic and robust, and could be used to power any use-case which requires taking TypeScript source code and producing an ESTree-compatible AST.
-
-In fact, it is already used within these hyper-popular open-source projects to power their TypeScript support:
-
-- [ESLint](https://eslint.org), the pluggable linting utility for JavaScript and JSX
-- [Prettier](https://prettier.io), an opinionated code formatter
-
-## Installation
-
-```sh
-yarn add -D @typescript-eslint/typescript-estree
-```
-
-## API
-
-### Parsing
-
-#### `parse(code, options)`
-
-Parses the given string of code with the options provided and returns an ESTree-compatible AST.
-
-```ts
-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?: boolean | ('typescript-eslint' | 'eslint' | 'typescript')[];
-
-  /**
-   * 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;
-
-  /*
-   * Allows overriding of function used for logging.
-   * When value is `false`, no logging will occur.
-   * When value is not provided, `console.log()` will be used.
-   */
-  loggerFn?: Function | 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;
-}
-
-const PARSE_DEFAULT_OPTIONS: ParseOptions = {
-  comment: false,
-  errorOnUnknownASTType: false,
-  filePath: 'estree.ts', // or 'estree.tsx', if you pass jsx: true
-  jsx: false,
-  loc: false,
-  loggerFn: undefined,
-  range: false,
-  tokens: false,
-};
-
-declare function parse(
-  code: string,
-  options: ParseOptions = PARSE_DEFAULT_OPTIONS,
-): TSESTree.Program;
-```
-
-Example usage:
-
-```js
-import { parse } from '@typescript-eslint/typescript-estree';
-
-const code = `const hello: string = 'world';`;
-const ast = parse(code, {
-  loc: true,
-  range: true,
-});
-```
-
-#### `parseAndGenerateServices(code, options)`
-
-Parses the given string of code with the options provided and returns an ESTree-compatible AST. Accepts additional options which can be used to generate type information along with the AST.
-
-```ts
-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?: 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;
-
-  /**
-   * Path to a file exporting a custom ModuleResolver.
-   */
-  moduleResolver?: string;
-}
-
-interface ParserServices {
-  program: ts.Program;
-  esTreeNodeToTSNodeMap: WeakMap<TSESTree.Node, ts.Node | ts.Token>;
-  tsNodeToESTreeNodeMap: WeakMap<ts.Node | ts.Token, TSESTree.Node>;
-  hasFullTypeInformation: boolean;
-}
-
-interface ParseAndGenerateServicesResult<T extends TSESTreeOptions> {
-  ast: TSESTree.Program;
-  services: ParserServices;
-}
-
-const PARSE_AND_GENERATE_SERVICES_DEFAULT_OPTIONS: ParseOptions = {
-  ...PARSE_DEFAULT_OPTIONS,
-  errorOnTypeScriptSyntacticAndSemanticIssues: false,
-  extraFileExtensions: [],
-  preserveNodeMaps: false, // or true, if you do not set this, but pass `project`
-  project: undefined,
-  projectFolderIgnoreList: ['/node_modules/'],
-  tsconfigRootDir: process.cwd(),
-};
-
-declare function parseAndGenerateServices(
-  code: string,
-  options: ParseOptions = PARSE_DEFAULT_OPTIONS,
-): ParseAndGenerateServicesResult;
-```
-
-Example usage:
-
-```js
-import { parseAndGenerateServices } from '@typescript-eslint/typescript-estree';
-
-const code = `const hello: string = 'world';`;
-const { ast, services } = parseAndGenerateServices(code, {
-  filePath: '/some/path/to/file/foo.ts',
-  loc: true,
-  project: './tsconfig.json',
-  range: true,
-});
-```
-
-#### `parseWithNodeMaps(code, options)`
-
-Parses the given string of code with the options provided and returns both the ESTree-compatible AST as well as the node maps.
-This allows you to work with both ASTs without the overhead of types that may come with `parseAndGenerateServices`.
-
-```ts
-interface ParseWithNodeMapsResult<T extends TSESTreeOptions> {
-  ast: TSESTree.Program;
-  esTreeNodeToTSNodeMap: ParserServices['esTreeNodeToTSNodeMap'];
-  tsNodeToESTreeNodeMap: ParserServices['tsNodeToESTreeNodeMap'];
-}
-
-declare function parseWithNodeMaps(
-  code: string,
-  options: ParseOptions = PARSE_DEFAULT_OPTIONS,
-): ParseWithNodeMapsResult;
-```
-
-Example usage:
-
-```js
-import { parseWithNodeMaps } from '@typescript-eslint/typescript-estree';
-
-const code = `const hello: string = 'world';`;
-const { ast, esTreeNodeToTSNodeMap, tsNodeToESTreeNodeMap } = parseWithNodeMaps(
-  code,
-  {
-    loc: true,
-    range: true,
-  },
-);
-```
-
-### `TSESTree`, `AST_NODE_TYPES` and `AST_TOKEN_TYPES`
-
-Types for the AST produced by the parse functions.
-
-- `TSESTree` is a namespace which contains object types representing all of the AST Nodes produced by the parser.
-- `AST_NODE_TYPES` is an enum which provides the values for every single AST node's `type` property.
-- `AST_TOKEN_TYPES` is an enum which provides the values for every single AST token's `type` property.
-
-### Utilities
-
-#### `createProgram(configFile, projectDirectory)`
-
-This serves as a utility method for users of the `ParseOptions.programs` feature to create a TypeScript program instance from a config file.
-
-```ts
-declare function createProgram(
-  configFile: string,
-  projectDirectory: string = process.cwd(),
-): import('typescript').Program;
-```
-
-Example usage:
-
-```js
-const tsESTree = require('@typescript-eslint/typescript-estree');
-
-const program = tsESTree.createProgram('tsconfig.json');
-const code = `const hello: string = 'world';`;
-const { ast, services } = parseAndGenerateServices(code, {
-  filePath: '/some/path/to/file/foo.ts',
-  loc: true,
-  program,
-  range: true,
-});
-```
-
-## Supported TypeScript Version
-
-See the [Supported TypeScript Version](../../README.md#supported-typescript-version) section in the project root.
-
-If you use a non-supported version of TypeScript, the parser will log a warning to the console.
-
-**Please ensure that you are using a supported version before submitting any issues/bug reports.**
-
-## Reporting Issues
-
-Please check the current list of open and known issues and ensure the issue has not been reported before. When creating a new issue provide as much information about your environment as possible. This includes:
-
-- TypeScript version
-- The `typescript-estree` version
-
-## AST Alignment Tests
-
-A couple of years after work on this parser began, the TypeScript Team at Microsoft began [officially supporting TypeScript parsing via Babel](https://blogs.msdn.microsoft.com/typescript/2018/08/27/typescript-and-babel-7/).
-
-I work closely with the TypeScript Team and we are gradually aligning the AST of this project with the one produced by Babel's parser. To that end, I have created a full test harness to compare the ASTs of the two projects which runs on every PR, please see [the code](https://github.com/typescript-eslint/typescript-eslint/tree/main/packages/typescript-estree/tests/ast-alignment) for more details.
-
-## Debugging
-
-If you encounter a bug with the parser that you want to investigate, you can turn on the debug logging via setting the environment variable: `DEBUG=typescript-eslint:*`.
-I.e. in this repo you can run: `DEBUG=typescript-eslint:* yarn lint`.
-
-## License
-
-TypeScript ESTree inherits from the the original TypeScript ESLint Parser license, as the majority of the work began there. It is licensed under a permissive BSD 2-clause license.
+[![NPM Version](https://img.shields.io/npm/v/@typescript-eslint/typescript-estree.svg?style=flat-square)](https://www.npmjs.com/package/@typescript-eslint/utils)
+[![NPM Downloads](https://img.shields.io/npm/dm/@typescript-eslint/typescript-estree.svg?style=flat-square)](https://www.npmjs.com/package/@typescript-eslint/utils)
 
 ## Contributing
 
-[See the contributing guide here](../../CONTRIBUTING.md)
+👉 See **https://typescript-eslint.io/architecture/typescript-estree** for documentation on this package.
+
+> See https://typescript-eslint.io for general documentation on typescript-eslint, the tooling that allows you to run ESLint and Prettier on TypeScript code.

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

@@ -0,0 +1,10 @@
+/**
+ * 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/create-program/describeFilePath.d.ts

@@ -0,0 +1,2 @@
+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/{createWatchProgram.d.ts → getWatchProgramsForProjects.d.ts}

@@ -10,7 +10,6 @@ declare function clearWatchCaches(): void;
  * @param parseSettings Internal settings for parsing the file
  * @returns The programs corresponding to the supplied tsconfig paths
  */
-declare function getProgramsForProjects(parseSettings: ParseSettings): ts.Program[];
-declare function createWatchProgram(tsconfigPath: string, parseSettings: ParseSettings): ts.WatchOfConfigFile<ts.BuilderProgram>;
-export { clearWatchCaches, createWatchProgram, getProgramsForProjects };
-//# sourceMappingURL=createWatchProgram.d.ts.map
+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

@@ -11,7 +11,7 @@ interface ASTAndProgram {
  */
 declare const CORE_COMPILER_OPTIONS: ts.CompilerOptions;
 declare function createDefaultCompilerOptionsFromExtra(parseSettings: ParseSettings): ts.CompilerOptions;
-declare type CanonicalPath = string & {
+type CanonicalPath = string & {
     __brand: unknown;
 };
 declare function getCanonicalFileName(filePath: string): CanonicalPath;
@@ -19,5 +19,11 @@ 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;
-export { ASTAndProgram, CORE_COMPILER_OPTIONS, canonicalDirname, CanonicalPath, createDefaultCompilerOptionsFromExtra, ensureAbsolutePath, getCanonicalFileName, getAstFromProgram, getModuleResolver, };
+/**
+ * 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/index.d.ts

@@ -1,12 +1,12 @@
-export { AST, parse, parseAndGenerateServices, parseWithNodeMaps, ParseAndGenerateServicesResult, ParseWithNodeMapsResult, clearProgramCache, } from './parser';
+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 { clearWatchCaches as clearCaches } from './create-program/createWatchProgram';
 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/parseSettings/ExpiringCache.d.ts

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

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

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

@@ -1,7 +1,8 @@
 import * as ts from 'typescript';
 import { CanonicalPath } from '../create-program/shared';
 import { TSESTree } from '../ts-estree';
-declare type DebugModule = 'typescript-eslint' | 'eslint' | 'typescript';
+import { CacheLike } from './ExpiringCache';
+type DebugModule = 'typescript-eslint' | 'eslint' | 'typescript';
 /**
  * Internal settings used by the parser to run on a file.
  */
@@ -79,7 +80,7 @@ export interface MutableParseSettings {
     /**
      * Normalized paths to provided project paths.
      */
-    projects: CanonicalPath[];
+    projects: readonly CanonicalPath[];
     /**
      * Whether to add the `range` property to AST nodes.
      */
@@ -92,11 +93,15 @@ export interface MutableParseSettings {
      * If the `tokens` parse option is enabled, retrieved tokens.
      */
     tokens: null | TSESTree.Token[];
+    /**
+     * 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 declare type ParseSettings = Readonly<MutableParseSettings>;
+export type ParseSettings = Readonly<MutableParseSettings>;
 export {};
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,19 @@
+import { CanonicalPath } from '../create-program/shared';
+import { 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: TSESTreeOptions['project'];
+    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/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/parser-options.d.ts

@@ -1,4 +1,4 @@
-import { DebugLevel } from '@typescript-eslint/types';
+import { CacheDurationSeconds, DebugLevel } from '@typescript-eslint/types';
 import * as ts from 'typescript';
 import { TSESTree, TSESTreeToTSNode, TSNode, TSToken } from './ts-estree';
 interface ParseOptions {
@@ -92,10 +92,11 @@ interface ParseAndGenerateServicesOptions extends ParseOptions {
      */
     preserveNodeMaps?: boolean;
     /**
-     * Absolute (or relative to `tsconfigRootDir`) paths to the tsconfig(s).
+     * 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[];
+    project?: string | string[] | true;
     /**
      * 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.
@@ -137,9 +138,27 @@ interface ParseAndGenerateServicesOptions extends ParseOptions {
      * 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;
+    };
+    /**
+     * Path to a file exporting a custom `ModuleResolver`.
+     */
     moduleResolver?: string;
 }
-export declare type TSESTreeOptions = ParseAndGenerateServicesOptions;
+export type TSESTreeOptions = ParseAndGenerateServicesOptions;
 export interface ParserWeakMap<TKey, TValueBase> {
     get<TValue extends TValueBase>(key: TKey): TValue;
     has(key: unknown): boolean;

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

@@ -3,7 +3,7 @@ import { TSESTree } from './ts-estree';
 declare function clearProgramCache(): void;
 interface EmptyObject {
 }
-declare type AST<T extends TSESTreeOptions> = TSESTree.Program & (T['tokens'] extends true ? {
+type AST<T extends TSESTreeOptions> = TSESTree.Program & (T['tokens'] extends true ? {
     tokens: TSESTree.Token[];
 } : EmptyObject) & (T['comment'] extends true ? {
     comments: TSESTree.Comment[];

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

@@ -1,5 +1,5 @@
 import { TSESTree } from './ts-estree';
-declare type SimpleTraverseOptions = {
+type SimpleTraverseOptions = {
     enter: (node: TSESTree.Node, parent: TSESTree.Node | undefined) => void;
 } | {
     [key: string]: (node: TSESTree.Node, parent: TSESTree.Node | undefined) => void;

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

@@ -2,6 +2,7 @@ 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.AccessorProperty]: ts.PropertyDeclaration;
     [AST_NODE_TYPES.ArrayExpression]: ts.ArrayLiteralExpression;
     [AST_NODE_TYPES.ArrayPattern]: ts.ArrayLiteralExpression | ts.ArrayBindingPattern;
     [AST_NODE_TYPES.ArrowFunctionExpression]: ts.ArrowFunction;
@@ -83,6 +84,7 @@ export interface EstreeToTsNodeTypes {
     [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.TSAbstractAccessorProperty]: ts.PropertyDeclaration;
     [AST_NODE_TYPES.TSAbstractPropertyDefinition]: ts.PropertyDeclaration;
     [AST_NODE_TYPES.TSAbstractMethodDefinition]: ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.MethodDeclaration | ts.ConstructorDeclaration;
     [AST_NODE_TYPES.TSArrayType]: ts.ArrayTypeNode;
@@ -108,6 +110,7 @@ export interface EstreeToTsNodeTypes {
     [AST_NODE_TYPES.TSInterfaceHeritage]: ts.ExpressionWithTypeArguments;
     [AST_NODE_TYPES.TSIntersectionType]: ts.IntersectionTypeNode;
     [AST_NODE_TYPES.TSInstantiationExpression]: ts.ExpressionWithTypeArguments;
+    [AST_NODE_TYPES.TSSatisfiesExpression]: ts.SatisfiesExpression;
     [AST_NODE_TYPES.TSLiteralType]: ts.LiteralTypeNode;
     [AST_NODE_TYPES.TSMappedType]: ts.MappedTypeNode;
     [AST_NODE_TYPES.TSMethodSignature]: ts.MethodSignature | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration;
@@ -171,5 +174,5 @@ export interface EstreeToTsNodeTypes {
  * 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']]>;
+export 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