@sprucelabs/spruce-cli 17.1.31 → 17.1.34

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

@@ -1,383 +0,0 @@
-<h1 align="center">TypeScript ESTree</h1>
-
-<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/linting)**
-
-## 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.
-
-## Contributing
-
-[See the contributing guide here](../../CONTRIBUTING.md)

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 { Extra } from './parser-options';
-import { TSESTree } from './ts-estree';
-export declare function astConverter(ast: SourceFile, extra: Extra, shouldPreserveNodeMaps: boolean): {
-    estree: TSESTree.Program;
-    astMaps: ASTMaps;
-};
-//# sourceMappingURL=ast-converter.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,157 +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.
-     * @param result
-     * @param modifiers original ts.Nodes from the node.modifiers array
-     * @returns the current result object will be mutated
-     * @deprecated This method adds not standardized `modifiers` property in nodes
-     */
-    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,12 +0,0 @@
-import { Extra } from '../parser-options';
-import { ASTAndProgram } from './shared';
-/**
- * @param code The code of the file being linted
- * @param extra The config object
- * @param extra.tsconfigRootDir The root directory for relative tsconfig paths
- * @param extra.projects Provided tsconfig paths
- * @returns If found, returns the source file corresponding to the code and the containing program
- */
-declare function createDefaultProgram(code: string, extra: Extra): 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 { Extra } from '../parser-options';
-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(code: string, extra: Extra): ASTAndProgram;
-export { createIsolatedProgram };
-//# sourceMappingURL=createIsolatedProgram.d.ts.map

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

@@ -1,11 +0,0 @@
-import { Extra } from '../parser-options';
-import { ASTAndProgram } from './shared';
-/**
- * @param code The code of the file being linted
- * @param createDefaultProgram True if the default program should be created
- * @param extra The config object
- * @returns If found, returns the source file corresponding to the code and the containing program
- */
-declare function createProjectProgram(code: string, createDefaultProgram: boolean, extra: Extra): 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 { Extra } from '../parser-options';
-declare function createSourceFile(code: string, extra: Extra): ts.SourceFile;
-export { createSourceFile };
-//# sourceMappingURL=createSourceFile.d.ts.map

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

@@ -1,19 +0,0 @@
-import * as ts from 'typescript';
-import { Extra } from '../parser-options';
-/**
- * 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 code The code being linted
- * @param filePathIn The path of the file being parsed
- * @param extra.tsconfigRootDir The root directory for relative tsconfig paths
- * @param extra.projects Provided tsconfig paths
- * @returns The programs corresponding to the supplied tsconfig paths
- */
-declare function getProgramsForProjects(code: string, filePathIn: string, extra: Extra): ts.Program[];
-declare function createWatchProgram(tsconfigPath: string, extra: Extra): ts.WatchOfConfigFile<ts.BuilderProgram>;
-export { clearWatchCaches, createWatchProgram, getProgramsForProjects };
-//# sourceMappingURL=createWatchProgram.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/shared.d.ts

@@ -1,22 +0,0 @@
-import * as ts from 'typescript';
-import { Program } from 'typescript';
-import { Extra, ModuleResolver } from '../parser-options';
-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(extra: Extra): ts.CompilerOptions;
-declare type CanonicalPath = string & {
-    __brand: unknown;
-};
-declare function getCanonicalFileName(filePath: string): CanonicalPath;
-declare function ensureAbsolutePath(p: string, extra: Extra): string;
-declare function canonicalDirname(p: CanonicalPath): CanonicalPath;
-declare function getAstFromProgram(currentProgram: Program, extra: Extra): ASTAndProgram | undefined;
-declare function getModuleResolver(moduleResolverPath: string): ModuleResolver;
-export { ASTAndProgram, CORE_COMPILER_OPTIONS, canonicalDirname, CanonicalPath, createDefaultCompilerOptionsFromExtra, ensureAbsolutePath, getCanonicalFileName, getAstFromProgram, getModuleResolver, };
-//# sourceMappingURL=shared.d.ts.map