@sprucelabs/spruce-cli 18.4.0 → 19.1.0

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

@@ -1,102 +0,0 @@
-import * as ts from 'typescript';
-import { CanonicalPath } from '../create-program/shared';
-import { TSESTree } from '../ts-estree';
-type DebugModule = 'typescript-eslint' | 'eslint' | 'typescript';
-/**
- * Internal settings used by the parser to run on a file.
- */
-export interface MutableParseSettings {
-    /**
-     * Code of the file being parsed.
-     */
-    code: string;
-    /**
-     * Whether the `comment` parse option is enabled.
-     */
-    comment: boolean;
-    /**
-     * If the `comment` parse option is enabled, retrieved comments.
-     */
-    comments: TSESTree.Comment[];
-    /**
-     * Whether to create a TypeScript program if one is not provided.
-     */
-    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;
-    /**
-     * 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;
-    /**
-     * Path for a module resolver to use for the compiler host's `resolveModuleNames`.
-     */
-    moduleResolver: string;
-    /**
-     * 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: null | Iterable<ts.Program>;
-    /**
-     * Normalized paths to provided project paths.
-     */
-    projects: 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;
-    /**
-     * If the `tokens` parse option is enabled, retrieved tokens.
-     */
-    tokens: null | TSESTree.Token[];
-    /**
-     * 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/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/parseSettings/inferSingleRun.d.ts

@@ -1,15 +0,0 @@
-import { 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/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/parseSettings/warnAboutTSVersion.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,20 +0,0 @@
-import * as ts from 'typescript';
-declare module 'typescript' {
-    interface NamedTupleMember extends ts.Node {
-    }
-    interface TemplateLiteralTypeNode extends ts.Node {
-    }
-    interface PrivateIdentifier extends ts.Node {
-    }
-    interface ClassStaticBlockDeclaration extends ts.Node {
-    }
-    interface AssertClause extends ts.Node {
-    }
-    interface AssertEntry extends ts.Node {
-    }
-    interface SatisfiesExpression extends ts.Node {
-    }
-}
-export type TSToken = ts.Token<ts.SyntaxKind>;
-export type TSNode = ts.AssertClause | ts.AssertEntry | ts.Modifier | ts.Identifier | ts.PrivateIdentifier | ts.QualifiedName | ts.ComputedPropertyName | ts.Decorator | ts.TypeParameterDeclaration | ts.CallSignatureDeclaration | ts.ConstructSignatureDeclaration | ts.VariableDeclaration | ts.VariableDeclarationList | ts.ParameterDeclaration | ts.BindingElement | ts.PropertySignature | ts.PropertyDeclaration | ts.PropertyAssignment | ts.ShorthandPropertyAssignment | ts.SpreadAssignment | ts.ObjectBindingPattern | ts.ArrayBindingPattern | ts.FunctionDeclaration | ts.MethodSignature | ts.MethodDeclaration | ts.ConstructorDeclaration | ts.SemicolonClassElement | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.IndexSignatureDeclaration | ts.KeywordTypeNode | ts.ImportTypeNode | ts.ThisTypeNode | ts.ClassStaticBlockDeclaration | ts.ConstructorTypeNode | ts.FunctionTypeNode | ts.TypeReferenceNode | ts.TypePredicateNode | ts.TypeQueryNode | ts.TypeLiteralNode | ts.ArrayTypeNode | ts.NamedTupleMember | ts.TupleTypeNode | ts.OptionalTypeNode | ts.RestTypeNode | ts.UnionTypeNode | ts.IntersectionTypeNode | ts.ConditionalTypeNode | ts.InferTypeNode | ts.ParenthesizedTypeNode | ts.TypeOperatorNode | ts.IndexedAccessTypeNode | ts.MappedTypeNode | ts.LiteralTypeNode | ts.StringLiteral | ts.OmittedExpression | ts.PartiallyEmittedExpression | ts.PrefixUnaryExpression | ts.PostfixUnaryExpression | ts.NullLiteral | ts.BooleanLiteral | ts.ThisExpression | ts.SuperExpression | ts.ImportExpression | ts.DeleteExpression | ts.TypeOfExpression | ts.VoidExpression | ts.AwaitExpression | ts.YieldExpression | ts.SyntheticExpression | ts.BinaryExpression | ts.ConditionalExpression | ts.FunctionExpression | ts.ArrowFunction | ts.RegularExpressionLiteral | ts.NoSubstitutionTemplateLiteral | ts.NumericLiteral | ts.BigIntLiteral | ts.TemplateHead | ts.TemplateMiddle | ts.TemplateTail | ts.TemplateExpression | ts.TemplateSpan | ts.ParenthesizedExpression | ts.ArrayLiteralExpression | ts.SpreadElement | ts.ObjectLiteralExpression | ts.PropertyAccessExpression | ts.ElementAccessExpression | ts.CallExpression | ts.ExpressionWithTypeArguments | ts.NewExpression | ts.TaggedTemplateExpression | ts.AsExpression | ts.TypeAssertion | ts.NonNullExpression | ts.MetaProperty | ts.JsxElement | ts.JsxOpeningElement | ts.JsxSelfClosingElement | ts.JsxFragment | ts.JsxOpeningFragment | ts.JsxClosingFragment | ts.JsxAttribute | ts.JsxSpreadAttribute | ts.JsxClosingElement | ts.JsxExpression | ts.JsxText | ts.NotEmittedStatement | ts.CommaListExpression | ts.EmptyStatement | ts.DebuggerStatement | ts.MissingDeclaration | ts.Block | ts.VariableStatement | ts.ExpressionStatement | ts.IfStatement | ts.DoStatement | ts.WhileStatement | ts.ForStatement | ts.ForInStatement | ts.ForOfStatement | ts.BreakStatement | ts.ContinueStatement | ts.ReturnStatement | ts.WithStatement | ts.SwitchStatement | ts.CaseBlock | ts.CaseClause | ts.DefaultClause | ts.LabeledStatement | ts.ThrowStatement | ts.TryStatement | ts.CatchClause | ts.ClassDeclaration | ts.ClassExpression | ts.InterfaceDeclaration | ts.HeritageClause | ts.TypeAliasDeclaration | ts.EnumMember | ts.EnumDeclaration | ts.ModuleDeclaration | ts.ModuleBlock | ts.ImportEqualsDeclaration | ts.ExternalModuleReference | ts.ImportDeclaration | ts.ImportClause | ts.NamespaceImport | ts.NamespaceExportDeclaration | ts.ExportDeclaration | ts.NamedImports | ts.NamedExports | ts.ImportSpecifier | ts.ExportSpecifier | ts.ExportAssignment | ts.SourceFile | ts.Bundle | ts.InputFiles | ts.UnparsedSource | ts.JsonMinusNumericLiteral | ts.TemplateLiteralTypeNode | ts.SatisfiesExpression | ts.JSDoc | ts.JSDocTypeExpression | ts.JSDocUnknownTag | ts.JSDocAugmentsTag | ts.JSDocClassTag | ts.JSDocEnumTag | ts.JSDocThisTag | ts.JSDocTemplateTag | ts.JSDocReturnTag | ts.JSDocTypeTag | ts.JSDocTypedefTag | ts.JSDocCallbackTag | ts.JSDocSignature | ts.JSDocPropertyTag | ts.JSDocParameterTag | ts.JSDocTypeLiteral | ts.JSDocFunctionType | ts.JSDocAllType | ts.JSDocUnknownType | ts.JSDocNullableType | ts.JSDocNonNullableType | ts.JSDocOptionalType | ts.JSDocVariadicType | ts.JSDocAuthorTag;
-//# sourceMappingURL=ts-nodes.d.ts.map

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

@@ -1,3 +0,0 @@
-declare const typescriptVersionIsAtLeast: Record<"3.7" | "3.8" | "3.9" | "4.0" | "4.1" | "4.2" | "4.3" | "4.4" | "4.5" | "4.6" | "4.7" | "4.8", boolean>;
-export { typescriptVersionIsAtLeast };
-//# sourceMappingURL=version-check.d.ts.map

package/node_modules/@typescript-eslint/visitor-keys/_ts3.4/dist/get-keys.d.ts

@@ -1,4 +0,0 @@
-import { TSESTree } from '@typescript-eslint/types';
-declare const getKeys: (node: TSESTree.Node) => ReadonlyArray<string>;
-export { getKeys };
-//# sourceMappingURL=get-keys.d.ts.map

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

@@ -1,3 +0,0 @@
-export { getKeys } from './get-keys';
-export { visitorKeys, VisitorKeys } from './visitor-keys';
-//# sourceMappingURL=index.d.ts.map

package/node_modules/@typescript-eslint/visitor-keys/_ts3.4/dist/visitor-keys.d.ts

@@ -1,6 +0,0 @@
-interface VisitorKeys {
-    readonly [type: string]: readonly string[] | undefined;
-}
-declare const visitorKeys: VisitorKeys;
-export { visitorKeys, VisitorKeys };
-//# sourceMappingURL=visitor-keys.d.ts.map

package/src/__tests__/behavioral/events/EverythingInstalledInstaller.ts

@@ -1,46 +0,0 @@
-import { FeatureDependency } from '../../../features/AbstractFeature'
-import FeatureInstaller from '../../../features/FeatureInstaller'
-import {
-	FeatureCode,
-	FeatureInstallResponse,
-	FeatureMap,
-} from '../../../features/features.types'
-
-export default class EverythingInstalledInstaller implements FeatureInstaller {
-	private featureMap: Partial<FeatureMap> = {}
-
-	public mapFeature<C extends keyof FeatureMap>(
-		code: C,
-		feature: FeatureMap[C]
-	): void {
-		this.featureMap[code] = feature
-	}
-
-	public async install(): Promise<FeatureInstallResponse> {
-		return {}
-	}
-	public async getInstalledFeatures() {
-		return Object.values(this.featureMap)
-	}
-	public getFeatureDependencies(): FeatureDependency[] {
-		return []
-	}
-	public getAllCodes(): FeatureCode[] {
-		return Object.keys(this.featureMap) as FeatureCode[]
-	}
-
-	public async isInstalled(_code: keyof FeatureMap): Promise<boolean> {
-		return true
-	}
-	public markAsSkippedThisRun(_code: keyof FeatureMap): void {}
-	public markAsPermanentlySkipped(_code: keyof FeatureMap): void {}
-	public isMarkedAsSkipped(_code: keyof FeatureMap): boolean {
-		return false
-	}
-	public getFeature<C extends keyof FeatureMap>(code: C): FeatureMap[C] {
-		return this.featureMap[code]!
-	}
-	public async areInstalled(_codes: FeatureCode[]): Promise<boolean> {
-		return true
-	}
-}