robojerk/codeql-action

Update checked-in dependencies

Browse source
This commit is contained in:
github-actions[bot] 2023-08-21 17:52:18 +00:00
parent 67f7ac2add
commit 02c45745e3
174 changed files with 2781 additions and 5722 deletions
Download patch file Download diff file Expand all files Collapse all files

16
node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-imports.js generated vendored
View file

@ -82,14 +82,14 @@ exports.default = util.createRule({
ImportDeclaration(node) {
const source = node.source.value;
// sourceImports is the object containing all the specifics for a particular import source, type or value
const sourceImports = sourceImportsMap[source] ??
(sourceImportsMap[source] = {
source,
reportValueImports: [],
typeOnlyNamedImport: null,
valueOnlyNamedImport: null,
valueImport: null, // if only value imports
});
sourceImportsMap[source] ??= {
source,
reportValueImports: [],
typeOnlyNamedImport: null,
valueOnlyNamedImport: null,
valueImport: null, // if only value imports
};
const sourceImports = sourceImportsMap[source];
if (node.importKind === 'type') {
if (!sourceImports.typeOnlyNamedImport &&
node.specifiers.every(specifier => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier)) {

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-imports.js.map generated vendored
View file

File diff suppressed because one or more lines are too long

11
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-condition.js generated vendored
View file

@ -34,11 +34,20 @@ const isTruthyLiteral = (type) => tsutils.isTrueLiteralType(type) ||
(type.isLiteral() && !!type.value);
const isPossiblyFalsy = (type) => tsutils
.unionTypeParts(type)
// Intersections like `string & {}` can also be possibly falsy,
// requiring us to look into the intersection.
.flatMap(type => tsutils.intersectionTypeParts(type))
// PossiblyFalsy flag includes literal values, so exclude ones that
// are definitely truthy
.filter(t => !isTruthyLiteral(t))
.some(type => (0, util_1.isTypeFlagSet)(type, ts.TypeFlags.PossiblyFalsy));
const isPossiblyTruthy = (type) => tsutils.unionTypeParts(type).some(type => !tsutils.isFalsyType(type));
const isPossiblyTruthy = (type) => tsutils
.unionTypeParts(type)
.map(type => tsutils.intersectionTypeParts(type))
.some(intersectionParts =>
// It is possible to define intersections that are always falsy,
// like `"" & { __brand: string }`.
intersectionParts.every(type => !tsutils.isFalsyType(type)));
// Nullish utilities
const nullishFlag = ts.TypeFlags.Undefined | ts.TypeFlags.Null;
const isNullishType = (type) => (0, util_1.isTypeFlagSet)(type, nullishFlag);

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-condition.js.map generated vendored
View file

File diff suppressed because one or more lines are too long

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/unified-signatures.js generated vendored
View file

@ -329,7 +329,7 @@ exports.default = util.createRule({
currentScope = scopes.pop();
}
function addOverload(signature, key, containingNode) {
key = key ?? getOverloadKey(signature);
key ??= getOverloadKey(signature);
if (currentScope &&
(containingNode || signature).parent === currentScope.parent) {
const overloads = currentScope.overloads.get(key);

2
node_modules/@typescript-eslint/eslint-plugin/dist/rules/unified-signatures.js.map generated vendored
View file

File diff suppressed because one or more lines are too long

2
node_modules/@typescript-eslint/eslint-plugin/docs/rules/member-ordering.md generated vendored
View file

@ -814,7 +814,7 @@ interface Foo {
#### Sorting Alphabetically Case Insensitive Within Member Groups
This config specifies that within each `memberTypes` group, members are in an alphabetic case-sensitive order.
This config specifies that within each `memberTypes` group, members are in an alphabetic case-insensitive order.
You can copy and paste the default order from [Default Configuration](#default-configuration).
```jsonc

24
node_modules/@typescript-eslint/eslint-plugin/package.json generated vendored
View file

@ -1,6 +1,6 @@
{
"name": "@typescript-eslint/eslint-plugin",
"version": "6.4.0",
"version": "6.4.1",
"description": "TypeScript plugin for ESLint",
"files": [
"dist",
@ -57,10 +57,10 @@
},
"dependencies": {
"@eslint-community/regexpp": "^4.5.1",
"@typescript-eslint/scope-manager": "6.4.0",
"@typescript-eslint/type-utils": "6.4.0",
"@typescript-eslint/utils": "6.4.0",
"@typescript-eslint/visitor-keys": "6.4.0",
"@typescript-eslint/scope-manager": "6.4.1",
"@typescript-eslint/type-utils": "6.4.1",
"@typescript-eslint/utils": "6.4.1",
"@typescript-eslint/visitor-keys": "6.4.1",
"debug": "^4.3.4",
"graphemer": "^1.4.0",
"ignore": "^5.2.4",
@ -73,17 +73,21 @@
"@types/marked": "*",
"@types/natural-compare": "*",
"@types/prettier": "*",
"@typescript-eslint/rule-schema-to-typescript-types": "6.4.0",
"@typescript-eslint/rule-tester": "6.4.0",
"@typescript-eslint/rule-schema-to-typescript-types": "6.4.1",
"@typescript-eslint/rule-tester": "6.4.1",
"ajv": "^6.12.6",
"chalk": "^5.3.0",
"cross-fetch": "*",
"jest-specific-snapshot": "*",
"grapheme-splitter": "^1.0.4",
"jest": "29.6.2",
"jest-specific-snapshot": "^8.0.0",
"json-schema": "*",
"markdown-table": "^3.0.3",
"marked": "^5.1.1",
"prettier": "*",
"prettier": "^2.8.4",
"rimraf": "*",
"title-case": "^3.0.3",
"tsx": "*",
"typescript": "*"
},
"peerDependencies": {
@ -99,5 +103,5 @@
"type": "opencollective",
"url": "https://opencollective.com/typescript-eslint"
},
"gitHead": "14bea42e4864c72d28f502e0d15e675fe8bd729a"
"gitHead": "ef1367eeed112fd6bbb94e0c9bd56d7e167a1a59"
}

8
node_modules/@typescript-eslint/parser/_ts4.3/dist/index.d.ts generated vendored
View file

@ -1,8 +0,0 @@
export { parse, parseForESLint, ParserOptions } from './parser';
export { ParserServices, ParserServicesWithTypeInformation, ParserServicesWithoutTypeInformation, clearCaches, createProgram, } from '@typescript-eslint/typescript-estree';
export declare const version: string;
export declare const meta: {
name: string;
version: string;
};
//# sourceMappingURL=index.d.ts.map

23
node_modules/@typescript-eslint/parser/_ts4.3/dist/parser.d.ts generated vendored
View file

@ -1,23 +0,0 @@
import type { ScopeManager } from '@typescript-eslint/scope-manager';
import type { TSESTree } from '@typescript-eslint/types';
import { ParserOptions } from '@typescript-eslint/types';
import type { ParserServices } from '@typescript-eslint/typescript-estree';
import { visitorKeys } from '@typescript-eslint/visitor-keys';
import type * as ts from 'typescript';
interface ParseForESLintResult {
ast: TSESTree.Program & {
range?: [
number,
number
];
tokens?: TSESTree.Token[];
comments?: TSESTree.Comment[];
};
services: ParserServices;
visitorKeys: typeof visitorKeys;
scopeManager: ScopeManager;
}
declare function parse(code: ts.SourceFile | string, options?: ParserOptions): ParseForESLintResult['ast'];
declare function parseForESLint(code: ts.SourceFile | string, options?: ParserOptions | null): ParseForESLintResult;
export { parse, parseForESLint, ParserOptions };
//# sourceMappingURL=parser.d.ts.map

17
node_modules/@typescript-eslint/parser/package.json generated vendored
View file

@ -1,6 +1,6 @@
{
"name": "@typescript-eslint/parser",
"version": "6.4.0",
"version": "6.4.1",
"description": "An ESLint custom parser which leverages TypeScript ESTree",
"files": [
"dist",
@ -51,14 +51,19 @@
"eslint": "^7.0.0 || ^8.0.0"
},
"dependencies": {
"@typescript-eslint/scope-manager": "6.4.0",
"@typescript-eslint/types": "6.4.0",
"@typescript-eslint/typescript-estree": "6.4.0",
"@typescript-eslint/visitor-keys": "6.4.0",
"@typescript-eslint/scope-manager": "6.4.1",
"@typescript-eslint/types": "6.4.1",
"@typescript-eslint/typescript-estree": "6.4.1",
"@typescript-eslint/visitor-keys": "6.4.1",
"debug": "^4.3.4"
},
"devDependencies": {
"@types/glob": "*",
"downlevel-dts": "*",
"glob": "*",
"jest": "29.6.2",
"prettier": "^2.8.4",
"rimraf": "*",
"typescript": "*"
},
"peerDependenciesMeta": {
@ -77,5 +82,5 @@
]
}
},
"gitHead": "14bea42e4864c72d28f502e0d15e675fe8bd729a"
"gitHead": "ef1367eeed112fd6bbb94e0c9bd56d7e167a1a59"
}

2
node_modules/@typescript-eslint/scope-manager/dist/referencer/ClassVisitor.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"ClassVisitor.d.ts","sourceRoot":"","sources":["../../src/referencer/ClassVisitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,cAAM,YAAa,SAAQ,OAAO;;gBAM9B,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAAG,QAAQ,CAAC,eAAe,EAC1D,qBAAqB,EAAE,OAAO;IAQhC,MAAM,CAAC,KAAK,CACV,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAAG,QAAQ,CAAC,eAAe,EAC1D,qBAAqB,EAAE,OAAO,GAC7B,IAAI;IASP,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI;IAanD,SAAS,CAAC,UAAU,CAClB,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAAG,QAAQ,CAAC,eAAe,GACzD,IAAI;IAgCP,SAAS,CAAC,uBAAuB,CAC/B,IAAI,EACA,QAAQ,CAAC,gBAAgB,GACzB,QAAQ,CAAC,kBAAkB,GAC3B,QAAQ,CAAC,0BAA0B,GACnC,QAAQ,CAAC,4BAA4B,GACxC,IAAI;IAWP,SAAS,CAAC,oCAAoC,CAC5C,IAAI,EAAE,QAAQ,CAAC,SAAS,EACxB,cAAc,EAAE,OAAO,GACtB,IAAI;IAgBP,SAAS,CAAC,mBAAmB,CAC3B,IAAI,EAAE,QAAQ,CAAC,kBAAkB,EACjC,UAAU,EAAE,QAAQ,CAAC,gBAAgB,GACpC,IAAI;IAsHP,SAAS,CAAC,iBAAiB,CACzB,IAAI,EACA,QAAQ,CAAC,gBAAgB,GACzB,QAAQ,CAAC,kBAAkB,GAC3B,QAAQ,CAAC,0BAA0B,GACnC,QAAQ,CAAC,0BAA0B,GACnC,QAAQ,CAAC,4BAA4B,GACxC,IAAI;IA4BP,SAAS,CAAC,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAAG,IAAI;IAc5D,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI;IAOjE,SAAS,CAAC,iBAAiB,CACzB,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAAG,IAAI,GAAG,SAAS,EAClD,cAAc,EAAE,OAAO,GACtB,IAAI;IA4CP,SAAS,CAAC,gBAAgB,CAAC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAAG,IAAI;IAIjE,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,IAAI;IAMnD,SAAS,CAAC,kBAAkB,CAAC,IAAI,EAAE,QAAQ,CAAC,kBAAkB,GAAG,IAAI;IAIrE,SAAS,CAAC,gBAAgB,CAAC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAAG,IAAI;IAIjE,SAAS,CAAC,0BAA0B,CAClC,IAAI,EAAE,QAAQ,CAAC,0BAA0B,GACxC,IAAI;IAIP,SAAS,CAAC,4BAA4B,CACpC,IAAI,EAAE,QAAQ,CAAC,4BAA4B,GAC1C,IAAI;IAIP,SAAS,CAAC,0BAA0B,CAClC,IAAI,EAAE,QAAQ,CAAC,0BAA0B,GACxC,IAAI;IAIP,SAAS,CAAC,UAAU,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,GAAG,IAAI;IAIrD,SAAS,CAAC,iBAAiB,IAAI,IAAI;IAInC,SAAS,CAAC,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,WAAW,GAAG,IAAI;CAOxD;AAsCD,OAAO,EAAE,YAAY,EAAE,CAAC"}
{"version":3,"file":"ClassVisitor.d.ts","sourceRoot":"","sources":["../../src/referencer/ClassVisitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,cAAM,YAAa,SAAQ,OAAO;;gBAM9B,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAAG,QAAQ,CAAC,eAAe,EAC1D,qBAAqB,EAAE,OAAO;IAQhC,MAAM,CAAC,KAAK,CACV,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAAG,QAAQ,CAAC,eAAe,EAC1D,qBAAqB,EAAE,OAAO,GAC7B,IAAI;IASP,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI;IAanD,SAAS,CAAC,UAAU,CAClB,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAAG,QAAQ,CAAC,eAAe,GACzD,IAAI;IAgCP,SAAS,CAAC,uBAAuB,CAC/B,IAAI,EACA,QAAQ,CAAC,gBAAgB,GACzB,QAAQ,CAAC,kBAAkB,GAC3B,QAAQ,CAAC,0BAA0B,GACnC,QAAQ,CAAC,4BAA4B,GACxC,IAAI;IAWP,SAAS,CAAC,oCAAoC,CAC5C,IAAI,EAAE,QAAQ,CAAC,SAAS,EACxB,cAAc,EAAE,OAAO,GACtB,IAAI;IAgBP,SAAS,CAAC,mBAAmB,CAC3B,IAAI,EAAE,QAAQ,CAAC,kBAAkB,EACjC,UAAU,EAAE,QAAQ,CAAC,gBAAgB,GACpC,IAAI;IAqHP,SAAS,CAAC,iBAAiB,CACzB,IAAI,EACA,QAAQ,CAAC,gBAAgB,GACzB,QAAQ,CAAC,kBAAkB,GAC3B,QAAQ,CAAC,0BAA0B,GACnC,QAAQ,CAAC,0BAA0B,GACnC,QAAQ,CAAC,4BAA4B,GACxC,IAAI;IA4BP,SAAS,CAAC,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAAG,IAAI;IAc5D,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI;IAOjE,SAAS,CAAC,iBAAiB,CACzB,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAAG,IAAI,GAAG,SAAS,EAClD,cAAc,EAAE,OAAO,GACtB,IAAI;IA4CP,SAAS,CAAC,gBAAgB,CAAC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAAG,IAAI;IAIjE,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,IAAI;IAMnD,SAAS,CAAC,kBAAkB,CAAC,IAAI,EAAE,QAAQ,CAAC,kBAAkB,GAAG,IAAI;IAIrE,SAAS,CAAC,gBAAgB,CAAC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAAG,IAAI;IAIjE,SAAS,CAAC,0BAA0B,CAClC,IAAI,EAAE,QAAQ,CAAC,0BAA0B,GACxC,IAAI;IAIP,SAAS,CAAC,4BAA4B,CACpC,IAAI,EAAE,QAAQ,CAAC,4BAA4B,GAC1C,IAAI;IAIP,SAAS,CAAC,0BAA0B,CAClC,IAAI,EAAE,QAAQ,CAAC,0BAA0B,GACxC,IAAI;IAIP,SAAS,CAAC,UAAU,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,GAAG,IAAI;IAIrD,SAAS,CAAC,iBAAiB,IAAI,IAAI;IAInC,SAAS,CAAC,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,WAAW,GAAG,IAAI;CAOxD;AAsCD,OAAO,EAAE,YAAY,EAAE,CAAC"}

7
node_modules/@typescript-eslint/scope-manager/dist/referencer/ClassVisitor.js generated vendored
View file

@ -120,10 +120,9 @@ class ClassVisitor extends Visitor_1.Visitor {
* ) {}
* }
*/
withMethodDecorators =
withMethodDecorators ||
(methodNode.kind !== 'set' &&
node.params.some(param => param.decorators.length));
withMethodDecorators ||=
methodNode.kind !== 'set' &&
node.params.some(param => param.decorators.length);
if (!withMethodDecorators && methodNode.kind === 'set') {
const keyName = getLiteralMethodKeyName(methodNode);
/**

2
node_modules/@typescript-eslint/scope-manager/dist/referencer/ClassVisitor.js.map generated vendored
View file

File diff suppressed because one or more lines are too long

12
node_modules/@typescript-eslint/scope-manager/package.json generated vendored
View file

@ -1,6 +1,6 @@
{
"name": "@typescript-eslint/scope-manager",
"version": "6.4.0",
"version": "6.4.1",
"description": "TypeScript scope analyser for ESLint",
"files": [
"dist",
@ -44,16 +44,16 @@
"typecheck": "nx typecheck"
},
"dependencies": {
"@typescript-eslint/types": "6.4.0",
"@typescript-eslint/visitor-keys": "6.4.0"
"@typescript-eslint/types": "6.4.1",
"@typescript-eslint/visitor-keys": "6.4.1"
},
"devDependencies": {
"@types/glob": "*",
"@typescript-eslint/typescript-estree": "6.4.0",
"@typescript-eslint/typescript-estree": "6.4.1",
"glob": "*",
"jest-specific-snapshot": "*",
"make-dir": "*",
"prettier": "*",
"prettier": "^2.8.4",
"pretty-format": "*",
"rimraf": "*",
"typescript": "*"
@ -69,5 +69,5 @@
]
}
},
"gitHead": "14bea42e4864c72d28f502e0d15e675fe8bd729a"
"gitHead": "ef1367eeed112fd6bbb94e0c9bd56d7e167a1a59"
}

21
node_modules/@typescript-eslint/type-utils/_ts4.3/dist/TypeOrValueSpecifier.d.ts generated vendored
View file

@ -1,21 +0,0 @@
import type { JSONSchema4 } from '@typescript-eslint/utils/json-schema';
import type * as ts from 'typescript';
interface FileSpecifier {
from: 'file';
name: string[] | string;
path?: string;
}
interface LibSpecifier {
from: 'lib';
name: string[] | string;
}
interface PackageSpecifier {
from: 'package';
name: string[] | string;
package: string;
}
export type TypeOrValueSpecifier = FileSpecifier | LibSpecifier | PackageSpecifier | string;
export declare const typeOrValueSpecifierSchema: JSONSchema4;
export declare function typeMatchesSpecifier(type: ts.Type, specifier: TypeOrValueSpecifier, program: ts.Program): boolean;
export {};
//# sourceMappingURL=TypeOrValueSpecifier.d.ts.map

10
node_modules/@typescript-eslint/type-utils/_ts4.3/dist/containsAllTypesByName.d.ts generated vendored
View file

@ -1,10 +0,0 @@
import * as ts from 'typescript';
/**
* @param type Type being checked by name.
* @param allowAny Whether to consider `any` and `unknown` to match.
* @param allowedNames Symbol names checking on the type.
* @param matchAnyInstead Whether to instead just check if any parts match, rather than all parts.
* @returns Whether the type is, extends, or contains the allowed names (or all matches the allowed names, if mustMatchAll is true).
*/
export declare function containsAllTypesByName(type: ts.Type, allowAny: boolean, allowedNames: Set<string>, matchAnyInstead?: boolean): boolean;
//# sourceMappingURL=containsAllTypesByName.d.ts.map

7
node_modules/@typescript-eslint/type-utils/_ts4.3/dist/getConstrainedTypeAtLocation.d.ts generated vendored
View file

@ -1,7 +0,0 @@
import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/typescript-estree';
import type * as ts from 'typescript';
/**
* Resolves the given node's type. Will resolve to the type's generic constraint, if it has one.
*/
export declare function getConstrainedTypeAtLocation(services: ParserServicesWithTypeInformation, node: TSESTree.Node): ts.Type;
//# sourceMappingURL=getConstrainedTypeAtLocation.d.ts.map

8
node_modules/@typescript-eslint/type-utils/_ts4.3/dist/getContextualType.d.ts generated vendored
View file

@ -1,8 +0,0 @@
import * as ts from 'typescript';
/**
* Returns the contextual type of a given node.
* Contextual type is the type of the target the node is going into.
* i.e. the type of a called function's parameter, or the defined type of a variable declaration
*/
export declare function getContextualType(checker: ts.TypeChecker, node: ts.Expression): ts.Type | undefined;
//# sourceMappingURL=getContextualType.d.ts.map

7
node_modules/@typescript-eslint/type-utils/_ts4.3/dist/getDeclaration.d.ts generated vendored
View file

@ -1,7 +0,0 @@
import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/typescript-estree';
import type * as ts from 'typescript';
/**
* Gets the declaration for the given variable
*/
export declare function getDeclaration(services: ParserServicesWithTypeInformation, node: TSESTree.Node): ts.Declaration | null;
//# sourceMappingURL=getDeclaration.d.ts.map

6
node_modules/@typescript-eslint/type-utils/_ts4.3/dist/getSourceFileOfNode.d.ts generated vendored
View file

@ -1,6 +0,0 @@
import * as ts from 'typescript';
/**
* Gets the source file for a given node
*/
export declare function getSourceFileOfNode(node: ts.Node): ts.SourceFile;
//# sourceMappingURL=getSourceFileOfNode.d.ts.map

3
node_modules/@typescript-eslint/type-utils/_ts4.3/dist/getTokenAtPosition.d.ts generated vendored
View file

@ -1,3 +0,0 @@
import * as ts from 'typescript';
export declare function getTokenAtPosition(sourceFile: ts.SourceFile, position: number): ts.Node;
//# sourceMappingURL=getTokenAtPosition.d.ts.map

3
node_modules/@typescript-eslint/type-utils/_ts4.3/dist/getTypeArguments.d.ts generated vendored
View file

@ -1,3 +0,0 @@
import type * as ts from 'typescript';
export declare function getTypeArguments(type: ts.TypeReference, checker: ts.TypeChecker): readonly ts.Type[];
//# sourceMappingURL=getTypeArguments.d.ts.map

8
node_modules/@typescript-eslint/type-utils/_ts4.3/dist/getTypeName.d.ts generated vendored
View file

@ -1,8 +0,0 @@
import * as ts from 'typescript';
/**
* Get the type name of a given type.
* @param typeChecker The context sensitive TypeScript TypeChecker.
* @param type The type to get the name of.
*/
export declare function getTypeName(typeChecker: ts.TypeChecker, type: ts.Type): string;
//# sourceMappingURL=getTypeName.d.ts.map

17
node_modules/@typescript-eslint/type-utils/_ts4.3/dist/index.d.ts generated vendored
View file

@ -1,17 +0,0 @@
export * from './containsAllTypesByName';
export * from './getConstrainedTypeAtLocation';
export * from './getContextualType';
export * from './getDeclaration';
export * from './getSourceFileOfNode';
export * from './getTokenAtPosition';
export * from './getTypeArguments';
export * from './getTypeName';
export * from './isTypeReadonly';
export * from './isUnsafeAssignment';
export * from './predicates';
export * from './propertyTypes';
export * from './requiresQuoting';
export * from './TypeOrValueSpecifier';
export * from './typeFlagUtils';
export { getDecorators, getModifiers, typescriptVersionIsAtLeast, } from '@typescript-eslint/typescript-estree';
//# sourceMappingURL=index.d.ts.map

27
node_modules/@typescript-eslint/type-utils/_ts4.3/dist/isTypeReadonly.d.ts generated vendored
View file

@ -1,27 +0,0 @@
import type { JSONSchema4 } from '@typescript-eslint/utils/json-schema';
import * as ts from 'typescript';
import type { TypeOrValueSpecifier } from './TypeOrValueSpecifier';
export interface ReadonlynessOptions {
readonly treatMethodsAsReadonly?: boolean;
readonly allow?: TypeOrValueSpecifier[];
}
export declare const readonlynessOptionsSchema: {
type: "object";
additionalProperties: false;
properties: {
treatMethodsAsReadonly: {
type: "boolean";
};
allow: {
type: "array";
items: JSONSchema4;
};
};
};
export declare const readonlynessOptionsDefaults: ReadonlynessOptions;
/**
* Checks if the given type is readonly
*/
declare function isTypeReadonly(program: ts.Program, type: ts.Type, options?: ReadonlynessOptions): boolean;
export { isTypeReadonly };
//# sourceMappingURL=isTypeReadonly.d.ts.map

17
node_modules/@typescript-eslint/type-utils/_ts4.3/dist/isUnsafeAssignment.d.ts generated vendored
View file

@ -1,17 +0,0 @@
import type { TSESTree } from '@typescript-eslint/utils';
import type * as ts from 'typescript';
/**
* Does a simple check to see if there is an any being assigned to a non-any type.
*
* This also checks generic positions to ensure there's no unsafe sub-assignments.
* Note: in the case of generic positions, it makes the assumption that the two types are the same.
*
* @example See tests for examples
*
* @returns false if it's safe, or an object with the two types if it's unsafe
*/
export declare function isUnsafeAssignment(type: ts.Type, receiver: ts.Type, checker: ts.TypeChecker, senderNode: TSESTree.Node | null): false | {
sender: ts.Type;
receiver: ts.Type;
};
//# sourceMappingURL=isUnsafeAssignment.d.ts.map

52
node_modules/@typescript-eslint/type-utils/_ts4.3/dist/predicates.d.ts generated vendored
View file

@ -1,52 +0,0 @@
import * as ts from 'typescript';
/**
* Checks if the given type is (or accepts) nullable
* @param isReceiver true if the type is a receiving type (i.e. the type of a called function's parameter)
*/
export declare function isNullableType(type: ts.Type, { isReceiver, allowUndefined, }?: {
isReceiver?: boolean;
allowUndefined?: boolean;
}): boolean;
/**
* Checks if the given type is either an array type,
* or a union made up solely of array types.
*/
export declare function isTypeArrayTypeOrUnionOfArrayTypes(type: ts.Type, checker: ts.TypeChecker): boolean;
/**
* @returns true if the type is `never`
*/
export declare function isTypeNeverType(type: ts.Type): boolean;
/**
* @returns true if the type is `unknown`
*/
export declare function isTypeUnknownType(type: ts.Type): boolean;
export declare function isTypeReferenceType(type: ts.Type): type is ts.TypeReference;
/**
* @returns true if the type is `any`
*/
export declare function isTypeAnyType(type: ts.Type): boolean;
/**
* @returns true if the type is `any[]`
*/
export declare function isTypeAnyArrayType(type: ts.Type, checker: ts.TypeChecker): boolean;
/**
* @returns true if the type is `unknown[]`
*/
export declare function isTypeUnknownArrayType(type: ts.Type, checker: ts.TypeChecker): boolean;
export declare enum AnyType {
Any = 0,
AnyArray = 1,
Safe = 2
}
/**
* @returns `AnyType.Any` if the type is `any`, `AnyType.AnyArray` if the type is `any[]` or `readonly any[]`,
* otherwise it returns `AnyType.Safe`.
*/
export declare function isAnyOrAnyArrayTypeDiscriminated(node: ts.Node, checker: ts.TypeChecker): AnyType;
/**
* @returns Whether a type is an instance of the parent type, including for the parent's base types.
*/
export declare function typeIsOrHasBaseType(type: ts.Type, parentType: ts.Type): boolean;
export declare function isTypeBigIntLiteralType(type: ts.Type): type is ts.BigIntLiteralType;
export declare function isTypeTemplateLiteralType(type: ts.Type): type is ts.TemplateLiteralType;
//# sourceMappingURL=predicates.d.ts.map

4
node_modules/@typescript-eslint/type-utils/_ts4.3/dist/propertyTypes.d.ts generated vendored
View file

@ -1,4 +0,0 @@
import type * as ts from 'typescript';
export declare function getTypeOfPropertyOfName(checker: ts.TypeChecker, type: ts.Type, name: string, escapedName?: ts.__String): ts.Type | undefined;
export declare function getTypeOfPropertyOfType(checker: ts.TypeChecker, type: ts.Type, property: ts.Symbol): ts.Type | undefined;
//# sourceMappingURL=propertyTypes.d.ts.map

4
node_modules/@typescript-eslint/type-utils/_ts4.3/dist/requiresQuoting.d.ts generated vendored
View file

@ -1,4 +0,0 @@
import * as ts from 'typescript';
declare function requiresQuoting(name: string, target?: ts.ScriptTarget): boolean;
export { requiresQuoting };
//# sourceMappingURL=requiresQuoting.d.ts.map

16
node_modules/@typescript-eslint/type-utils/_ts4.3/dist/typeFlagUtils.d.ts generated vendored
View file

@ -1,16 +0,0 @@
import * as ts from 'typescript';
/**
* Gets all of the type flags in a type, iterating through unions automatically.
*/
export declare function getTypeFlags(type: ts.Type): ts.TypeFlags;
/**
* @param flagsToCheck The composition of one or more `ts.TypeFlags`.
* @param isReceiver Whether the type is a receiving type (e.g. the type of a
* called function's parameter).
* @remarks
* Note that if the type is a union, this function will decompose it into the
* parts and get the flags of every union constituent. If this is not desired,
* use the `isTypeFlag` function from tsutils.
*/
export declare function isTypeFlagSet(type: ts.Type, flagsToCheck: ts.TypeFlags, isReceiver?: boolean): boolean;
//# sourceMappingURL=typeFlagUtils.d.ts.map

16
node_modules/@typescript-eslint/type-utils/package.json generated vendored
View file

@ -1,6 +1,6 @@
{
"name": "@typescript-eslint/type-utils",
"version": "6.4.0",
"version": "6.4.1",
"description": "Type utilities for working with TypeScript + ESLint together",
"files": [
"dist",
@ -45,14 +45,18 @@
"typecheck": "tsc -p tsconfig.json --noEmit"
},
"dependencies": {
"@typescript-eslint/typescript-estree": "6.4.0",
"@typescript-eslint/utils": "6.4.0",
"@typescript-eslint/typescript-estree": "6.4.1",
"@typescript-eslint/utils": "6.4.1",
"debug": "^4.3.4",
"ts-api-utils": "^1.0.1"
},
"devDependencies": {
"@typescript-eslint/parser": "6.4.0",
"ajv": "^8.12.0",
"@typescript-eslint/parser": "6.4.1",
"ajv": "^6.10.0",
"downlevel-dts": "*",
"jest": "29.6.2",
"prettier": "^2.8.4",
"rimraf": "*",
"typescript": "*"
},
"peerDependencies": {
@ -74,5 +78,5 @@
]
}
},
"gitHead": "14bea42e4864c72d28f502e0d15e675fe8bd729a"
"gitHead": "ef1367eeed112fd6bbb94e0c9bd56d7e167a1a59"
}

8
node_modules/@typescript-eslint/types/package.json generated vendored
View file

@ -1,6 +1,6 @@
{
"name": "@typescript-eslint/types",
"version": "6.4.0",
"version": "6.4.1",
"description": "Types for the TypeScript-ESTree AST spec",
"files": [
"dist",
@ -73,6 +73,10 @@
}
},
"devDependencies": {
"downlevel-dts": "*",
"prettier": "^2.8.4",
"rimraf": "*",
"tsx": "*",
"typescript": "*"
},
"funding": {
@ -86,5 +90,5 @@
]
}
},
"gitHead": "14bea42e4864c72d28f502e0d15e675fe8bd729a"
"gitHead": "ef1367eeed112fd6bbb94e0c9bd56d7e167a1a59"
}

9
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/ast-converter.d.ts generated vendored
View file

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

10
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/clear-caches.d.ts generated vendored
View file

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

11
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/convert-comments.d.ts generated vendored
View file

@ -1,11 +0,0 @@
import * as ts from 'typescript';
import type { 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

142
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/convert.d.ts generated vendored
View file

@ -1,142 +0,0 @@
import * as ts from 'typescript';
import type { TSError } from './node-utils';
import type { ParserWeakMap, ParserWeakMapESTreeToTSNode } from './parser-options';
import type { SemanticOrSyntacticError } from './semantic-or-syntactic-errors';
import type { TSESTree, TSNode } from './ts-estree';
export interface ConverterOptions {
allowInvalidAST?: boolean;
errorOnUnknownASTType?: boolean;
shouldPreserveNodeMaps?: boolean;
suppressDeprecatedPropertyWarnings?: boolean;
}
/**
* Extends and formats a given error object
* @param error the error object
* @returns converted error object
*/
export declare function convertError(error: SemanticOrSyntacticError | ts.DiagnosticWithLocation): TSError;
export interface ASTMaps {
esTreeNodeToTSNodeMap: ParserWeakMapESTreeToTSNode;
tsNodeToESTreeNodeMap: ParserWeakMap<TSNode, TSESTree.Node>;
}
export declare class Converter {
#private;
private readonly ast;
private readonly options;
private readonly esTreeNodeToTSNodeMap;
private readonly tsNodeToESTreeNodeMap;
private allowPattern;
/**
* 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 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;
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 convertTypeArgumentsToTypeParameterInstantiation;
/**
* 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;
/**
* 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;
}
//# sourceMappingURL=convert.d.ts.map

13
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/create-program/WatchCompilerHostOfConfigFile.d.ts generated vendored
View file

@ -1,13 +0,0 @@
import type * as ts from 'typescript';
interface DirectoryStructureHost {
readDirectory?(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[];
}
interface CachedDirectoryStructureHost extends DirectoryStructureHost {
readDirectory(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly 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

12
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/create-program/createDefaultProgram.d.ts generated vendored
View file

@ -1,12 +0,0 @@
import type { ParseSettings } from '../parseSettings';
import type { ASTAndDefiniteProgram } from './shared';
/**
* @param parseSettings Internal settings for parsing the file
* @returns If found, returns the source file corresponding to the code and the containing program
* @deprecated
* This is a legacy option that comes with severe performance penalties.
* Please do not use it.
*/
declare function createDefaultProgram(parseSettings: ParseSettings): ASTAndDefiniteProgram | undefined;
export { createDefaultProgram };
//# sourceMappingURL=createDefaultProgram.d.ts.map

9
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/create-program/createIsolatedProgram.d.ts generated vendored
View file

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

10
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/create-program/createProjectProgram.d.ts generated vendored
View file

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

4
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/create-program/createProjectService.d.ts generated vendored
View file

@ -1,4 +0,0 @@
import type * as ts from 'typescript/lib/tsserverlibrary';
export type TypeScriptProjectService = ts.server.ProjectService;
export declare function createProjectService(): TypeScriptProjectService;
//# sourceMappingURL=createProjectService.d.ts.map

7
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/create-program/createSourceFile.d.ts generated vendored
View file

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

2
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/create-program/describeFilePath.d.ts generated vendored
View file

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

5
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/create-program/getScriptKind.d.ts generated vendored
View file

@ -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

15
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/create-program/getWatchProgramsForProjects.d.ts generated vendored
View file

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

32
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/create-program/shared.d.ts generated vendored
View file

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

16
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/create-program/useProvidedPrograms.d.ts generated vendored
View file

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

5
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/createParserServices.d.ts generated vendored
View file

@ -1,5 +0,0 @@
import type * as ts from 'typescript';
import type { ASTMaps } from './convert';
import type { ParserServices } from './parser-options';
export declare function createParserServices(astMaps: ASTMaps, program: ts.Program | null): ParserServices;
//# sourceMappingURL=createParserServices.d.ts.map

4
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/getModifiers.d.ts generated vendored
View file

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

13
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/index.d.ts generated vendored
View file

@ -1,13 +0,0 @@
export { AST, parse, parseAndGenerateServices, ParseAndGenerateServicesResult, } from './parser';
export { ParserServices, ParserServicesWithTypeInformation, ParserServicesWithoutTypeInformation, TSESTreeOptions, } from './parser-options';
export { simpleTraverse } from './simple-traverse';
export * from './ts-estree';
export { createProgramFromConfigFile as createProgram } from './create-program/useProvidedPrograms';
export * from './create-program/getScriptKind';
export { getCanonicalFileName } from './create-program/shared';
export { typescriptVersionIsAtLeast } from './version-check';
export * from './getModifiers';
export { TSError } from './node-utils';
export * from './clear-caches';
export declare const version: string;
//# sourceMappingURL=index.d.ts.map

2
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/jsx/xhtml-entities.d.ts generated vendored
View file

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

255
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/node-utils.d.ts generated vendored
View file

@ -1,255 +0,0 @@
import * as ts from 'typescript';
import type { TSESTree, TSNode } from './ts-estree';
import { AST_NODE_TYPES, AST_TOKEN_TYPES } from './ts-estree';
declare const SyntaxKind: typeof ts.SyntaxKind;
type LogicalOperatorKind = ts.SyntaxKind.AmpersandAmpersandToken | ts.SyntaxKind.BarBarToken | ts.SyntaxKind.QuestionQuestionToken;
interface TokenToText extends TSESTree.PunctuatorTokenToText, TSESTree.BinaryOperatorToText {
[SyntaxKind.ImportKeyword]: 'import';
[SyntaxKind.NewKeyword]: 'new';
[SyntaxKind.KeyOfKeyword]: 'keyof';
[SyntaxKind.ReadonlyKeyword]: 'readonly';
[SyntaxKind.UniqueKeyword]: 'unique';
}
type AssignmentOperatorKind = keyof TSESTree.AssignmentOperatorToText;
type BinaryOperatorKind = keyof TSESTree.BinaryOperatorToText;
/**
* Returns true if the given ts.Token is a logical operator
* @param operator the operator token
* @returns is a logical operator
*/
export declare function isLogicalOperator(operator: ts.BinaryOperatorToken): operator is ts.Token<LogicalOperatorKind>;
export declare function isESTreeBinaryOperator(operator: ts.BinaryOperatorToken): operator is ts.Token<BinaryOperatorKind>;
type TokenForTokenKind<T extends ts.SyntaxKind> = T extends keyof TokenToText ? TokenToText[T] : string | undefined;
/**
* Returns the string form of the given TSToken SyntaxKind
* @param kind the token's SyntaxKind
* @returns the token applicable token as a string
*/
export declare function getTextForTokenKind<T extends ts.SyntaxKind>(kind: T): TokenForTokenKind<T>;
/**
* Returns true if the given ts.Node is a valid ESTree class member
* @param node TypeScript AST node
* @returns is valid ESTree class member
*/
export declare function isESTreeClassMember(node: ts.Node): boolean;
/**
* Checks if a ts.Node has a modifier
* @param modifierKind TypeScript SyntaxKind modifier
* @param node TypeScript AST node
* @returns has the modifier specified
*/
export declare function hasModifier(modifierKind: ts.KeywordSyntaxKind, node: ts.Node): boolean;
/**
* Get last last modifier in ast
* @param node TypeScript AST node
* @returns returns last modifier if present or null
*/
export declare function getLastModifier(node: ts.Node): ts.Modifier | null;
/**
* Returns true if the given ts.Token is a comma
* @param token the TypeScript token
* @returns is comma
*/
export declare function isComma(token: ts.Node): token is ts.Token<ts.SyntaxKind.CommaToken>;
/**
* Returns true if the given ts.Node is a comment
* @param node the TypeScript node
* @returns is comment
*/
export declare function isComment(node: ts.Node): boolean;
/**
* Returns the binary expression type of the given ts.Token
* @param operator the operator token
* @returns the binary expression type
*/
export declare function getBinaryExpressionType(operator: ts.BinaryOperatorToken): {
type: AST_NODE_TYPES.AssignmentExpression;
operator: TokenForTokenKind<AssignmentOperatorKind>;
} | {
type: AST_NODE_TYPES.BinaryExpression;
operator: TokenForTokenKind<BinaryOperatorKind>;
} | {
type: AST_NODE_TYPES.LogicalExpression;
operator: TokenForTokenKind<LogicalOperatorKind>;
};
/**
* Returns line and column data for the given positions,
* @param pos position to check
* @param ast the AST object
* @returns line and column
*/
export declare function getLineAndCharacterFor(pos: number, ast: ts.SourceFile): TSESTree.Position;
/**
* Returns line and column data for the given start and end positions,
* for the given AST
* @param range start end data
* @param ast the AST object
* @returns the loc data
*/
export declare function getLocFor(range: TSESTree.Range, ast: ts.SourceFile): TSESTree.SourceLocation;
/**
* Check whatever node can contain directive
* @param node
* @returns returns true if node can contain directive
*/
export declare function canContainDirective(node: ts.Block | ts.ClassStaticBlockDeclaration | ts.ModuleBlock | ts.SourceFile): boolean;
/**
* Returns range for the given ts.Node
* @param node the ts.Node or ts.Token
* @param ast the AST object
* @returns the range data
*/
export declare function getRange(node: Pick<ts.Node, 'getEnd' | 'getStart'>, ast: ts.SourceFile): [
number,
number
];
/**
* Returns true if a given ts.Node is a JSX token
* @param node ts.Node to be checked
* @returns is a JSX token
*/
export declare function isJSXToken(node: ts.Node): boolean;
/**
* Returns the declaration kind of the given ts.Node
* @param node TypeScript AST node
* @returns declaration kind
*/
export declare function getDeclarationKind(node: ts.VariableDeclarationList): 'const' | 'let' | 'var';
/**
* Gets a ts.Node's accessibility level
* @param node The ts.Node
* @returns accessibility "public", "protected", "private", or null
*/
export declare function getTSNodeAccessibility(node: ts.Node): 'private' | 'protected' | 'public' | undefined;
/**
* Finds the next token based on the previous one and its parent
* Had to copy this from TS instead of using TS's version because theirs doesn't pass the ast to getChildren
* @param previousToken The previous TSToken
* @param parent The parent TSNode
* @param ast The TS AST
* @returns the next TSToken
*/
export declare function findNextToken(previousToken: ts.TextRange, parent: ts.Node, ast: ts.SourceFile): ts.Node | undefined;
/**
* Find the first matching ancestor based on the given predicate function.
* @param node The current ts.Node
* @param predicate The predicate function to apply to each checked ancestor
* @returns a matching parent ts.Node
*/
export declare function findFirstMatchingAncestor(node: ts.Node, predicate: (node: ts.Node) => boolean): ts.Node | undefined;
/**
* Returns true if a given ts.Node has a JSX token within its hierarchy
* @param node ts.Node to be checked
* @returns has JSX ancestor
*/
export declare function hasJSXAncestor(node: ts.Node): boolean;
/**
* Unescape the text content of string literals, e.g. &amp; -> &
* @param text The escaped string literal text.
* @returns The unescaped string literal text.
*/
export declare function unescapeStringLiteralText(text: string): string;
/**
* Returns true if a given ts.Node is a computed property
* @param node ts.Node to be checked
* @returns is Computed Property
*/
export declare function isComputedProperty(node: ts.Node): node is ts.ComputedPropertyName;
/**
* Returns true if a given ts.Node is optional (has QuestionToken)
* @param node ts.Node to be checked
* @returns is Optional
*/
export declare function isOptional(node: {
questionToken?: ts.QuestionToken;
}): boolean;
/**
* Returns true if the node is an optional chain node
*/
export declare function isChainExpression(node: TSESTree.Node): node is TSESTree.ChainExpression;
/**
* Returns true of the child of property access expression is an optional chain
*/
export declare function isChildUnwrappableOptionalChain(node: ts.CallExpression | ts.ElementAccessExpression | ts.NonNullExpression | ts.PropertyAccessExpression, child: TSESTree.Node): boolean;
/**
* Returns the type of a given ts.Token
* @param token the ts.Token
* @returns the token type
*/
export declare function getTokenType(token: ts.Identifier | ts.Token<ts.SyntaxKind>): Exclude<AST_TOKEN_TYPES, AST_TOKEN_TYPES.Block | AST_TOKEN_TYPES.Line>;
/**
* Extends and formats a given ts.Token, for a given AST
* @param token the ts.Token
* @param ast the AST object
* @returns the converted Token
*/
export declare function convertToken(token: ts.Token<ts.TokenSyntaxKind>, ast: ts.SourceFile): TSESTree.Token;
/**
* Converts all tokens for the given AST
* @param ast the AST object
* @returns the converted Tokens
*/
export declare function convertTokens(ast: ts.SourceFile): TSESTree.Token[];
export declare class TSError extends Error {
readonly fileName: string;
readonly location: {
start: {
line: number;
column: number;
offset: number;
};
end: {
line: number;
column: number;
offset: number;
};
};
constructor(message: string, fileName: string, location: {
start: {
line: number;
column: number;
offset: number;
};
end: {
line: number;
column: number;
offset: number;
};
});
get index(): number;
get lineNumber(): number;
get column(): number;
}
/**
* @param message the error message
* @param ast the AST object
* @param startIndex the index at which the error starts
* @param endIndex the index at which the error ends
* @returns converted error object
*/
export declare function createError(message: string, ast: ts.SourceFile, startIndex: number, endIndex?: number): TSError;
export declare function nodeHasIllegalDecorators(node: ts.Node): node is ts.Node & {
illegalDecorators: ts.Node[];
};
/**
* @param n the TSNode
* @param ast the TS AST
*/
export declare function nodeHasTokens(n: ts.Node, ast: ts.SourceFile): boolean;
/**
* Like `forEach`, but suitable for use with numbers and strings (which may be falsy).
* @template T
* @template U
* @param array
* @param callback
*/
export declare function firstDefined<T, U>(array: readonly T[] | undefined, callback: (element: T, index: number) => U | undefined): U | undefined;
export declare function identifierIsThisKeyword(id: ts.Identifier): boolean;
export declare function isThisIdentifier(node: ts.Node | undefined): node is ts.Identifier;
export declare function isThisInTypeQuery(node: ts.Node): boolean;
export declare function nodeIsPresent(node: ts.Node | undefined): node is ts.Node;
export declare function getContainingFunction(node: ts.Node): ts.SignatureDeclaration | undefined;
export declare function nodeCanBeDecorated(node: TSNode): boolean;
export declare function getNamespaceModifiers(node: ts.ModuleDeclaration): ts.Modifier[] | undefined;
export {};
//# sourceMappingURL=node-utils.d.ts.map

17
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/parseSettings/ExpiringCache.d.ts generated vendored
View file

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

7
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/parseSettings/createParseSettings.d.ts generated vendored
View file

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

12
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/parseSettings/getProjectConfigFiles.d.ts generated vendored
View file

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

122
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/parseSettings/index.d.ts generated vendored
View file

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

15
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/parseSettings/inferSingleRun.d.ts generated vendored
View file

@ -1,15 +0,0 @@
import type { TSESTreeOptions } from '../parser-options';
/**
* ESLint (and therefore typescript-eslint) is used in both "single run"/one-time contexts,
* such as an ESLint CLI invocation, and long-running sessions (such as continuous feedback
* on a file in an IDE).
*
* When typescript-eslint handles TypeScript Program management behind the scenes, this distinction
* is important because there is significant overhead to managing the so called Watch Programs
* needed for the long-running use-case. We therefore use the following logic to figure out which
* of these contexts applies to the current execution.
*
* @returns Whether this is part of a single run, rather than a long-running process.
*/
export declare function inferSingleRun(options: TSESTreeOptions | undefined): boolean;
//# sourceMappingURL=inferSingleRun.d.ts.map

19
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/parseSettings/resolveProjectList.d.ts generated vendored
View file

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

3
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/parseSettings/warnAboutTSVersion.d.ts generated vendored
View file

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

192
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/parser-options.d.ts generated vendored
View file

@ -1,192 +0,0 @@
import type { CacheDurationSeconds, DebugLevel } from '@typescript-eslint/types';
import type * as ts from 'typescript';
import type { TSESTree, TSESTreeToTSNode, TSNode, TSToken } from './ts-estree';
interface ParseOptions {
/**
* Prevents the parser from throwing an error if it receives an invalid AST from TypeScript.
* This case only usually occurs when attempting to lint invalid code.
*/
allowInvalidAST?: boolean;
/**
* create a top-level comments array containing all comments
*/
comment?: boolean;
/**
* An array of modules to turn explicit debugging on for.
* - 'typescript-eslint' is the same as setting the env var `DEBUG=typescript-eslint:*`
* - 'eslint' is the same as setting the env var `DEBUG=eslint:*`
* - 'typescript' is the same as setting `extendedDiagnostics: true` in your tsconfig compilerOptions
*
* For convenience, also supports a boolean:
* - true === ['typescript-eslint']
* - false === []
*/
debugLevel?: DebugLevel;
/**
* Cause the parser to error if it encounters an unknown AST node type (useful for testing).
* This case only usually occurs when TypeScript releases new features.
*/
errorOnUnknownASTType?: boolean;
/**
* Absolute (or relative to `cwd`) path to the file being parsed.
*/
filePath?: string;
/**
* Enable parsing of JSX.
* For more details, see https://www.typescriptlang.org/docs/handbook/jsx.html
*
* NOTE: this setting does not effect known file types (.js, .cjs, .mjs, .jsx, .ts, .mts, .cts, .tsx, .json) because the
* TypeScript compiler has its own internal handling for known file extensions.
*
* For the exact behavior, see https://github.com/typescript-eslint/typescript-eslint/tree/main/packages/parser#parseroptionsecmafeaturesjsx
*/
jsx?: boolean;
/**
* Controls whether the `loc` information to each node.
* The `loc` property is an object which contains the exact line/column the node starts/ends on.
* This is similar to the `range` property, except it is line/column relative.
*/
loc?: boolean;
loggerFn?: false | ((message: string) => void);
/**
* Controls whether the `range` property is included on AST nodes.
* The `range` property is a [number, number] which indicates the start/end index of the node in the file contents.
* This is similar to the `loc` property, except this is the absolute index.
*/
range?: boolean;
/**
* Set to true to create a top-level array containing all tokens from the file.
*/
tokens?: boolean;
/**
* Whether deprecated AST properties should skip calling console.warn on accesses.
*/
suppressDeprecatedPropertyWarnings?: boolean;
}
interface ParseAndGenerateServicesOptions extends ParseOptions {
/**
* Causes the parser to error if the TypeScript compiler returns any unexpected syntax/semantic errors.
*/
errorOnTypeScriptSyntacticAndSemanticIssues?: boolean;
/**
* ***EXPERIMENTAL FLAG*** - Use this at your own risk.
*
* Whether to create a shared TypeScript server to power program creation.
*
* @see https://github.com/typescript-eslint/typescript-eslint/issues/6575
*/
EXPERIMENTAL_useProjectService?: boolean;
/**
* ***EXPERIMENTAL FLAG*** - Use this at your own risk.
*
* Causes TS to use the source files for referenced projects instead of the compiled .d.ts files.
* This feature is not yet optimized, and is likely to cause OOMs for medium to large projects.
*
* This flag REQUIRES at least TS v3.9, otherwise it does nothing.
*
* @see https://github.com/typescript-eslint/typescript-eslint/issues/2094
*/
EXPERIMENTAL_useSourceOfProjectReferenceRedirect?: boolean;
/**
* When `project` is provided, this controls the non-standard file extensions which will be parsed.
* It accepts an array of file extensions, each preceded by a `.`.
*/
extraFileExtensions?: string[];
/**
* Absolute (or relative to `tsconfigRootDir`) path to the file being parsed.
* When `project` is provided, this is required, as it is used to fetch the file from the TypeScript compiler's cache.
*/
filePath?: string;
/**
* Allows the user to control whether or not two-way AST node maps are preserved
* during the AST conversion process.
*
* By default: the AST node maps are NOT preserved, unless `project` has been specified,
* in which case the maps are made available on the returned `parserServices`.
*
* NOTE: If `preserveNodeMaps` is explicitly set by the user, it will be respected,
* regardless of whether or not `project` is in use.
*/
preserveNodeMaps?: boolean;
/**
* Absolute (or relative to `tsconfigRootDir`) paths to the tsconfig(s),
* or `true` to find the nearest tsconfig.json to the file.
* If this is provided, type information will be returned.
*/
project?: string[] | string | true | null;
/**
* If you provide a glob (or globs) to the project option, you can use this option to ignore certain folders from
* being matched by the globs.
* This accepts an array of globs to ignore.
*
* By default, this is set to ["**\/node_modules/**"]
*/
projectFolderIgnoreList?: string[];
/**
* The absolute path to the root directory for all provided `project`s.
*/
tsconfigRootDir?: string;
/**
* An array of one or more instances of TypeScript Program objects to be used for type information.
* This overrides any program or programs that would have been computed from the `project` option.
* All linted files must be part of the provided program(s).
*/
programs?: ts.Program[] | null;
/**
* @deprecated - this flag will be removed in the next major.
* Do not rely on the behavior provided by this flag.
*/
DEPRECATED__createDefaultProgram?: boolean;
/**
* ESLint (and therefore typescript-eslint) is used in both "single run"/one-time contexts,
* such as an ESLint CLI invocation, and long-running sessions (such as continuous feedback
* on a file in an IDE).
*
* When typescript-eslint handles TypeScript Program management behind the scenes, this distinction
* is important because there is significant overhead to managing the so called Watch Programs
* needed for the long-running use-case.
*
* When allowAutomaticSingleRunInference is enabled, we will use common heuristics to infer
* whether or not ESLint is being used as part of a single run.
*/
allowAutomaticSingleRunInference?: boolean;
/**
* Granular control of the expiry lifetime of our internal caches.
* You can specify the number of seconds as an integer number, or the string
* 'Infinity' if you never want the cache to expire.
*
* By default cache entries will be evicted after 30 seconds, or will persist
* indefinitely if `allowAutomaticSingleRunInference = true` AND the parser
* infers that it is a single run.
*/
cacheLifetime?: {
/**
* Glob resolution for `parserOptions.project` values.
*/
glob?: CacheDurationSeconds;
};
}
export type TSESTreeOptions = ParseAndGenerateServicesOptions;
export interface ParserWeakMap<TKey, TValueBase> {
get<TValue extends TValueBase>(key: TKey): TValue;
has(key: unknown): boolean;
}
export interface ParserWeakMapESTreeToTSNode<TKey extends TSESTree.Node = TSESTree.Node> {
get<TKeyBase extends TKey>(key: TKeyBase): TSESTreeToTSNode<TKeyBase>;
has(key: unknown): boolean;
}
export interface ParserServicesNodeMaps {
esTreeNodeToTSNodeMap: ParserWeakMapESTreeToTSNode;
tsNodeToESTreeNodeMap: ParserWeakMap<TSNode | TSToken, TSESTree.Node>;
}
export interface ParserServicesWithTypeInformation extends ParserServicesNodeMaps {
program: ts.Program;
getSymbolAtLocation: (node: TSESTree.Node) => ts.Symbol | undefined;
getTypeAtLocation: (node: TSESTree.Node) => ts.Type;
}
export interface ParserServicesWithoutTypeInformation extends ParserServicesNodeMaps {
program: null;
}
export type ParserServices = ParserServicesWithoutTypeInformation | ParserServicesWithTypeInformation;
export {};
//# sourceMappingURL=parser-options.d.ts.map

20
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/parser.d.ts generated vendored
View file

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

13
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/semantic-or-syntactic-errors.d.ts generated vendored
View file

@ -1,13 +0,0 @@
import type { 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

12
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/simple-traverse.d.ts generated vendored
View file

@ -1,12 +0,0 @@
import type { VisitorKeys } from '@typescript-eslint/visitor-keys';
import type { TSESTree } from './ts-estree';
type SimpleTraverseOptions = Readonly<{
visitorKeys?: Readonly<VisitorKeys>;
enter: (node: TSESTree.Node, parent: TSESTree.Node | undefined) => void;
} | {
visitorKeys?: Readonly<VisitorKeys>;
visitors: Record<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

4
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/source-files.d.ts generated vendored
View file

@ -1,4 +0,0 @@
import * as ts from 'typescript';
export declare function isSourceFile(code: unknown): code is ts.SourceFile;
export declare function getCodeText(code: ts.SourceFile | string): string;
//# sourceMappingURL=source-files.d.ts.map

178
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/ts-estree/estree-to-ts-node-types.d.ts generated vendored
View file

@ -1,178 +0,0 @@
import type { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/types';
import type * as ts from 'typescript';
import type { TSNode } from './ts-nodes';
export interface EstreeToTsNodeTypes {
[AST_NODE_TYPES.AccessorProperty]: ts.PropertyDeclaration;
[AST_NODE_TYPES.ArrayExpression]: ts.ArrayLiteralExpression;
[AST_NODE_TYPES.ArrayPattern]: ts.ArrayBindingPattern | ts.ArrayLiteralExpression;
[AST_NODE_TYPES.ArrowFunctionExpression]: ts.ArrowFunction;
[AST_NODE_TYPES.AssignmentExpression]: ts.BinaryExpression;
[AST_NODE_TYPES.AssignmentPattern]: ts.BinaryExpression | ts.BindingElement | ts.ParameterDeclaration | ts.ShorthandPropertyAssignment;
[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.ElementAccessExpression | ts.NonNullExpression | ts.PropertyAccessExpression;
[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.ClassDeclaration | ts.ClassExpression | ts.EnumDeclaration | ts.ExportAssignment | ts.FunctionDeclaration | ts.InterfaceDeclaration | ts.ModuleDeclaration | ts.TypeAliasDeclaration | ts.VariableStatement;
[AST_NODE_TYPES.ExportNamedDeclaration]: ts.ClassDeclaration | ts.ClassExpression | ts.EnumDeclaration | ts.ExportDeclaration | ts.FunctionDeclaration | ts.ImportEqualsDeclaration | ts.InterfaceDeclaration | ts.ModuleDeclaration | ts.TypeAliasDeclaration | ts.VariableStatement;
[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.ConstructorDeclaration | ts.FunctionExpression | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.SetAccessorDeclaration;
[AST_NODE_TYPES.Identifier]: ts.ConstructorDeclaration | ts.Identifier | ts.Token<ts.SyntaxKind.ImportKeyword | ts.SyntaxKind.NewKeyword>;
[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.JsxNamespacedName;
[AST_NODE_TYPES.JSXText]: ts.JsxText;
[AST_NODE_TYPES.LabeledStatement]: ts.LabeledStatement;
[AST_NODE_TYPES.Literal]: ts.BigIntLiteral | ts.BooleanLiteral | ts.NullLiteral | ts.NumericLiteral | ts.RegularExpressionLiteral | ts.StringLiteral;
[AST_NODE_TYPES.LogicalExpression]: ts.BinaryExpression;
[AST_NODE_TYPES.MemberExpression]: ts.ElementAccessExpression | ts.PropertyAccessExpression;
[AST_NODE_TYPES.MetaProperty]: ts.MetaProperty;
[AST_NODE_TYPES.MethodDefinition]: ts.ConstructorDeclaration | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.SetAccessorDeclaration;
[AST_NODE_TYPES.NewExpression]: ts.NewExpression;
[AST_NODE_TYPES.ObjectExpression]: ts.ObjectLiteralExpression;
[AST_NODE_TYPES.ObjectPattern]: ts.ObjectBindingPattern | ts.ObjectLiteralExpression;
[AST_NODE_TYPES.Program]: ts.SourceFile;
[AST_NODE_TYPES.Property]: ts.BindingElement | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.PropertyAssignment | ts.SetAccessorDeclaration | ts.ShorthandPropertyAssignment;
[AST_NODE_TYPES.RestElement]: ts.BindingElement | ts.ParameterDeclaration | ts.SpreadAssignment | ts.SpreadElement;
[AST_NODE_TYPES.ReturnStatement]: ts.ReturnStatement;
[AST_NODE_TYPES.SequenceExpression]: ts.BinaryExpression;
[AST_NODE_TYPES.SpreadElement]: ts.SpreadAssignment | ts.SpreadElement;
[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.Identifier | ts.KeywordTypeNode | ts.ThisExpression;
[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.ConstructorDeclaration | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.SetAccessorDeclaration;
[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.GetAccessorDeclaration | ts.MethodSignature | 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.Identifier | ts.QualifiedName;
[AST_NODE_TYPES.TSRestType]: ts.NamedTupleMember | ts.RestTypeNode;
[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.CallExpression | ts.ExpressionWithTypeArguments | ts.ImportTypeNode | ts.JsxOpeningElement | ts.JsxSelfClosingElement | ts.NewExpression | ts.TaggedTemplateExpression | ts.TypeQueryNode | ts.TypeReferenceNode;
[AST_NODE_TYPES.TSTypePredicate]: ts.TypePredicateNode;
[AST_NODE_TYPES.TSTypeQuery]: ts.ImportTypeNode | ts.TypeQueryNode;
[AST_NODE_TYPES.TSTypeReference]: ts.TypeReferenceNode;
[AST_NODE_TYPES.TSUnionType]: ts.UnionTypeNode;
[AST_NODE_TYPES.UpdateExpression]: ts.PostfixUnaryExpression | ts.PrefixUnaryExpression;
[AST_NODE_TYPES.UnaryExpression]: ts.DeleteExpression | ts.PostfixUnaryExpression | ts.PrefixUnaryExpression | ts.TypeOfExpression | ts.VoidExpression;
[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.ConstructorDeclaration | ts.FunctionExpression | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.SetAccessorDeclaration;
[AST_NODE_TYPES.TSAbstractKeyword]: ts.Token<ts.SyntaxKind.AbstractKeyword>;
[AST_NODE_TYPES.TSNullKeyword]: ts.KeywordTypeNode | ts.NullLiteral;
[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<ts.Token<ts.SyntaxKind.ImportKeyword | ts.SyntaxKind.NewKeyword> | TSNode, EstreeToTsNodeTypes[T['type']]>;
//# sourceMappingURL=estree-to-ts-node-types.d.ts.map

4
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/ts-estree/index.d.ts generated vendored
View file

@ -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

14
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/ts-estree/ts-nodes.d.ts generated vendored
View file

@ -1,14 +0,0 @@
import type * as ts from 'typescript';
declare module 'typescript' {
interface AssertClause extends ts.Node {
}
interface AssertEntry extends ts.Node {
}
interface SatisfiesExpression extends ts.Node {
}
interface JsxNamespacedName 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.JsxNamespacedName | 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

7
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/use-at-your-own-risk.d.ts generated vendored
View file

@ -1,7 +0,0 @@
export * from './create-program/getScriptKind';
export * from './ast-converter';
export type { ParseSettings } from './parseSettings';
export * from './getModifiers';
export { typescriptVersionIsAtLeast } from './version-check';
export { getCanonicalFileName } from './create-program/shared';
//# sourceMappingURL=use-at-your-own-risk.d.ts.map

5
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/useProgramFromProjectService.d.ts generated vendored
View file

@ -1,5 +0,0 @@
import type { server } from 'typescript/lib/tsserverlibrary';
import type { ASTAndDefiniteProgram } from './create-program/shared';
import type { MutableParseSettings } from './parseSettings';
export declare function useProgramFromProjectService(projectService: server.ProjectService, parseSettings: Readonly<MutableParseSettings>): ASTAndDefiniteProgram | undefined;
//# sourceMappingURL=useProgramFromProjectService.d.ts.map

3
node_modules/@typescript-eslint/typescript-estree/_ts4.3/dist/version-check.d.ts generated vendored
View file

@ -1,3 +0,0 @@
declare const typescriptVersionIsAtLeast: Record<"4.3" | "4.4" | "4.5" | "4.6" | "4.7" | "4.8" | "4.9" | "5.0" | "5.1" | "5.2", boolean>;
export { typescriptVersionIsAtLeast };
//# sourceMappingURL=version-check.d.ts.map

2
node_modules/@typescript-eslint/typescript-estree/dist/create-program/getWatchProgramsForProjects.d.ts.map generated vendored
View file

@ -1 +1 @@
{"version":3,"file":"getWatchProgramsForProjects.d.ts","sourceRoot":"","sources":["../../src/create-program/getWatchProgramsForProjects.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AA8CtD;;;GAGG;AACH,iBAAS,gBAAgB,IAAI,IAAI,CAOhC;AAgED;;;;GAIG;AACH,iBAAS,2BAA2B,CAClC,aAAa,EAAE,aAAa,GAC3B,EAAE,CAAC,OAAO,EAAE,CAuHd;AAkQD,OAAO,EAAE,gBAAgB,EAAE,2BAA2B,EAAE,CAAC"}
{"version":3,"file":"getWatchProgramsForProjects.d.ts","sourceRoot":"","sources":["../../src/create-program/getWatchProgramsForProjects.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AA8CtD;;;GAGG;AACH,iBAAS,gBAAgB,IAAI,IAAI,CAOhC;AAgED;;;;GAIG;AACH,iBAAS,2BAA2B,CAClC,aAAa,EAAE,aAAa,GAC3B,EAAE,CAAC,OAAO,EAAE,CAsHd;AAkQD,OAAO,EAAE,gBAAgB,EAAE,2BAA2B,EAAE,CAAC"}

3
node_modules/@typescript-eslint/typescript-estree/dist/create-program/getWatchProgramsForProjects.js generated vendored
View file

@ -146,8 +146,7 @@ function getWatchProgramsForProjects(parseSettings) {
}
if (fileList.has(filePath)) {
log('Found existing program for file. %s', filePath);
updatedProgram =
updatedProgram ?? existingWatch.getProgram().getProgram();
updatedProgram ??= existingWatch.getProgram().getProgram();
// sets parent pointers in source files
updatedProgram.getTypeChecker();
return [updatedProgram];

2
node_modules/@typescript-eslint/typescript-estree/dist/create-program/getWatchProgramsForProjects.js.map generated vendored
View file

File diff suppressed because one or more lines are too long

13
node_modules/@typescript-eslint/typescript-estree/package.json generated vendored
View file

@ -1,6 +1,6 @@
{
"name": "@typescript-eslint/typescript-estree",
"version": "6.4.0",
"version": "6.4.1",
"description": "A parser that converts TypeScript source code into an ESTree compatible form",
"files": [
"dist",
@ -52,8 +52,8 @@
"typecheck": "tsc -p tsconfig.json --noEmit"
},
"dependencies": {
"@typescript-eslint/types": "6.4.0",
"@typescript-eslint/visitor-keys": "6.4.0",
"@typescript-eslint/types": "6.4.1",
"@typescript-eslint/visitor-keys": "6.4.1",
"debug": "^4.3.4",
"globby": "^11.1.0",
"is-glob": "^4.0.3",
@ -64,8 +64,11 @@
"@babel/code-frame": "*",
"@babel/parser": "*",
"glob": "*",
"jest-specific-snapshot": "*",
"jest": "29.6.2",
"jest-specific-snapshot": "^8.0.0",
"make-dir": "*",
"prettier": "^2.8.4",
"rimraf": "*",
"tmp": "*",
"typescript": "*"
},
@ -85,5 +88,5 @@
]
}
},
"gitHead": "14bea42e4864c72d28f502e0d15e675fe8bd729a"
"gitHead": "ef1367eeed112fd6bbb94e0c9bd56d7e167a1a59"
}

48
node_modules/@typescript-eslint/utils/_ts4.3/dist/ast-utils/eslint-utils/PatternMatcher.d.ts generated vendored
View file

@ -1,48 +0,0 @@
interface PatternMatcher {
/**
* Iterate all matched parts in a given string.
*
* @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#matcher-execall}
*/
execAll(str: string): IterableIterator<RegExpExecArray>;
/**
* Check whether this pattern matches a given string or not.
*
* @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#matcher-test}
*/
test(str: string): boolean;
/**
* Replace all matched parts by a given replacer.
*
* @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#matcher-symbol-replace}
* @example
* const { PatternMatcher } = require("eslint-utils")
* const matcher = new PatternMatcher(/\\p{Script=Greek}/g)
*
* module.exports = {
* meta: {},
* create(context) {
* return {
* "Literal[regex]"(node) {
* const replacedPattern = node.regex.pattern.replace(
* matcher,
* "[\\u0370-\\u0373\\u0375-\\u0377\\u037A-\\u037D\\u037F\\u0384\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03E1\\u03F0-\\u03FF\\u1D26-\\u1D2A\\u1D5D-\\u1D61\\u1D66-\\u1D6A\\u1DBF\\u1F00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FC4\\u1FC6-\\u1FD3\\u1FD6-\\u1FDB\\u1FDD-\\u1FEF\\u1FF2-\\u1FF4\\u1FF6-\\u1FFE\\u2126\\uAB65]|\\uD800[\\uDD40-\\uDD8E\\uDDA0]|\\uD834[\\uDE00-\\uDE45]"
* )
* },
* }
* },
* }
*/
[Symbol.replace](str: string, replacer: string | ((...strs: string[]) => string)): string;
}
/**
* The class to find a pattern in strings as handling escape sequences.
* It ignores the found pattern if it's escaped with `\`.
*
* @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#patternmatcher-class}
*/
declare const PatternMatcher: new (pattern: RegExp, options?: {
escaped?: boolean;
}) => PatternMatcher;
export { PatternMatcher };
//# sourceMappingURL=PatternMatcher.d.ts.map

76
node_modules/@typescript-eslint/utils/_ts4.3/dist/ast-utils/eslint-utils/ReferenceTracker.d.ts generated vendored
View file

@ -1,76 +0,0 @@
import type * as TSESLint from '../../ts-eslint';
import type { TSESTree } from '../../ts-estree';
declare const ReferenceTrackerREAD: unique symbol;
declare const ReferenceTrackerCALL: unique symbol;
declare const ReferenceTrackerCONSTRUCT: unique symbol;
declare const ReferenceTrackerESM: unique symbol;
interface ReferenceTracker {
/**
* Iterate the references that the given `traceMap` determined.
* This method starts to search from global variables.
*
* @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#tracker-iterateglobalreferences}
*/
iterateGlobalReferences<T>(traceMap: ReferenceTracker.TraceMap<T>): IterableIterator<ReferenceTracker.FoundReference<T>>;
/**
* Iterate the references that the given `traceMap` determined.
* This method starts to search from `require()` expression.
*
* @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#tracker-iteratecjsreferences}
*/
iterateCjsReferences<T>(traceMap: ReferenceTracker.TraceMap<T>): IterableIterator<ReferenceTracker.FoundReference<T>>;
/**
* Iterate the references that the given `traceMap` determined.
* This method starts to search from `import`/`export` declarations.
*
* @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#tracker-iterateesmreferences}
*/
iterateEsmReferences<T>(traceMap: ReferenceTracker.TraceMap<T>): IterableIterator<ReferenceTracker.FoundReference<T>>;
}
interface ReferenceTrackerStatic {
new (globalScope: TSESLint.Scope.Scope, options?: {
/**
* The mode which determines how the `tracker.iterateEsmReferences()` method scans CommonJS modules.
* If this is `"strict"`, the method binds CommonJS modules to the default export. Otherwise, the method binds
* CommonJS modules to both the default export and named exports. Optional. Default is `"strict"`.
*/
mode?: 'legacy' | 'strict';
/**
* The name list of Global Object. Optional. Default is `["global", "globalThis", "self", "window"]`.
*/
globalObjectNames?: readonly string[];
}): ReferenceTracker;
readonly READ: typeof ReferenceTrackerREAD;
readonly CALL: typeof ReferenceTrackerCALL;
readonly CONSTRUCT: typeof ReferenceTrackerCONSTRUCT;
readonly ESM: typeof ReferenceTrackerESM;
}
declare namespace ReferenceTracker {
type READ = ReferenceTrackerStatic['READ'];
type CALL = ReferenceTrackerStatic['CALL'];
type CONSTRUCT = ReferenceTrackerStatic['CONSTRUCT'];
type ESM = ReferenceTrackerStatic['ESM'];
type ReferenceType = CALL | CONSTRUCT | READ;
type TraceMap<T = any> = Record<string, TraceMapElement<T>>;
interface TraceMapElement<T> {
[ReferenceTrackerREAD]?: T;
[ReferenceTrackerCALL]?: T;
[ReferenceTrackerCONSTRUCT]?: T;
[ReferenceTrackerESM]?: true;
[key: string]: TraceMapElement<T>;
}
interface FoundReference<T = any> {
node: TSESTree.Node;
path: readonly string[];
type: ReferenceType;
info: T;
}
}
/**
* The tracker for references. This provides reference tracking for global variables, CommonJS modules, and ES modules.
*
* @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#referencetracker-class}
*/
declare const ReferenceTracker: ReferenceTrackerStatic;
export { ReferenceTracker };
//# sourceMappingURL=ReferenceTracker.d.ts.map

76
node_modules/@typescript-eslint/utils/_ts4.3/dist/ast-utils/eslint-utils/astUtilities.d.ts generated vendored
View file

@ -1,76 +0,0 @@
import type * as TSESLint from '../../ts-eslint';
import type { TSESTree } from '../../ts-estree';
/**
* Get the proper location of a given function node to report.
*
* @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getfunctionheadlocation}
*/
declare const getFunctionHeadLocation: (node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression, sourceCode: TSESLint.SourceCode) => TSESTree.SourceLocation;
/**
* Get the name and kind of a given function node.
*
* @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getfunctionnamewithkind}
*/
declare const getFunctionNameWithKind: (node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression, sourceCode?: TSESLint.SourceCode) => string;
/**
* Get the property name of a given property node.
* If the node is a computed property, this tries to compute the property name by the getStringIfConstant function.
*
* @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getpropertyname}
* @returns The property name of the node. If the property name is not constant then it returns `null`.
*/
declare const getPropertyName: (node: TSESTree.MemberExpression | TSESTree.MethodDefinition | TSESTree.Property | TSESTree.PropertyDefinition, initialScope?: TSESLint.Scope.Scope) => string | null;
/**
* Get the value of a given node if it can decide the value statically.
* If the 2nd parameter `initialScope` was given, this function tries to resolve identifier references which are in the
* given node as much as possible. In the resolving way, it does on the assumption that built-in global objects have
* not been modified.
* For example, it considers `Symbol.iterator`, ` String.raw``hello`` `, and `Object.freeze({a: 1}).a` as static.
*
* @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getstaticvalue}
* @returns The `{ value: any }` shaped object. The `value` property is the static value. If it couldn't compute the
* static value of the node, it returns `null`.
*/
declare const getStaticValue: (node: TSESTree.Node, initialScope?: TSESLint.Scope.Scope) => {
value: unknown;
} | null;
/**
* Get the string value of a given node.
* This function is a tiny wrapper of the getStaticValue function.
*
* @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getstringifconstant}
*/
declare const getStringIfConstant: (node: TSESTree.Node, initialScope?: TSESLint.Scope.Scope) => string | null;
/**
* Check whether a given node has any side effect or not.
* The side effect means that it may modify a certain variable or object member. This function considers the node which
* contains the following types as the node which has side effects:
* - `AssignmentExpression`
* - `AwaitExpression`
* - `CallExpression`
* - `ImportExpression`
* - `NewExpression`
* - `UnaryExpression([operator = "delete"])`
* - `UpdateExpression`
* - `YieldExpression`
* - When `options.considerGetters` is `true`:
* - `MemberExpression`
* - When `options.considerImplicitTypeConversion` is `true`:
* - `BinaryExpression([operator = "==" | "!=" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "in"])`
* - `MemberExpression([computed = true])`
* - `MethodDefinition([computed = true])`
* - `Property([computed = true])`
* - `UnaryExpression([operator = "-" | "+" | "!" | "~"])`
*
* @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#hassideeffect}
*/
declare const hasSideEffect: (node: TSESTree.Node, sourceCode: TSESLint.SourceCode, options?: {
considerGetters?: boolean;
considerImplicitTypeConversion?: boolean;
}) => boolean;
declare const isParenthesized: {
(node: TSESTree.Node, sourceCode: TSESLint.SourceCode): boolean;
(times: number, node: TSESTree.Node, sourceCode: TSESLint.SourceCode): boolean;
};
export { getFunctionHeadLocation, getFunctionNameWithKind, getPropertyName, getStaticValue, getStringIfConstant, hasSideEffect, isParenthesized, };
//# sourceMappingURL=astUtilities.d.ts.map

6
node_modules/@typescript-eslint/utils/_ts4.3/dist/ast-utils/eslint-utils/index.d.ts generated vendored
View file

@ -1,6 +0,0 @@
export * from './astUtilities';
export * from './PatternMatcher';
export * from './predicates';
export * from './ReferenceTracker';
export * from './scopeAnalysis';
//# sourceMappingURL=index.d.ts.map

32
node_modules/@typescript-eslint/utils/_ts4.3/dist/ast-utils/eslint-utils/predicates.d.ts generated vendored
View file

@ -1,32 +0,0 @@
import type { TSESTree } from '../../ts-estree';
type IsSpecificTokenFunction<SpecificToken extends TSESTree.Token> = (token: TSESTree.Token) => token is SpecificToken;
type IsNotSpecificTokenFunction<SpecificToken extends TSESTree.Token> = (token: TSESTree.Token) => token is Exclude<TSESTree.Token, SpecificToken>;
type PunctuatorTokenWithValue<Value extends string> = TSESTree.PunctuatorToken & {
value: Value;
};
type IsPunctuatorTokenWithValueFunction<Value extends string> = IsSpecificTokenFunction<PunctuatorTokenWithValue<Value>>;
type IsNotPunctuatorTokenWithValueFunction<Value extends string> = IsNotSpecificTokenFunction<PunctuatorTokenWithValue<Value>>;
declare const isArrowToken: IsPunctuatorTokenWithValueFunction<"=>">;
declare const isNotArrowToken: IsNotPunctuatorTokenWithValueFunction<"=>">;
declare const isClosingBraceToken: IsPunctuatorTokenWithValueFunction<"}">;
declare const isNotClosingBraceToken: IsNotPunctuatorTokenWithValueFunction<"}">;
declare const isClosingBracketToken: IsPunctuatorTokenWithValueFunction<"]">;
declare const isNotClosingBracketToken: IsNotPunctuatorTokenWithValueFunction<"]">;
declare const isClosingParenToken: IsPunctuatorTokenWithValueFunction<")">;
declare const isNotClosingParenToken: IsNotPunctuatorTokenWithValueFunction<")">;
declare const isColonToken: IsPunctuatorTokenWithValueFunction<":">;
declare const isNotColonToken: IsNotPunctuatorTokenWithValueFunction<":">;
declare const isCommaToken: IsPunctuatorTokenWithValueFunction<",">;
declare const isNotCommaToken: IsNotPunctuatorTokenWithValueFunction<",">;
declare const isCommentToken: IsSpecificTokenFunction<TSESTree.Comment>;
declare const isNotCommentToken: IsNotSpecificTokenFunction<TSESTree.Comment>;
declare const isOpeningBraceToken: IsPunctuatorTokenWithValueFunction<"{">;
declare const isNotOpeningBraceToken: IsNotPunctuatorTokenWithValueFunction<"{">;
declare const isOpeningBracketToken: IsPunctuatorTokenWithValueFunction<"[">;
declare const isNotOpeningBracketToken: IsNotPunctuatorTokenWithValueFunction<"[">;
declare const isOpeningParenToken: IsPunctuatorTokenWithValueFunction<"(">;
declare const isNotOpeningParenToken: IsNotPunctuatorTokenWithValueFunction<"(">;
declare const isSemicolonToken: IsPunctuatorTokenWithValueFunction<";">;
declare const isNotSemicolonToken: IsNotPunctuatorTokenWithValueFunction<";">;
export { isArrowToken, isClosingBraceToken, isClosingBracketToken, isClosingParenToken, isColonToken, isCommaToken, isCommentToken, isNotArrowToken, isNotClosingBraceToken, isNotClosingBracketToken, isNotClosingParenToken, isNotColonToken, isNotCommaToken, isNotCommentToken, isNotOpeningBraceToken, isNotOpeningBracketToken, isNotOpeningParenToken, isNotSemicolonToken, isOpeningBraceToken, isOpeningBracketToken, isOpeningParenToken, isSemicolonToken, };
//# sourceMappingURL=predicates.d.ts.map

18
node_modules/@typescript-eslint/utils/_ts4.3/dist/ast-utils/eslint-utils/scopeAnalysis.d.ts generated vendored
View file

@ -1,18 +0,0 @@
import type * as TSESLint from '../../ts-eslint';
import type { TSESTree } from '../../ts-estree';
/**
* Get the variable of a given name.
*
* @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#findvariable}
*/
declare const findVariable: (initialScope: TSESLint.Scope.Scope, nameOrNode: TSESTree.Identifier | string) => TSESLint.Scope.Variable | null;
/**
* Get the innermost scope which contains a given node.
*
* @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#getinnermostscope}
* @returns The innermost scope which contains the given node.
* If such scope doesn't exist then it returns the 1st argument `initialScope`.
*/
declare const getInnermostScope: (initialScope: TSESLint.Scope.Scope, node: TSESTree.Node) => TSESLint.Scope.Scope;
export { findVariable, getInnermostScope };
//# sourceMappingURL=scopeAnalysis.d.ts.map

1207
node_modules/@typescript-eslint/utils/_ts4.3/dist/ast-utils/helpers.d.ts generated vendored
View file

File diff suppressed because it is too large Load diff

5
node_modules/@typescript-eslint/utils/_ts4.3/dist/ast-utils/index.d.ts generated vendored
View file

@ -1,5 +0,0 @@
export * from './eslint-utils';
export * from './helpers';
export * from './misc';
export * from './predicates';
//# sourceMappingURL=index.d.ts.map

8
node_modules/@typescript-eslint/utils/_ts4.3/dist/ast-utils/misc.d.ts generated vendored
View file

@ -1,8 +0,0 @@
import type { TSESTree } from '../ts-estree';
declare const LINEBREAK_MATCHER: RegExp;
/**
* Determines whether two adjacent tokens are on the same line
*/
declare function isTokenOnSameLine(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token): boolean;
export { isTokenOnSameLine, LINEBREAK_MATCHER };
//# sourceMappingURL=misc.d.ts.map

70
node_modules/@typescript-eslint/utils/_ts4.3/dist/ast-utils/predicates.d.ts generated vendored
View file

@ -1,70 +0,0 @@
import type { TSESTree } from '../ts-estree';
declare const isOptionalChainPunctuator: (token: TSESTree.Token | null | undefined) => token is {
value: "?.";
} & TSESTree.PunctuatorToken;
declare const isNotOptionalChainPunctuator: (token: TSESTree.Token | null | undefined) => token is TSESTree.BooleanToken | TSESTree.BlockComment | TSESTree.LineComment | TSESTree.IdentifierToken | TSESTree.JSXIdentifierToken | TSESTree.JSXTextToken | TSESTree.KeywordToken | TSESTree.NullToken | TSESTree.NumericToken | TSESTree.PunctuatorToken | TSESTree.RegularExpressionToken | TSESTree.StringToken | TSESTree.TemplateToken;
declare const isNonNullAssertionPunctuator: (token: TSESTree.Token | null | undefined) => token is {
value: "!";
} & TSESTree.PunctuatorToken;
declare const isNotNonNullAssertionPunctuator: (token: TSESTree.Token | null | undefined) => token is TSESTree.BooleanToken | TSESTree.BlockComment | TSESTree.LineComment | TSESTree.IdentifierToken | TSESTree.JSXIdentifierToken | TSESTree.JSXTextToken | TSESTree.KeywordToken | TSESTree.NullToken | TSESTree.NumericToken | TSESTree.PunctuatorToken | TSESTree.RegularExpressionToken | TSESTree.StringToken | TSESTree.TemplateToken;
/**
* Returns true if and only if the node represents: foo?.() or foo.bar?.()
*/
declare const isOptionalCallExpression: (node: TSESTree.Node | null | undefined) => node is {
optional: boolean;
} & TSESTree.CallExpression;
/**
* Returns true if and only if the node represents logical OR
*/
declare const isLogicalOrOperator: (node: TSESTree.Node | null | undefined) => node is Partial<TSESTree.LogicalExpression> & TSESTree.LogicalExpression;
/**
* Checks if a node is a type assertion:
* ```
* x as foo
* <foo>x
* ```
*/
declare const isTypeAssertion: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSAsExpression | TSESTree.TSTypeAssertion;
declare const isVariableDeclarator: (node: TSESTree.Node | null | undefined) => node is TSESTree.VariableDeclarator;
declare const isFunction: (node: TSESTree.Node | null | undefined) => node is TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | TSESTree.FunctionExpression;
declare const isFunctionType: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructorType | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSEmptyBodyFunctionExpression | TSESTree.TSFunctionType | TSESTree.TSMethodSignatureComputedName | TSESTree.TSMethodSignatureNonComputedName;
declare const isFunctionOrFunctionType: (node: TSESTree.Node | null | undefined) => node is TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | TSESTree.FunctionExpression | TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructorType | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSEmptyBodyFunctionExpression | TSESTree.TSFunctionType | TSESTree.TSMethodSignatureComputedName | TSESTree.TSMethodSignatureNonComputedName;
declare const isTSFunctionType: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSFunctionType;
declare const isTSConstructorType: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSConstructorType;
declare const isClassOrTypeElement: (node: TSESTree.Node | null | undefined) => node is TSESTree.FunctionExpression | TSESTree.MethodDefinitionComputedName | TSESTree.MethodDefinitionNonComputedName | TSESTree.PropertyDefinitionComputedName | TSESTree.PropertyDefinitionNonComputedName | TSESTree.TSAbstractMethodDefinitionComputedName | TSESTree.TSAbstractMethodDefinitionNonComputedName | TSESTree.TSAbstractPropertyDefinitionComputedName | TSESTree.TSAbstractPropertyDefinitionNonComputedName | TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSEmptyBodyFunctionExpression | TSESTree.TSIndexSignature | TSESTree.TSMethodSignatureComputedName | TSESTree.TSMethodSignatureNonComputedName | TSESTree.TSPropertySignatureComputedName | TSESTree.TSPropertySignatureNonComputedName;
/**
* Checks if a node is a constructor method.
*/
declare const isConstructor: (node: TSESTree.Node | null | undefined) => node is (Partial<TSESTree.MethodDefinitionComputedName> & TSESTree.MethodDefinitionComputedName) | (Partial<TSESTree.MethodDefinitionNonComputedName> & TSESTree.MethodDefinitionNonComputedName);
/**
* Checks if a node is a setter method.
*/
declare function isSetter(node: TSESTree.Node | undefined): node is {
kind: 'set';
} & (TSESTree.MethodDefinition | TSESTree.Property);
declare const isIdentifier: (node: TSESTree.Node | null | undefined) => node is TSESTree.Identifier;
/**
* Checks if a node represents an `await …` expression.
*/
declare const isAwaitExpression: (node: TSESTree.Node | null | undefined) => node is TSESTree.AwaitExpression;
/**
* Checks if a possible token is the `await` keyword.
*/
declare const isAwaitKeyword: (token: TSESTree.Token | null | undefined) => token is {
value: "await";
} & TSESTree.IdentifierToken;
/**
* Checks if a possible token is the `type` keyword.
*/
declare const isTypeKeyword: (token: TSESTree.Token | null | undefined) => token is {
value: "type";
} & TSESTree.IdentifierToken;
/**
* Checks if a possible token is the `import` keyword.
*/
declare const isImportKeyword: (token: TSESTree.Token | null | undefined) => token is {
value: "import";
} & TSESTree.KeywordToken;
declare const isLoop: (node: TSESTree.Node | null | undefined) => node is TSESTree.DoWhileStatement | TSESTree.ForInStatement | TSESTree.ForOfStatement | TSESTree.ForStatement | TSESTree.WhileStatement;
export { isAwaitExpression, isAwaitKeyword, isConstructor, isClassOrTypeElement, isFunction, isFunctionOrFunctionType, isFunctionType, isIdentifier, isImportKeyword, isLoop, isLogicalOrOperator, isNonNullAssertionPunctuator, isNotNonNullAssertionPunctuator, isNotOptionalChainPunctuator, isOptionalChainPunctuator, isOptionalCallExpression, isSetter, isTSConstructorType, isTSFunctionType, isTypeAssertion, isTypeKeyword, isVariableDeclarator, };
//# sourceMappingURL=predicates.d.ts.map

11
node_modules/@typescript-eslint/utils/_ts4.3/dist/eslint-utils/InferTypesFromRule.d.ts generated vendored
View file

@ -1,11 +0,0 @@
import type { RuleCreateFunction, RuleModule } from '../ts-eslint';
/**
* Uses type inference to fetch the TOptions type from the given RuleModule
*/
type InferOptionsTypeFromRule<T> = T extends RuleModule<infer _TMessageIds, infer TOptions> ? TOptions : T extends RuleCreateFunction<infer _TMessageIds, infer TOptions> ? TOptions : unknown;
/**
* Uses type inference to fetch the TMessageIds type from the given RuleModule
*/
type InferMessageIdsTypeFromRule<T> = T extends RuleModule<infer TMessageIds, infer _TOptions> ? TMessageIds : T extends RuleCreateFunction<infer TMessageIds, infer _TOptions> ? TMessageIds : unknown;
export { InferOptionsTypeFromRule, InferMessageIdsTypeFromRule };
//# sourceMappingURL=InferTypesFromRule.d.ts.map

35
node_modules/@typescript-eslint/utils/_ts4.3/dist/eslint-utils/RuleCreator.d.ts generated vendored
View file

@ -1,35 +0,0 @@
import type { RuleContext, RuleListener, RuleMetaData, RuleMetaDataDocs, RuleModule } from '../ts-eslint/Rule';
export type NamedCreateRuleMetaDocs = Omit<RuleMetaDataDocs, 'url'>;
export type NamedCreateRuleMeta<TMessageIds extends string> = Omit<RuleMetaData<TMessageIds>, 'docs'> & {
docs: NamedCreateRuleMetaDocs;
};
export interface RuleCreateAndOptions<TOptions extends readonly unknown[], TMessageIds extends string> {
create: (context: Readonly<RuleContext<TMessageIds, TOptions>>, optionsWithDefault: Readonly<TOptions>) => RuleListener;
defaultOptions: Readonly<TOptions>;
}
export interface RuleWithMeta<TOptions extends readonly unknown[], TMessageIds extends string> extends RuleCreateAndOptions<TOptions, TMessageIds> {
meta: RuleMetaData<TMessageIds>;
}
export interface RuleWithMetaAndName<TOptions extends readonly unknown[], TMessageIds extends string> extends RuleCreateAndOptions<TOptions, TMessageIds> {
meta: NamedCreateRuleMeta<TMessageIds>;
name: string;
}
/**
* Creates reusable function to create rules with default options and docs URLs.
*
* @param urlCreator Creates a documentation URL for a given rule name.
* @returns Function to create a rule with the docs URL format.
*/
export declare function RuleCreator(urlCreator: (ruleName: string) => string): <TOptions extends readonly unknown[], TMessageIds extends string>({ name, meta, ...rule }: Readonly<RuleWithMetaAndName<TOptions, TMessageIds>>) => RuleModule<TMessageIds, TOptions, RuleListener>;
export declare namespace RuleCreator {
var withoutDocs: typeof createRule;
}
/**
* Creates a well-typed TSESLint custom ESLint rule without a docs URL.
*
* @returns Well-typed TSESLint custom ESLint rule.
* @remarks It is generally better to provide a docs URL function to RuleCreator.
*/
declare function createRule<TOptions extends readonly unknown[], TMessageIds extends string>({ create, defaultOptions, meta, }: Readonly<RuleWithMeta<TOptions, TMessageIds>>): RuleModule<TMessageIds, TOptions>;
export {};
//# sourceMappingURL=RuleCreator.d.ts.map

10
node_modules/@typescript-eslint/utils/_ts4.3/dist/eslint-utils/applyDefault.d.ts generated vendored
View file

@ -1,10 +0,0 @@
/**
* Pure function - doesn't mutate either parameter!
* Uses the default options and overrides with the options provided by the user
* @param defaultOptions the defaults
* @param userOptions the user opts
* @returns the options with defaults
*/
declare function applyDefault<TUser extends readonly unknown[], TDefault extends TUser>(defaultOptions: Readonly<TDefault>, userOptions: Readonly<TUser> | null): TDefault;
export { applyDefault };
//# sourceMappingURL=applyDefault.d.ts.map

17
node_modules/@typescript-eslint/utils/_ts4.3/dist/eslint-utils/deepMerge.d.ts generated vendored
View file

@ -1,17 +0,0 @@
type ObjectLike<T = unknown> = Record<string, T>;
/**
* Check if the variable contains an object strictly rejecting arrays
* @param obj an object
* @returns `true` if obj is an object
*/
declare function isObjectNotArray<T extends ObjectLike>(obj: unknown): obj is T;
/**
* Pure function - doesn't mutate either parameter!
* Merges two objects together deeply, overwriting the properties in first with the properties in second
* @param first The first object
* @param second The second object
* @returns a new object
*/
export declare function deepMerge(first?: ObjectLike, second?: ObjectLike): Record<string, unknown>;
export { isObjectNotArray };
//# sourceMappingURL=deepMerge.d.ts.map

24
node_modules/@typescript-eslint/utils/_ts4.3/dist/eslint-utils/getParserServices.d.ts generated vendored
View file

@ -1,24 +0,0 @@
import type * as TSESLint from '../ts-eslint';
import type { ParserServices, ParserServicesWithTypeInformation } from '../ts-estree';
/**
* Try to retrieve type-aware parser service from context.
* This **_will_** throw if it is not available.
*/
declare function getParserServices<TMessageIds extends string, TOptions extends readonly unknown[]>(context: Readonly<TSESLint.RuleContext<TMessageIds, TOptions>>): ParserServicesWithTypeInformation;
/**
* Try to retrieve type-aware parser service from context.
* This **_will_** throw if it is not available.
*/
declare function getParserServices<TMessageIds extends string, TOptions extends readonly unknown[]>(context: Readonly<TSESLint.RuleContext<TMessageIds, TOptions>>, allowWithoutFullTypeInformation: false): ParserServicesWithTypeInformation;
/**
* Try to retrieve type-aware parser service from context.
* This **_will not_** throw if it is not available.
*/
declare function getParserServices<TMessageIds extends string, TOptions extends readonly unknown[]>(context: Readonly<TSESLint.RuleContext<TMessageIds, TOptions>>, allowWithoutFullTypeInformation: true): ParserServices;
/**
* Try to retrieve type-aware parser service from context.
* This may or may not throw if it is not available, depending on if `allowWithoutFullTypeInformation` is `true`
*/
declare function getParserServices<TMessageIds extends string, TOptions extends readonly unknown[]>(context: Readonly<TSESLint.RuleContext<TMessageIds, TOptions>>, allowWithoutFullTypeInformation: boolean): ParserServices;
export { getParserServices };
//# sourceMappingURL=getParserServices.d.ts.map

7
node_modules/@typescript-eslint/utils/_ts4.3/dist/eslint-utils/index.d.ts generated vendored
View file

@ -1,7 +0,0 @@
export * from './applyDefault';
export * from './getParserServices';
export * from './InferTypesFromRule';
export * from './RuleCreator';
export * from './deepMerge';
export * from './nullThrows';
//# sourceMappingURL=index.d.ts.map

14
node_modules/@typescript-eslint/utils/_ts4.3/dist/eslint-utils/nullThrows.d.ts generated vendored
View file

@ -1,14 +0,0 @@
/**
* A set of common reasons for calling nullThrows
*/
declare const NullThrowsReasons: {
readonly MissingParent: "Expected node to have a parent.";
readonly MissingToken: (token: string, thing: string) => string;
};
/**
* Assert that a value must not be null or undefined.
* This is a nice explicit alternative to the non-null assertion operator.
*/
declare function nullThrows<T>(value: T | null | undefined, message: string): T;
export { nullThrows, NullThrowsReasons };
//# sourceMappingURL=nullThrows.d.ts.map

8
node_modules/@typescript-eslint/utils/_ts4.3/dist/index.d.ts generated vendored
View file

@ -1,8 +0,0 @@
import * as ASTUtils from './ast-utils';
import * as ESLintUtils from './eslint-utils';
import * as JSONSchema from './json-schema';
import * as TSESLint from './ts-eslint';
import * as TSUtils from './ts-utils';
export { ASTUtils, ESLintUtils, JSONSchema, TSESLint, TSUtils };
export * from './ts-estree';
//# sourceMappingURL=index.d.ts.map

388
node_modules/@typescript-eslint/utils/_ts4.3/dist/json-schema.d.ts generated vendored
View file

@ -1,388 +0,0 @@
/**
* This is a fork of https://github.com/DefinitelyTyped/DefinitelyTyped/blob/13f63c2eb8d7479caf01ab8d72f9e3683368a8f5/types/json-schema/index.d.ts
* We intentionally fork this because:
* - ESLint ***ONLY*** supports JSONSchema v4
* - We want to provide stricter types
*/
/**
* @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1
*/
export type JSONSchema4TypeName = 'any' | 'array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string';
/**
* @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-3.5
*/
export type JSONSchema4Type = boolean | number | string | null;
export type JSONSchema4TypeExtended = JSONSchema4Type | JSONSchema4Array | JSONSchema4Object;
export interface JSONSchema4Object {
[key: string]: JSONSchema4TypeExtended;
}
export interface JSONSchema4Array extends Array<JSONSchema4TypeExtended> {
}
/**
* Meta schema
*
* Recommended values:
* - 'http://json-schema.org/schema#'
* - 'http://json-schema.org/hyper-schema#'
* - 'http://json-schema.org/draft-04/schema#'
* - 'http://json-schema.org/draft-04/hyper-schema#'
* - 'http://json-schema.org/draft-03/schema#'
* - 'http://json-schema.org/draft-03/hyper-schema#'
*
* @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
*/
export type JSONSchema4Version = string;
/**
* JSON Schema V4
* @see https://tools.ietf.org/html/draft-zyp-json-schema-04
*/
export type JSONSchema4 = JSONSchema4AllOfSchema | JSONSchema4AnyOfSchema | JSONSchema4AnySchema | JSONSchema4ArraySchema | JSONSchema4BooleanSchema | JSONSchema4MultiSchema | JSONSchema4NullSchema | JSONSchema4NumberSchema | JSONSchema4ObjectSchema | JSONSchema4OneOfSchema | JSONSchema4RefSchema | JSONSchema4StringSchema;
interface JSONSchema4Base {
id?: string | undefined;
$schema?: JSONSchema4Version | undefined;
/**
* A single type, or a union of simple types
*/
type?: JSONSchema4TypeName | JSONSchema4TypeName[] | undefined;
/**
* Path to a schema defined in `definitions`/`$defs` that will form the base
* for this schema.
*
* If you are defining an "array" schema (`schema: [ ... ]`) for your rule
* then you should prefix this with `items/0` so that the validator can find
* your definitions.
*
* eg: `'#/items/0/definitions/myDef'`
*
* Otherwise if you are defining an "object" schema (`schema: { ... }`) for
* your rule you can directly reference your definitions
*
* eg: `'#/definitions/myDef'`
*/
$ref?: string | undefined;
/**
* This attribute is a string that provides a short description of the
* instance property.
*
* @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.21
*/
title?: string | undefined;
/**
* This attribute is a string that provides a full description of the of
* purpose the instance property.
*
* @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.22
*/
description?: string | undefined;
/**
* Reusable definitions that can be referenced via `$ref`
*/
definitions?: Record<string, JSONSchema4> | undefined;
/**
* Reusable definitions that can be referenced via `$ref`
*/
$defs?: Record<string, JSONSchema4> | undefined;
/**
* The value of this property MUST be another schema which will provide
* a base schema which the current schema will inherit from. The
* inheritance rules are such that any instance that is valid according
* to the current schema MUST be valid according to the referenced
* schema. This MAY also be an array, in which case, the instance MUST
* be valid for all the schemas in the array. A schema that extends
* another schema MAY define additional attributes, constrain existing
* attributes, or add other constraints.
*
* Conceptually, the behavior of extends can be seen as validating an
* instance against all constraints in the extending schema as well as
* the extended schema(s).
*
* @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.26
*/
extends?: string[] | string | undefined;
/**
* The default value for the item if not present
*/
default?: JSONSchema4TypeExtended | undefined;
/**
* This attribute indicates if the instance must have a value, and not
* be undefined. This is false by default, making the instance
* optional.
*
* @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.7
*/
required?: string[] | boolean | undefined;
/**
* (NOT) Must not be valid against the given schema
*/
not?: JSONSchema4 | undefined;
/**
* (AND) Must be valid against all of the sub-schemas
*/
allOf?: JSONSchema4[] | undefined;
/**
* (OR) Must be valid against any of the sub-schemas
*/
anyOf?: JSONSchema4[] | undefined;
/**
* (XOR) Must be valid against exactly one of the sub-schemas
*/
oneOf?: JSONSchema4[] | undefined;
}
export interface JSONSchema4RefSchema extends JSONSchema4Base {
type?: undefined;
$ref: string;
}
export interface JSONSchema4AllOfSchema extends JSONSchema4Base {
type?: undefined;
allOf: JSONSchema4[];
}
export interface JSONSchema4AnyOfSchema extends JSONSchema4Base {
type?: undefined;
anyOf: JSONSchema4[];
}
export interface JSONSchema4OneOfSchema extends JSONSchema4Base {
type?: undefined;
oneOf: JSONSchema4[];
}
export interface JSONSchema4MultiSchema extends Omit<JSONSchema4ObjectSchema, 'enum' | 'type'>, Omit<JSONSchema4ArraySchema, 'enum' | 'type'>, Omit<JSONSchema4StringSchema, 'enum' | 'type'>, Omit<JSONSchema4NumberSchema, 'enum' | 'type'>, Omit<JSONSchema4BooleanSchema, 'enum' | 'type'>, Omit<JSONSchema4NullSchema, 'enum' | 'type'>, Omit<JSONSchema4AnySchema, 'enum' | 'type'> {
type: JSONSchema4TypeName[];
/**
* This provides an enumeration of all possible values that are valid
* for the instance property. This MUST be an array, and each item in
* the array represents a possible value for the instance value. If
* this attribute is defined, the instance value MUST be one of the
* values in the array in order for the schema to be valid.
*
* @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19
*/
enum?: JSONSchema4Type[];
}
/**
* @see https://json-schema.org/understanding-json-schema/reference/object.html
*/
export interface JSONSchema4ObjectSchema extends JSONSchema4Base {
type: 'object';
/**
* This attribute defines a schema for all properties that are not
* explicitly defined in an object type definition. If specified, the
* value MUST be a schema or a boolean. If false is provided, no
* additional properties are allowed beyond the properties defined in
* the schema. The default value is an empty schema which allows any
* value for additional properties.
*
* @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.4
*/
additionalProperties?: JSONSchema4 | boolean | undefined;
/**
* This attribute is an object with property definitions that define the
* valid values of instance object property values. When the instance
* value is an object, the property values of the instance object MUST
* conform to the property definitions in this object. In this object,
* each property definition's value MUST be a schema, and the property's
* name MUST be the name of the instance property that it defines. The
* instance property value MUST be valid according to the schema from
* the property definition. Properties are considered unordered, the
* order of the instance properties MAY be in any order.
*
* @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.2
*/
properties?: Record<string, JSONSchema4> | undefined;
/**
* This attribute is an object that defines the schema for a set of
* property names of an object instance. The name of each property of
* this attribute's object is a regular expression pattern in the ECMA
* 262/Perl 5 format, while the value is a schema. If the pattern
* matches the name of a property on the instance object, the value of
* the instance's property MUST be valid against the pattern name's
* schema value.
*
* @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.3
*/
patternProperties?: Record<string, JSONSchema4> | undefined;
/**
* The `dependencies` keyword conditionally applies a sub-schema when a given
* property is present. This schema is applied in the same way `allOf` applies
* schemas. Nothing is merged or extended. Both schemas apply independently.
*/
dependencies?: Record<string, JSONSchema4 | string[]> | undefined;
/**
* The maximum number of properties allowed for record-style schemas
*/
maxProperties?: number | undefined;
/**
* The minimum number of properties required for record-style schemas
*/
minProperties?: number | undefined;
}
/**
* @see https://json-schema.org/understanding-json-schema/reference/array.html
*/
export interface JSONSchema4ArraySchema extends JSONSchema4Base {
type: 'array';
/**
* May only be defined when "items" is defined, and is a tuple of JSONSchemas.
*
* This provides a definition for additional items in an array instance
* when tuple definitions of the items is provided. This can be false
* to indicate additional items in the array are not allowed, or it can
* be a schema that defines the schema of the additional items.
*
* @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.6
*/
additionalItems?: JSONSchema4 | boolean | undefined;
/**
* This attribute defines the allowed items in an instance array, and
* MUST be a schema or an array of schemas. The default value is an
* empty schema which allows any value for items in the instance array.
*
* When this attribute value is a schema and the instance value is an
* array, then all the items in the array MUST be valid according to the
* schema.
*
* When this attribute value is an array of schemas and the instance
* value is an array, each position in the instance array MUST conform
* to the schema in the corresponding position for this array. This
* called tuple typing. When tuple typing is used, additional items are
* allowed, disallowed, or constrained by the "additionalItems"
* (Section 5.6) attribute using the same rules as
* "additionalProperties" (Section 5.4) for objects.
*
* @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.5
*/
items?: JSONSchema4 | JSONSchema4[] | undefined;
/**
* Defines the maximum length of an array
*/
maxItems?: number | undefined;
/**
* Defines the minimum length of an array
*/
minItems?: number | undefined;
/**
* Enforces that all items in the array are unique
*/
uniqueItems?: boolean | undefined;
}
/**
* @see https://json-schema.org/understanding-json-schema/reference/string.html
*/
export interface JSONSchema4StringSchema extends JSONSchema4Base {
type: 'string';
/**
* The maximum allowed length for the string
*/
maxLength?: number | undefined;
/**
* The minimum allowed length for the string
*/
minLength?: number | undefined;
/**
* The `pattern` keyword is used to restrict a string to a particular regular
* expression. The regular expression syntax is the one defined in JavaScript
* (ECMA 262 specifically) with Unicode support.
*
* When defining the regular expressions, it’s important to note that the
* string is considered valid if the expression matches anywhere within the
* string. For example, the regular expression "p" will match any string with
* a p in it, such as "apple" not just a string that is simply "p". Therefore,
* it is usually less confusing, as a matter of course, to surround the
* regular expression in ^...$, for example, "^p$", unless there is a good
* reason not to do so.
*/
pattern?: string | undefined;
/**
* The `format` keyword allows for basic semantic identification of certain
* kinds of string values that are commonly used.
*
* For example, because JSON doesn’t have a “DateTime” type, dates need to be
* encoded as strings. `format` allows the schema author to indicate that the
* string value should be interpreted as a date.
*
* ajv v6 provides a few built-in formats - all other strings will cause AJV
* to throw during schema compilation
*/
format?: 'date-time' | 'date' | 'email' | 'hostname' | 'ipv4' | 'ipv6' | 'json-pointer-uri-fragment' | 'json-pointer' | 'regex' | 'relative-json-pointer' | 'time' | 'uri-reference' | 'uri-template' | 'uri' | 'url' | 'uuid' | undefined;
enum?: string[] | undefined;
}
/**
* @see https://json-schema.org/understanding-json-schema/reference/numeric.html
*/
export interface JSONSchema4NumberSchema extends JSONSchema4Base {
type: 'integer' | 'number';
/**
* Numbers can be restricted to a multiple of a given number, using the
* `multipleOf` keyword. It may be set to any positive number.
*/
multipleOf?: number | undefined;
/**
* The maximum allowed value for the number
*/
maximum?: number | undefined;
/**
* The minimum allowed value for the number
*/
minimum?: number | undefined;
/**
* The exclusive minimum allowed value for the number
* - `true` = `x < maximum`
* - `false` = `x <= maximum`
*
* Default is `false`
*/
exclusiveMaximum?: boolean | undefined;
/**
* Indicates whether or not `minimum` is the inclusive or exclusive minimum
* - `true` = `x > minimum`
* - `false` = `x ≥ minimum`
*
* Default is `false`
*/
exclusiveMinimum?: boolean | undefined;
/**
* This provides an enumeration of all possible values that are valid
* for the instance property. This MUST be an array, and each item in
* the array represents a possible value for the instance value. If
* this attribute is defined, the instance value MUST be one of the
* values in the array in order for the schema to be valid.
*
* @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19
*/
enum?: number[] | undefined;
}
/**
* @see https://json-schema.org/understanding-json-schema/reference/boolean.html
*/
export interface JSONSchema4BooleanSchema extends JSONSchema4Base {
type: 'boolean';
/**
* This provides an enumeration of all possible values that are valid
* for the instance property. This MUST be an array, and each item in
* the array represents a possible value for the instance value. If
* this attribute is defined, the instance value MUST be one of the
* values in the array in order for the schema to be valid.
*
* @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19
*/
enum?: boolean[] | undefined;
}
/**
* @see https://json-schema.org/understanding-json-schema/reference/null.html
*/
export interface JSONSchema4NullSchema extends JSONSchema4Base {
type: 'null';
/**
* This provides an enumeration of all possible values that are valid
* for the instance property. This MUST be an array, and each item in
* the array represents a possible value for the instance value. If
* this attribute is defined, the instance value MUST be one of the
* values in the array in order for the schema to be valid.
*
* @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19
*/
enum?: null[] | undefined;
}
export interface JSONSchema4AnySchema extends JSONSchema4Base {
type: 'any';
}
export {};
//# sourceMappingURL=json-schema.d.ts.map

9
node_modules/@typescript-eslint/utils/_ts4.3/dist/ts-eslint/AST.d.ts generated vendored
View file

@ -1,9 +0,0 @@
import type { AST_TOKEN_TYPES, TSESTree } from '../ts-estree';
declare namespace AST {
type TokenType = AST_TOKEN_TYPES;
type Token = TSESTree.Token;
type SourceLocation = TSESTree.SourceLocation;
type Range = TSESTree.Range;
}
export { AST };
//# sourceMappingURL=AST.d.ts.map

131
node_modules/@typescript-eslint/utils/_ts4.3/dist/ts-eslint/CLIEngine.d.ts generated vendored
View file

@ -1,131 +0,0 @@
import type { Linter } from './Linter';
import type { RuleMetaData, RuleModule } from './Rule';
declare namespace CLIEngine {
interface Options {
allowInlineConfig?: boolean;
baseConfig?: false | Record<string, unknown>;
cache?: boolean;
cacheFile?: string;
cacheLocation?: string;
configFile?: string;
cwd?: string;
envs?: string[];
errorOnUnmatchedPattern?: boolean;
extensions?: string[];
fix?: boolean;
globals?: string[];
ignore?: boolean;
ignorePath?: string;
ignorePattern?: string[] | string;
useEslintrc?: boolean;
parser?: string;
parserOptions?: Linter.ParserOptions;
plugins?: string[];
resolvePluginsRelativeTo?: string;
rules?: Record<string, Linter.RuleLevel | Linter.RuleLevelAndOptions>;
rulePaths?: string[];
reportUnusedDisableDirectives?: boolean;
}
interface LintResult {
filePath: string;
messages: Linter.LintMessage[];
errorCount: number;
warningCount: number;
fixableErrorCount: number;
fixableWarningCount: number;
output?: string;
source?: string;
}
interface LintReport {
results: LintResult[];
errorCount: number;
warningCount: number;
fixableErrorCount: number;
fixableWarningCount: number;
usedDeprecatedRules: DeprecatedRuleUse[];
}
interface DeprecatedRuleUse {
ruleId: string;
replacedBy: string[];
}
interface LintResultData<TMessageIds extends string> {
rulesMeta: Record<string, RuleMetaData<TMessageIds>>;
}
type Formatter = <TMessageIds extends string>(results: LintResult[], data?: LintResultData<TMessageIds>) => string;
}
/**
* The underlying utility that runs the ESLint command line interface. This object will read the filesystem for
* configuration and file information but will not output any results. Instead, it allows you direct access to the
* important information so you can deal with the output yourself.
* @deprecated use the ESLint class instead
*/
declare const CLIEngine: {
new (options: CLIEngine.Options): {
/**
* Add a plugin by passing its configuration
* @param name Name of the plugin.
* @param pluginObject Plugin configuration object.
*/
addPlugin(name: string, pluginObject: Linter.Plugin): void;
/**
* Executes the current configuration on an array of file and directory names.
* @param patterns An array of file and directory names.
* @returns The results for all files that were linted.
*/
executeOnFiles(patterns: string[]): CLIEngine.LintReport;
/**
* Executes the current configuration on text.
* @param text A string of JavaScript code to lint.
* @param filename An optional string representing the texts filename.
* @param warnIgnored Always warn when a file is ignored
* @returns The results for the linting.
*/
executeOnText(text: string, filename?: string, warnIgnored?: boolean): CLIEngine.LintReport;
/**
* Returns a configuration object for the given file based on the CLI options.
* This is the same logic used by the ESLint CLI executable to determine configuration for each file it processes.
* @param filePath The path of the file to retrieve a config object for.
* @returns A configuration object for the file.
*/
getConfigForFile(filePath: string): Linter.Config;
/**
* Returns the formatter representing the given format.
* @param format The name of the format to load or the path to a custom formatter.
* @returns The formatter function.
*/
getFormatter(format?: string): CLIEngine.Formatter;
/**
* Checks if a given path is ignored by ESLint.
* @param filePath The path of the file to check.
* @returns Whether or not the given path is ignored.
*/
isPathIgnored(filePath: string): boolean;
/**
* Resolves the patterns passed into `executeOnFiles()` into glob-based patterns for easier handling.
* @param patterns The file patterns passed on the command line.
* @returns The equivalent glob patterns.
*/
resolveFileGlobPatterns(patterns: string[]): string[];
getRules<TMessageIds extends string = string, TOptions extends readonly unknown[] = unknown[]>(): Map<string, RuleModule<TMessageIds, TOptions, import("./Rule").RuleListener>>;
};
/**
* Returns results that only contains errors.
* @param results The results to filter.
* @returns The filtered results.
*/
getErrorResults(results: CLIEngine.LintResult[]): CLIEngine.LintResult[];
/**
* Returns the formatter representing the given format or null if the `format` is not a string.
* @param format The name of the format to load or the path to a custom formatter.
* @returns The formatter function.
*/
getFormatter(format?: string): CLIEngine.Formatter;
/**
* Outputs fixes from the given results to files.
* @param report The report object created by CLIEngine.
*/
outputFixes(report: CLIEngine.LintReport): void;
version: string;
} | undefined;
export { CLIEngine };
//# sourceMappingURL=CLIEngine.d.ts.map

376
node_modules/@typescript-eslint/utils/_ts4.3/dist/ts-eslint/ESLint.d.ts generated vendored
View file

@ -1,376 +0,0 @@
import type { Linter } from './Linter';
declare class ESLintBase {
/**
* Creates a new instance of the main ESLint API.
* @param options The options for this instance.
*/
constructor(options?: ESLint.ESLintOptions);
/**
* This method calculates the configuration for a given file, which can be useful for debugging purposes.
* - It resolves and merges extends and overrides settings into the top level configuration.
* - It resolves the parser setting to absolute paths.
* - It normalizes the plugins setting to align short names. (e.g., eslint-plugin-foo → foo)
* - It adds the processor setting if a legacy file extension processor is matched.
* - It doesn't interpret the env setting to the globals and parserOptions settings, so the result object contains
* the env setting as is.
* @param filePath The path to the file whose configuration you would like to calculate. Directory paths are forbidden
* because ESLint cannot handle the overrides setting.
* @returns The promise that will be fulfilled with a configuration object.
*/
calculateConfigForFile(filePath: string): Promise<Linter.Config>;
/**
* This method checks if a given file is ignored by your configuration.
* @param filePath The path to the file you want to check.
* @returns The promise that will be fulfilled with whether the file is ignored or not. If the file is ignored, then
* it will return true.
*/
isPathIgnored(filePath: string): Promise<boolean>;
/**
* This method lints the files that match the glob patterns and then returns the results.
* @param patterns The lint target files. This can contain any of file paths, directory paths, and glob patterns.
* @returns The promise that will be fulfilled with an array of LintResult objects.
*/
lintFiles(patterns: string[] | string): Promise<ESLint.LintResult[]>;
/**
* This method lints the given source code text and then returns the results.
*
* By default, this method uses the configuration that applies to files in the current working directory (the cwd
* constructor option). If you want to use a different configuration, pass options.filePath, and ESLint will load the
* same configuration that eslint.lintFiles() would use for a file at options.filePath.
*
* If the options.filePath value is configured to be ignored, this method returns an empty array. If the
* options.warnIgnored option is set along with the options.filePath option, this method returns a LintResult object.
* In that case, the result may contain a warning that indicates the file was ignored.
* @param code The source code text to check.
* @param options The options.
* @returns The promise that will be fulfilled with an array of LintResult objects. This is an array (despite there
* being only one lint result) in order to keep the interfaces between this and the eslint.lintFiles()
* method similar.
*/
lintText(code: string, options?: ESLint.LintTextOptions): Promise<ESLint.LintResult[]>;
/**
* This method loads a formatter. Formatters convert lint results to a human- or machine-readable string.
* @param name TThe path to the file you want to check.
* The following values are allowed:
* - undefined. In this case, loads the "stylish" built-in formatter.
* - A name of built-in formatters.
* - A name of third-party formatters. For examples:
* -- `foo` will load eslint-formatter-foo.
* -- `@foo` will load `@foo/eslint-formatter`.
* -- `@foo/bar` will load `@foo/eslint-formatter-bar`.
* - A path to the file that defines a formatter. The path must contain one or more path separators (/) in order to distinguish if it's a path or not. For example, start with ./.
* @returns The promise that will be fulfilled with a Formatter object.
*/
loadFormatter(name?: string): Promise<ESLint.Formatter>;
/**
* This method copies the given results and removes warnings. The returned value contains only errors.
* @param results The LintResult objects to filter.
* @returns The filtered LintResult objects.
*/
static getErrorResults(results: ESLint.LintResult): ESLint.LintResult;
/**
* This method writes code modified by ESLint's autofix feature into its respective file. If any of the modified
* files don't exist, this method does nothing.
* @param results The LintResult objects to write.
* @returns The promise that will be fulfilled after all files are written.
*/
static outputFixes(results: ESLint.LintResult): Promise<void>;
/**
* The version text.
*/
static readonly version: string;
}
declare namespace ESLint {
interface ESLintOptions {
/**
* If false is present, ESLint suppresses directive comments in source code.
* If this option is false, it overrides the noInlineConfig setting in your configurations.
*/
allowInlineConfig?: boolean;
/**
* Configuration object, extended by all configurations used with this instance.
* You can use this option to define the default settings that will be used if your configuration files don't
* configure it.
*/
baseConfig?: Linter.Config | null;
/**
* If true is present, the eslint.lintFiles() method caches lint results and uses it if each target file is not
* changed. Please mind that ESLint doesn't clear the cache when you upgrade ESLint plugins. In that case, you have
* to remove the cache file manually. The eslint.lintText() method doesn't use caches even if you pass the
* options.filePath to the method.
*/
cache?: boolean;
/**
* The eslint.lintFiles() method writes caches into this file.
*/
cacheLocation?: string;
/**
* The working directory. This must be an absolute path.
*/
cwd?: string;
/**
* Unless set to false, the eslint.lintFiles() method will throw an error when no target files are found.
*/
errorOnUnmatchedPattern?: boolean;
/**
* If you pass directory paths to the eslint.lintFiles() method, ESLint checks the files in those directories that
* have the given extensions. For example, when passing the src/ directory and extensions is [".js", ".ts"], ESLint
* will lint *.js and *.ts files in src/. If extensions is null, ESLint checks *.js files and files that match
* overrides[].files patterns in your configuration.
* Note: This option only applies when you pass directory paths to the eslint.lintFiles() method.
* If you pass glob patterns, ESLint will lint all files matching the glob pattern regardless of extension.
*/
extensions?: string[] | null;
/**
* If true is present, the eslint.lintFiles() and eslint.lintText() methods work in autofix mode.
* If a predicate function is present, the methods pass each lint message to the function, then use only the
* lint messages for which the function returned true.
*/
fix?: boolean | ((message: ESLint.LintMessage) => boolean);
/**
* The types of the rules that the eslint.lintFiles() and eslint.lintText() methods use for autofix.
*/
fixTypes?: ('directive' | 'layout' | 'problem' | 'suggestion')[] | null;
/**
* If false is present, the eslint.lintFiles() method doesn't interpret glob patterns.
*/
globInputPaths?: boolean;
/**
* If false is present, the eslint.lintFiles() method doesn't respect `.eslintignore` files or ignorePatterns in
* your configuration.
*/
ignore?: boolean;
/**
* The path to a file ESLint uses instead of `$CWD/.eslintignore`.
* If a path is present and the file doesn't exist, this constructor will throw an error.
*/
ignorePath?: string;
/**
* Configuration object, overrides all configurations used with this instance.
* You can use this option to define the settings that will be used even if your configuration files configure it.
*/
overrideConfig?: Linter.ConfigOverride | null;
/**
* The path to a configuration file, overrides all configurations used with this instance.
* The options.overrideConfig option is applied after this option is applied.
*/
overrideConfigFile?: string | null;
/**
* The plugin implementations that ESLint uses for the plugins setting of your configuration.
* This is a map-like object. Those keys are plugin IDs and each value is implementation.
*/
plugins?: Record<string, Linter.Plugin> | null;
/**
* The severity to report unused eslint-disable directives.
* If this option is a severity, it overrides the reportUnusedDisableDirectives setting in your configurations.
*/
reportUnusedDisableDirectives?: Linter.SeverityString | null;
/**
* The path to a directory where plugins should be resolved from.
* If null is present, ESLint loads plugins from the location of the configuration file that contains the plugin
* setting.
* If a path is present, ESLint loads all plugins from there.
*/
resolvePluginsRelativeTo?: string | null;
/**
* An array of paths to directories to load custom rules from.
*/
rulePaths?: string[];
/**
* If false is present, ESLint doesn't load configuration files (.eslintrc.* files).
* Only the configuration of the constructor options is valid.
*/
useEslintrc?: boolean;
}
interface DeprecatedRuleInfo {
/**
* The rule ID.
*/
ruleId: string;
/**
* The rule IDs that replace this deprecated rule.
*/
replacedBy: string[];
}
/**
* The LintResult value is the information of the linting result of each file.
*/
interface LintResult {
/**
* The number of errors. This includes fixable errors.
*/
errorCount: number;
/**
* The number of fatal errors.
* @since 7.32.0
*/
fatalErrorCount?: number;
/**
* The absolute path to the file of this result. This is the string "<text>" if the file path is unknown (when you
* didn't pass the options.filePath option to the eslint.lintText() method).
*/
filePath: string;
/**
* The number of errors that can be fixed automatically by the fix constructor option.
*/
fixableErrorCount: number;
/**
* The number of warnings that can be fixed automatically by the fix constructor option.
*/
fixableWarningCount: number;
/**
* The array of LintMessage objects.
*/
messages: ESLint.LintMessage[];
/**
* The source code of the file that was linted, with as many fixes applied as possible.
*/
output?: string;
/**
* The original source code text. This property is undefined if any messages didn't exist or the output
* property exists.
*/
source?: string;
/**
* The array of SuppressedLintMessage objects.
*
* @since 8.8.0
*/
suppressedMessages?: SuppressedLintMessage[];
/**
* The information about the deprecated rules that were used to check this file.
*/
usedDeprecatedRules: DeprecatedRuleInfo[];
/**
* The number of warnings. This includes fixable warnings.
*/
warningCount: number;
}
interface LintTextOptions {
/**
* The path to the file of the source code text. If omitted, the result.filePath becomes the string "<text>".
*/
filePath?: string;
/**
* If true is present and the options.filePath is a file ESLint should ignore, this method returns a lint result
* contains a warning message.
*/
warnIgnored?: boolean;
}
/**
* The LintMessage value is the information of each linting error.
*/
interface LintMessage {
/**
* The 1-based column number of the begin point of this message.
*/
column: number | undefined;
/**
* The 1-based column number of the end point of this message. This property is undefined if this message
* is not a range.
*/
endColumn: number | undefined;
/**
* The 1-based line number of the end point of this message. This property is undefined if this
* message is not a range.
*/
endLine: number | undefined;
/**
* `true` if this is a fatal error unrelated to a rule, like a parsing error.
* @since 7.24.0
*/
fatal?: boolean | undefined;
/**
* The EditInfo object of autofix. This property is undefined if this message is not fixable.
*/
fix: EditInfo | undefined;
/**
* The 1-based line number of the begin point of this message.
*/
line: number | undefined;
/**
* The error message
*/
message: string;
/**
* The rule name that generates this lint message. If this message is generated by the ESLint core rather than
* rules, this is null.
*/
ruleId: string | null;
/**
* The severity of this message. 1 means warning and 2 means error.
*/
severity: 1 | 2;
/**
* The list of suggestions. Each suggestion is the pair of a description and an EditInfo object to fix code. API
* users such as editor integrations can choose one of them to fix the problem of this message. This property is
* undefined if this message doesn't have any suggestions.
*/
suggestions: {
desc: string;
fix: EditInfo;
}[] | undefined;
}
/**
* The SuppressedLintMessage value is the information of each suppressed linting error.
*/
interface SuppressedLintMessage extends ESLint.LintMessage {
/**
* The list of suppressions.
*/
suppressions?: {
/**
* Right now, this is always `directive`
*/
kind: string;
/**
* The free text description added after the `--` in the comment
*/
justification: string;
}[];
}
/**
* The EditInfo value is information to edit text.
*
* This edit information means replacing the range of the range property by the text property value. It's like
* sourceCodeText.slice(0, edit.range[0]) + edit.text + sourceCodeText.slice(edit.range[1]). Therefore, it's an add
* if the range[0] and range[1] property values are the same value, and it's removal if the text property value is
* empty string.
*/
interface EditInfo {
/**
* The pair of 0-based indices in source code text to remove.
*/
range: [
number,
number
];
/**
* The text to add.
*/
text: string;
}
/**
* The Formatter value is the object to convert the LintResult objects to text.
*/
interface Formatter {
/**
* The method to convert the LintResult objects to text.
* Promise return supported since 8.4.0
*/
format(results: LintResult[]): Promise<string> | string;
}
}
declare const _ESLint: typeof ESLintBase;
/**
* The ESLint class is the primary class to use in Node.js applications.
* This class depends on the Node.js fs module and the file system, so you cannot use it in browsers.
*
* If you want to lint code on browsers, use the Linter class instead.
*
* @since 7.0.0
*/
declare class ESLint extends _ESLint {
}
export { ESLint };
//# sourceMappingURL=ESLint.d.ts.map

327
node_modules/@typescript-eslint/utils/_ts4.3/dist/ts-eslint/Linter.d.ts generated vendored
View file

@ -1,327 +0,0 @@
import type { ParserServices, TSESTree } from '../ts-estree';
import type { ParserOptions as TSParserOptions } from './ParserOptions';
import type { RuleCreateFunction, RuleFix, RuleModule, SharedConfigurationSettings } from './Rule';
import type { Scope } from './Scope';
import type { SourceCode } from './SourceCode';
export type MinimalRuleModule<TMessageIds extends string = string, TOptions extends readonly unknown[] = [
]> = Partial<Omit<RuleModule<TMessageIds, TOptions>, 'create'>> & Pick<RuleModule<TMessageIds, TOptions>, 'create'>;
declare class LinterBase {
/**
* Initialize the Linter.
* @param config the config object
*/
constructor(config?: Linter.LinterOptions);
/**
* Define a new parser module
* @param parserId Name of the parser
* @param parserModule The parser object
*/
defineParser(parserId: string, parserModule: Linter.ParserModule): void;
/**
* Defines a new linting rule.
* @param ruleId A unique rule identifier
* @param ruleModule Function from context to object mapping AST node types to event handlers
*/
defineRule<TMessageIds extends string, TOptions extends readonly unknown[]>(ruleId: string, ruleModule: MinimalRuleModule<TMessageIds, TOptions> | RuleCreateFunction): void;
/**
* Defines many new linting rules.
* @param rulesToDefine map from unique rule identifier to rule
*/
defineRules<TMessageIds extends string, TOptions extends readonly unknown[]>(rulesToDefine: Record<string, MinimalRuleModule<TMessageIds, TOptions> | RuleCreateFunction<TMessageIds, TOptions>>): void;
/**
* Gets an object with all loaded rules.
* @returns All loaded rules
*/
getRules(): Map<string, MinimalRuleModule<string, unknown[]>>;
/**
* Gets the `SourceCode` object representing the parsed source.
* @returns The `SourceCode` object.
*/
getSourceCode(): SourceCode;
/**
* Verifies the text against the rules specified by the second argument.
* @param textOrSourceCode The text to parse or a SourceCode object.
* @param config An ESLintConfig instance to configure everything.
* @param filenameOrOptions The optional filename of the file being checked.
* If this is not set, the filename will default to '<input>' in the rule context.
* If this is an object, then it has "filename", "allowInlineConfig", and some properties.
* @returns The results as an array of messages or an empty array if no messages.
*/
verify(textOrSourceCode: SourceCode | string, config: Linter.Config, filenameOrOptions?: Linter.VerifyOptions | string): Linter.LintMessage[];
/**
* Performs multiple autofix passes over the text until as many fixes as possible have been applied.
* @param code The source text to apply fixes to.
* @param config The ESLint config object to use.
* @param options The ESLint options object to use.
* @returns The result of the fix operation as returned from the SourceCodeFixer.
*/
verifyAndFix(code: string, config: Linter.Config, options: Linter.FixOptions): Linter.FixReport;
/**
* The version from package.json.
*/
readonly version: string;
/**
* The version from package.json.
*/
static readonly version: string;
}
declare namespace Linter {
export interface LinterOptions {
/**
* path to a directory that should be considered as the current working directory.
*/
cwd?: string;
}
export type Severity = 0 | 1 | 2;
export type SeverityString = 'error' | 'off' | 'warn';
export type RuleLevel = Severity | SeverityString;
export type RuleLevelAndOptions = [
RuleLevel,
...unknown[]
];
export type RuleEntry = RuleLevel | RuleLevelAndOptions;
export type RulesRecord = Partial<Record<string, RuleEntry>>;
export type GlobalVariableOptionBase = 'off' | 'readonly' | 'writable';
export type GlobalVariableOption = GlobalVariableOptionBase | boolean;
export type GlobalsConfig = Record<string, GlobalVariableOption>;
export type EnvironmentConfig = Record<string, boolean>;
interface BaseConfig {
$schema?: string;
/**
* The environment settings.
*/
env?: EnvironmentConfig;
/**
* The path to other config files or the package name of shareable configs.
*/
extends?: string[] | string;
/**
* The global variable settings.
*/
globals?: GlobalsConfig;
/**
* The flag that disables directive comments.
*/
noInlineConfig?: boolean;
/**
* The override settings per kind of files.
*/
overrides?: ConfigOverride[];
/**
* The path to a parser or the package name of a parser.
*/
parser?: string;
/**
* The parser options.
*/
parserOptions?: ParserOptions;
/**
* The plugin specifiers.
*/
plugins?: string[];
/**
* The processor specifier.
*/
processor?: string;
/**
* The flag to report unused `eslint-disable` comments.
*/
reportUnusedDisableDirectives?: boolean;
/**
* The rule settings.
*/
rules?: RulesRecord;
/**
* The shared settings.
*/
settings?: SharedConfigurationSettings;
}
export interface ConfigOverride extends BaseConfig {
excludedFiles?: string[] | string;
files: string[] | string;
}
export interface Config extends BaseConfig {
/**
* The glob patterns that ignore to lint.
*/
ignorePatterns?: string[] | string;
/**
* The root flag.
*/
root?: boolean;
}
export type ParserOptions = TSParserOptions;
export interface VerifyOptions {
/**
* Allow/disallow inline comments' ability to change config once it is set. Defaults to true if not supplied.
* Useful if you want to validate JS without comments overriding rules.
*/
allowInlineConfig?: boolean;
/**
* if `true` then the linter doesn't make `fix` properties into the lint result.
*/
disableFixes?: boolean;
/**
* the filename of the source code.
*/
filename?: string;
/**
* the predicate function that selects adopt code blocks.
*/
filterCodeBlock?: (filename: string, text: string) => boolean;
/**
* postprocessor for report messages.
* If provided, this should accept an array of the message lists
* for each code block returned from the preprocessor, apply a mapping to
* the messages as appropriate, and return a one-dimensional array of
* messages.
*/
postprocess?: Processor['postprocess'];
/**
* preprocessor for source text.
* If provided, this should accept a string of source text, and return an array of code blocks to lint.
*/
preprocess?: Processor['preprocess'];
/**
* Adds reported errors for unused `eslint-disable` directives.
*/
reportUnusedDisableDirectives?: SeverityString | boolean;
}
export interface FixOptions extends VerifyOptions {
/**
* Determines whether fixes should be applied.
*/
fix?: boolean;
}
export interface LintSuggestion {
desc: string;
fix: RuleFix;
messageId?: string;
}
export interface LintMessage {
/**
* The 1-based column number.
*/
column: number;
/**
* The 1-based column number of the end location.
*/
endColumn?: number;
/**
* The 1-based line number of the end location.
*/
endLine?: number;
/**
* If `true` then this is a fatal error.
*/
fatal?: true;
/**
* Information for autofix.
*/
fix?: RuleFix;
/**
* The 1-based line number.
*/
line: number;
/**
* The error message.
*/
message: string;
messageId?: string;
nodeType: string;
/**
* The ID of the rule which makes this message.
*/
ruleId: string | null;
/**
* The severity of this message.
*/
severity: Severity;
source: string | null;
/**
* Information for suggestions
*/
suggestions?: LintSuggestion[];
}
export interface FixReport {
/**
* True, if the code was fixed
*/
fixed: boolean;
/**
* Fixed code text (might be the same as input if no fixes were applied).
*/
output: string;
/**
* Collection of all messages for the given code
*/
messages: LintMessage[];
}
export type ParserModule = {
parse(text: string, options?: ParserOptions): TSESTree.Program;
} | {
parseForESLint(text: string, options?: ParserOptions): ESLintParseResult;
};
export interface ESLintParseResult {
ast: TSESTree.Program;
services?: ParserServices;
scopeManager?: Scope.ScopeManager;
visitorKeys?: SourceCode.VisitorKeys;
}
export interface Processor {
/**
* The function to extract code blocks.
*/
preprocess?: (text: string, filename: string) => (string | {
text: string;
filename: string;
})[];
/**
* The function to merge messages.
*/
postprocess?: (messagesList: Linter.LintMessage[][], filename: string) => Linter.LintMessage[];
/**
* If `true` then it means the processor supports autofix.
*/
supportsAutofix?: boolean;
}
export interface Environment {
/**
* The definition of global variables.
*/
globals?: Record<string, Linter.Config>;
/**
* The parser options that will be enabled under this environment.
*/
parserOptions?: ParserOptions;
}
export interface Plugin {
/**
* The definition of plugin configs.
*/
configs?: Record<string, Linter.Config>;
/**
* The definition of plugin environments.
*/
environments?: Record<string, Environment>;
/**
* The definition of plugin processors.
*/
processors?: Record<string, Processor>;
/**
* The definition of plugin rules.
*/
rules?: Record<string, RuleCreateFunction | RuleModule<string, unknown[]>>;
}
export {};
}
declare const Linter_base: typeof LinterBase;
/**
* The Linter object does the actual evaluation of the JavaScript code. It doesn't do any filesystem operations, it
* simply parses and reports on the code. In particular, the Linter object does not process configuration objects
* or files.
*/
declare class Linter extends Linter_base {
}
export { Linter };
//# sourceMappingURL=Linter.d.ts.map

2
node_modules/@typescript-eslint/utils/_ts4.3/dist/ts-eslint/ParserOptions.d.ts generated vendored
View file

@ -1,2 +0,0 @@
export { DebugLevel, EcmaVersion, ParserOptions, SourceType, } from '@typescript-eslint/types';
//# sourceMappingURL=ParserOptions.d.ts.map

418
node_modules/@typescript-eslint/utils/_ts4.3/dist/ts-eslint/Rule.d.ts generated vendored
View file

@ -1,418 +0,0 @@
import type { JSONSchema4 } from '../json-schema';
import type { ParserServices, TSESTree } from '../ts-estree';
import type { AST } from './AST';
import type { Linter } from './Linter';
import type { Scope } from './Scope';
import type { SourceCode } from './SourceCode';
export type RuleRecommendation = 'recommended' | 'strict' | 'stylistic';
interface RuleMetaDataDocs {
/**
* Concise description of the rule
*/
description: string;
/**
* The recommendation level for the rule.
* Used by the build tools to generate the recommended and strict configs.
* Exclude to not include it as a recommendation.
*/
recommended?: RuleRecommendation;
/**
* The URL of the rule's docs
*/
url?: string;
/**
* Does the rule require us to create a full TypeScript Program in order for it
* to type-check code. This is only used for documentation purposes.
*/
requiresTypeChecking?: boolean;
/**
* Does the rule extend (or is it based off of) an ESLint code rule?
* Alternately accepts the name of the base rule, in case the rule has been renamed.
* This is only used for documentation purposes.
*/
extendsBaseRule?: boolean | string;
}
interface RuleMetaData<TMessageIds extends string> {
/**
* True if the rule is deprecated, false otherwise
*/
deprecated?: boolean;
/**
* Documentation for the rule, unnecessary for custom rules/plugins
*/
docs?: RuleMetaDataDocs;
/**
* The fixer category. Omit if there is no fixer
*/
fixable?: 'code' | 'whitespace';
/**
* Specifies whether rules can return suggestions. Omit if there is no suggestions
*/
hasSuggestions?: boolean;
/**
* A map of messages which the rule can report.
* The key is the messageId, and the string is the parameterised error string.
* See: https://eslint.org/docs/developer-guide/working-with-rules#messageids
*/
messages: Record<TMessageIds, string>;
/**
* The type of rule.
* - `"problem"` means the rule is identifying code that either will cause an error or may cause a confusing behavior. Developers should consider this a high priority to resolve.
* - `"suggestion"` means the rule is identifying something that could be done in a better way but no errors will occur if the code isn’t changed.
* - `"layout"` means the rule cares primarily about whitespace, semicolons, commas, and parentheses, all the parts of the program that determine how the code looks rather than how it executes. These rules work on parts of the code that aren’t specified in the AST.
*/
type: 'layout' | 'problem' | 'suggestion';
/**
* The name of the rule this rule was replaced by, if it was deprecated.
*/
replacedBy?: readonly string[];
/**
* The options schema. Supply an empty array if there are no options.
*/
schema: JSONSchema4 | readonly JSONSchema4[];
}
interface RuleFix {
range: Readonly<AST.Range>;
text: string;
}
interface RuleFixer {
insertTextAfter(nodeOrToken: TSESTree.Node | TSESTree.Token, text: string): RuleFix;
insertTextAfterRange(range: Readonly<AST.Range>, text: string): RuleFix;
insertTextBefore(nodeOrToken: TSESTree.Node | TSESTree.Token, text: string): RuleFix;
insertTextBeforeRange(range: Readonly<AST.Range>, text: string): RuleFix;
remove(nodeOrToken: TSESTree.Node | TSESTree.Token): RuleFix;
removeRange(range: Readonly<AST.Range>): RuleFix;
replaceText(nodeOrToken: TSESTree.Node | TSESTree.Token, text: string): RuleFix;
replaceTextRange(range: Readonly<AST.Range>, text: string): RuleFix;
}
interface SuggestionReportDescriptor<TMessageIds extends string> extends Omit<ReportDescriptorBase<TMessageIds>, 'fix'> {
readonly fix: ReportFixFunction;
}
type ReportFixFunction = (fixer: RuleFixer) => IterableIterator<RuleFix> | RuleFix | readonly RuleFix[] | null;
type ReportSuggestionArray<TMessageIds extends string> = SuggestionReportDescriptor<TMessageIds>[];
type ReportDescriptorMessageData = Readonly<Record<string, unknown>>;
interface ReportDescriptorBase<TMessageIds extends string> {
/**
* The parameters for the message string associated with `messageId`.
*/
readonly data?: ReportDescriptorMessageData;
/**
* The fixer function.
*/
readonly fix?: ReportFixFunction | null;
/**
* The messageId which is being reported.
*/
readonly messageId: TMessageIds;
}
interface ReportDescriptorWithSuggestion<TMessageIds extends string> extends ReportDescriptorBase<TMessageIds> {
/**
* 6.7's Suggestions API
*/
readonly suggest?: Readonly<ReportSuggestionArray<TMessageIds>> | null;
}
interface ReportDescriptorNodeOptionalLoc {
/**
* The Node or AST Token which the report is being attached to
*/
readonly node: TSESTree.Node | TSESTree.Token;
/**
* An override of the location of the report
*/
readonly loc?: Readonly<TSESTree.Position> | Readonly<TSESTree.SourceLocation>;
}
interface ReportDescriptorLocOnly {
/**
* An override of the location of the report
*/
loc: Readonly<TSESTree.Position> | Readonly<TSESTree.SourceLocation>;
}
type ReportDescriptor<TMessageIds extends string> = ReportDescriptorWithSuggestion<TMessageIds> & (ReportDescriptorLocOnly | ReportDescriptorNodeOptionalLoc);
/**
* Plugins can add their settings using declaration
* merging against this interface.
*/
type SharedConfigurationSettings = Record<string, unknown>;
interface RuleContext<TMessageIds extends string, TOptions extends readonly unknown[]> {
/**
* The rule ID.
*/
id: string;
/**
* An array of the configured options for this rule.
* This array does not include the rule severity.
*/
options: TOptions;
/**
* The name of the parser from configuration.
*/
parserPath: string;
/**
* The parser options configured for this run
*/
parserOptions: Linter.ParserOptions;
/**
* An object containing parser-provided services for rules
*/
parserServices?: ParserServices;
/**
* The shared settings from configuration.
* We do not have any shared settings in this plugin.
*/
settings: SharedConfigurationSettings;
/**
* Returns an array of the ancestors of the currently-traversed node, starting at
* the root of the AST and continuing through the direct parent of the current node.
* This array does not include the currently-traversed node itself.
*/
getAncestors(): TSESTree.Node[];
/**
* Returns a list of variables declared by the given node.
* This information can be used to track references to variables.
*/
getDeclaredVariables(node: TSESTree.Node): readonly Scope.Variable[];
/**
* Returns the current working directory passed to Linter.
* It is a path to a directory that should be considered as the current working directory.
* @since 6.6.0
*/
getCwd(): string;
/**
* The current working directory passed to Linter.
* It is a path to a directory that should be considered as the current working directory.
* @since 8.40.0
*/
cwd: string;
/**
* Returns the filename associated with the source.
*/
getFilename(): string;
/**
* The filename associated with the source.
* @since 8.40.0
*/
filename: string;
/**
* Returns the full path of the file on disk without any code block information (unlike `getFilename()`).
* @since 7.28.0
*/
getPhysicalFilename?(): string;
/**
* The full path of the file on disk without any code block information (unlike `filename`).
* @since 8.40.0
*/
physicalFilename?: string;
/**
* Returns the scope of the currently-traversed node.
* This information can be used track references to variables.
*/
getScope(): Scope.Scope;
/**
* Returns a SourceCode object that you can use to work with the source that
* was passed to ESLint.
*/
getSourceCode(): Readonly<SourceCode>;
/**
* A SourceCode object that you can use to work with the source that
* was passed to ESLint.
* @since 8.40.0
*/
sourceCode: Readonly<SourceCode>;
/**
* Marks a variable with the given name in the current scope as used.
* This affects the no-unused-vars rule.
*/
markVariableAsUsed(name: string): boolean;
/**
* Reports a problem in the code.
*/
report(descriptor: ReportDescriptor<TMessageIds>): void;
}
type RuleFunction<T extends TSESTree.NodeOrTokenData = never> = (node: T) => void;
interface RuleListenerBaseSelectors {
ArrayExpression?: RuleFunction<TSESTree.ArrayExpression>;
ArrayPattern?: RuleFunction<TSESTree.ArrayPattern>;
ArrowFunctionExpression?: RuleFunction<TSESTree.ArrowFunctionExpression>;
AssignmentExpression?: RuleFunction<TSESTree.AssignmentExpression>;
AssignmentPattern?: RuleFunction<TSESTree.AssignmentPattern>;
AwaitExpression?: RuleFunction<TSESTree.AwaitExpression>;
BigIntLiteral?: RuleFunction<TSESTree.BigIntLiteral>;
BinaryExpression?: RuleFunction<TSESTree.BinaryExpression>;
BlockStatement?: RuleFunction<TSESTree.BlockStatement>;
BreakStatement?: RuleFunction<TSESTree.BreakStatement>;
CallExpression?: RuleFunction<TSESTree.CallExpression>;
CatchClause?: RuleFunction<TSESTree.CatchClause>;
ChainExpression?: RuleFunction<TSESTree.ChainExpression>;
ClassBody?: RuleFunction<TSESTree.ClassBody>;
ClassDeclaration?: RuleFunction<TSESTree.ClassDeclaration>;
ClassExpression?: RuleFunction<TSESTree.ClassExpression>;
ConditionalExpression?: RuleFunction<TSESTree.ConditionalExpression>;
ContinueStatement?: RuleFunction<TSESTree.ContinueStatement>;
DebuggerStatement?: RuleFunction<TSESTree.DebuggerStatement>;
Decorator?: RuleFunction<TSESTree.Decorator>;
DoWhileStatement?: RuleFunction<TSESTree.DoWhileStatement>;
EmptyStatement?: RuleFunction<TSESTree.EmptyStatement>;
ExportAllDeclaration?: RuleFunction<TSESTree.ExportAllDeclaration>;
ExportDefaultDeclaration?: RuleFunction<TSESTree.ExportDefaultDeclaration>;
ExportNamedDeclaration?: RuleFunction<TSESTree.ExportNamedDeclaration>;
ExportSpecifier?: RuleFunction<TSESTree.ExportSpecifier>;
ExpressionStatement?: RuleFunction<TSESTree.ExpressionStatement>;
ForInStatement?: RuleFunction<TSESTree.ForInStatement>;
ForOfStatement?: RuleFunction<TSESTree.ForOfStatement>;
ForStatement?: RuleFunction<TSESTree.ForStatement>;
FunctionDeclaration?: RuleFunction<TSESTree.FunctionDeclaration>;
FunctionExpression?: RuleFunction<TSESTree.FunctionExpression>;
Identifier?: RuleFunction<TSESTree.Identifier>;
IfStatement?: RuleFunction<TSESTree.IfStatement>;
ImportDeclaration?: RuleFunction<TSESTree.ImportDeclaration>;
ImportDefaultSpecifier?: RuleFunction<TSESTree.ImportDefaultSpecifier>;
ImportExpression?: RuleFunction<TSESTree.ImportExpression>;
ImportNamespaceSpecifier?: RuleFunction<TSESTree.ImportNamespaceSpecifier>;
ImportSpecifier?: RuleFunction<TSESTree.ImportSpecifier>;
JSXAttribute?: RuleFunction<TSESTree.JSXAttribute>;
JSXClosingElement?: RuleFunction<TSESTree.JSXClosingElement>;
JSXClosingFragment?: RuleFunction<TSESTree.JSXClosingFragment>;
JSXElement?: RuleFunction<TSESTree.JSXElement>;
JSXEmptyExpression?: RuleFunction<TSESTree.JSXEmptyExpression>;
JSXExpressionContainer?: RuleFunction<TSESTree.JSXExpressionContainer>;
JSXFragment?: RuleFunction<TSESTree.JSXFragment>;
JSXIdentifier?: RuleFunction<TSESTree.JSXIdentifier>;
JSXMemberExpression?: RuleFunction<TSESTree.JSXMemberExpression>;
JSXOpeningElement?: RuleFunction<TSESTree.JSXOpeningElement>;
JSXOpeningFragment?: RuleFunction<TSESTree.JSXOpeningFragment>;
JSXSpreadAttribute?: RuleFunction<TSESTree.JSXSpreadAttribute>;
JSXSpreadChild?: RuleFunction<TSESTree.JSXSpreadChild>;
JSXText?: RuleFunction<TSESTree.JSXText>;
LabeledStatement?: RuleFunction<TSESTree.LabeledStatement>;
Literal?: RuleFunction<TSESTree.Literal>;
LogicalExpression?: RuleFunction<TSESTree.LogicalExpression>;
MemberExpression?: RuleFunction<TSESTree.MemberExpression>;
MetaProperty?: RuleFunction<TSESTree.MetaProperty>;
MethodDefinition?: RuleFunction<TSESTree.MethodDefinition>;
NewExpression?: RuleFunction<TSESTree.NewExpression>;
ObjectExpression?: RuleFunction<TSESTree.ObjectExpression>;
ObjectPattern?: RuleFunction<TSESTree.ObjectPattern>;
Program?: RuleFunction<TSESTree.Program>;
Property?: RuleFunction<TSESTree.Property>;
PropertyDefinition?: RuleFunction<TSESTree.PropertyDefinition>;
RestElement?: RuleFunction<TSESTree.RestElement>;
ReturnStatement?: RuleFunction<TSESTree.ReturnStatement>;
SequenceExpression?: RuleFunction<TSESTree.SequenceExpression>;
SpreadElement?: RuleFunction<TSESTree.SpreadElement>;
Super?: RuleFunction<TSESTree.Super>;
SwitchCase?: RuleFunction<TSESTree.SwitchCase>;
SwitchStatement?: RuleFunction<TSESTree.SwitchStatement>;
TaggedTemplateExpression?: RuleFunction<TSESTree.TaggedTemplateExpression>;
TemplateElement?: RuleFunction<TSESTree.TemplateElement>;
TemplateLiteral?: RuleFunction<TSESTree.TemplateLiteral>;
ThisExpression?: RuleFunction<TSESTree.ThisExpression>;
ThrowStatement?: RuleFunction<TSESTree.ThrowStatement>;
TryStatement?: RuleFunction<TSESTree.TryStatement>;
TSAbstractKeyword?: RuleFunction<TSESTree.TSAbstractKeyword>;
TSAbstractMethodDefinition?: RuleFunction<TSESTree.TSAbstractMethodDefinition>;
TSAbstractPropertyDefinition?: RuleFunction<TSESTree.TSAbstractPropertyDefinition>;
TSAnyKeyword?: RuleFunction<TSESTree.TSAnyKeyword>;
TSArrayType?: RuleFunction<TSESTree.TSArrayType>;
TSAsExpression?: RuleFunction<TSESTree.TSAsExpression>;
TSAsyncKeyword?: RuleFunction<TSESTree.TSAsyncKeyword>;
TSBigIntKeyword?: RuleFunction<TSESTree.TSBigIntKeyword>;
TSBooleanKeyword?: RuleFunction<TSESTree.TSBooleanKeyword>;
TSCallSignatureDeclaration?: RuleFunction<TSESTree.TSCallSignatureDeclaration>;
TSClassImplements?: RuleFunction<TSESTree.TSClassImplements>;
TSConditionalType?: RuleFunction<TSESTree.TSConditionalType>;
TSConstructorType?: RuleFunction<TSESTree.TSConstructorType>;
TSConstructSignatureDeclaration?: RuleFunction<TSESTree.TSConstructSignatureDeclaration>;
TSDeclareFunction?: RuleFunction<TSESTree.TSDeclareFunction>;
TSDeclareKeyword?: RuleFunction<TSESTree.TSDeclareKeyword>;
TSEmptyBodyFunctionExpression?: RuleFunction<TSESTree.TSEmptyBodyFunctionExpression>;
TSEnumDeclaration?: RuleFunction<TSESTree.TSEnumDeclaration>;
TSEnumMember?: RuleFunction<TSESTree.TSEnumMember>;
TSExportAssignment?: RuleFunction<TSESTree.TSExportAssignment>;
TSExportKeyword?: RuleFunction<TSESTree.TSExportKeyword>;
TSExternalModuleReference?: RuleFunction<TSESTree.TSExternalModuleReference>;
TSFunctionType?: RuleFunction<TSESTree.TSFunctionType>;
TSImportEqualsDeclaration?: RuleFunction<TSESTree.TSImportEqualsDeclaration>;
TSImportType?: RuleFunction<TSESTree.TSImportType>;
TSIndexedAccessType?: RuleFunction<TSESTree.TSIndexedAccessType>;
TSIndexSignature?: RuleFunction<TSESTree.TSIndexSignature>;
TSInferType?: RuleFunction<TSESTree.TSInferType>;
TSInterfaceBody?: RuleFunction<TSESTree.TSInterfaceBody>;
TSInterfaceDeclaration?: RuleFunction<TSESTree.TSInterfaceDeclaration>;
TSInterfaceHeritage?: RuleFunction<TSESTree.TSInterfaceHeritage>;
TSIntersectionType?: RuleFunction<TSESTree.TSIntersectionType>;
TSLiteralType?: RuleFunction<TSESTree.TSLiteralType>;
TSMappedType?: RuleFunction<TSESTree.TSMappedType>;
TSMethodSignature?: RuleFunction<TSESTree.TSMethodSignature>;
TSModuleBlock?: RuleFunction<TSESTree.TSModuleBlock>;
TSModuleDeclaration?: RuleFunction<TSESTree.TSModuleDeclaration>;
TSNamespaceExportDeclaration?: RuleFunction<TSESTree.TSNamespaceExportDeclaration>;
TSNeverKeyword?: RuleFunction<TSESTree.TSNeverKeyword>;
TSNonNullExpression?: RuleFunction<TSESTree.TSNonNullExpression>;
TSNullKeyword?: RuleFunction<TSESTree.TSNullKeyword>;
TSNumberKeyword?: RuleFunction<TSESTree.TSNumberKeyword>;
TSObjectKeyword?: RuleFunction<TSESTree.TSObjectKeyword>;
TSOptionalType?: RuleFunction<TSESTree.TSOptionalType>;
TSParameterProperty?: RuleFunction<TSESTree.TSParameterProperty>;
TSPrivateKeyword?: RuleFunction<TSESTree.TSPrivateKeyword>;
TSPropertySignature?: RuleFunction<TSESTree.TSPropertySignature>;
TSProtectedKeyword?: RuleFunction<TSESTree.TSProtectedKeyword>;
TSPublicKeyword?: RuleFunction<TSESTree.TSPublicKeyword>;
TSQualifiedName?: RuleFunction<TSESTree.TSQualifiedName>;
TSReadonlyKeyword?: RuleFunction<TSESTree.TSReadonlyKeyword>;
TSRestType?: RuleFunction<TSESTree.TSRestType>;
TSStaticKeyword?: RuleFunction<TSESTree.TSStaticKeyword>;
TSStringKeyword?: RuleFunction<TSESTree.TSStringKeyword>;
TSSymbolKeyword?: RuleFunction<TSESTree.TSSymbolKeyword>;
TSThisType?: RuleFunction<TSESTree.TSThisType>;
TSTupleType?: RuleFunction<TSESTree.TSTupleType>;
TSTypeAliasDeclaration?: RuleFunction<TSESTree.TSTypeAliasDeclaration>;
TSTypeAnnotation?: RuleFunction<TSESTree.TSTypeAnnotation>;
TSTypeAssertion?: RuleFunction<TSESTree.TSTypeAssertion>;
TSTypeLiteral?: RuleFunction<TSESTree.TSTypeLiteral>;
TSTypeOperator?: RuleFunction<TSESTree.TSTypeOperator>;
TSTypeParameter?: RuleFunction<TSESTree.TSTypeParameter>;
TSTypeParameterDeclaration?: RuleFunction<TSESTree.TSTypeParameterDeclaration>;
TSTypeParameterInstantiation?: RuleFunction<TSESTree.TSTypeParameterInstantiation>;
TSTypePredicate?: RuleFunction<TSESTree.TSTypePredicate>;
TSTypeQuery?: RuleFunction<TSESTree.TSTypeQuery>;
TSTypeReference?: RuleFunction<TSESTree.TSTypeReference>;
TSUndefinedKeyword?: RuleFunction<TSESTree.TSUndefinedKeyword>;
TSUnionType?: RuleFunction<TSESTree.TSUnionType>;
TSUnknownKeyword?: RuleFunction<TSESTree.TSUnknownKeyword>;
TSVoidKeyword?: RuleFunction<TSESTree.TSVoidKeyword>;
UnaryExpression?: RuleFunction<TSESTree.UnaryExpression>;
UpdateExpression?: RuleFunction<TSESTree.UpdateExpression>;
VariableDeclaration?: RuleFunction<TSESTree.VariableDeclaration>;
VariableDeclarator?: RuleFunction<TSESTree.VariableDeclarator>;
WhileStatement?: RuleFunction<TSESTree.WhileStatement>;
WithStatement?: RuleFunction<TSESTree.WithStatement>;
YieldExpression?: RuleFunction<TSESTree.YieldExpression>;
}
type RuleListenerExitSelectors = {
[K in keyof RuleListenerBaseSelectors as `${K}:exit`]: RuleListenerBaseSelectors[K];
};
type RuleListenerCatchAllBaseCase = Record<string, RuleFunction | undefined>;
interface RuleListenerExtension {
}
type RuleListener = RuleListenerBaseSelectors & RuleListenerCatchAllBaseCase & RuleListenerExitSelectors;
interface RuleModule<TMessageIds extends string, TOptions extends readonly unknown[] = [
], TRuleListener extends RuleListener = RuleListener> {
/**
* Default options the rule will be run with
*/
defaultOptions: TOptions;
/**
* Metadata about the rule
*/
meta: RuleMetaData<TMessageIds>;
/**
* Function which returns an object with methods that ESLint calls to “visit”
* nodes while traversing the abstract syntax tree.
*/
create(context: Readonly<RuleContext<TMessageIds, TOptions>>): TRuleListener;
}
type AnyRuleModule = RuleModule<string, readonly unknown[]>;
type RuleCreateFunction<TMessageIds extends string = never, TOptions extends readonly unknown[] = unknown[]> = (context: Readonly<RuleContext<TMessageIds, TOptions>>) => RuleListener;
type AnyRuleCreateFunction = RuleCreateFunction<string, readonly unknown[]>;
export { AnyRuleCreateFunction, AnyRuleModule, ReportDescriptor, ReportDescriptorMessageData, ReportFixFunction, ReportSuggestionArray, RuleContext, RuleCreateFunction, RuleFix, RuleFixer, RuleFunction, RuleListener, RuleListenerExtension, RuleMetaData, RuleMetaDataDocs, RuleModule, SharedConfigurationSettings, };
//# sourceMappingURL=Rule.d.ts.map

Some files were not shown because too many files have changed in this diff Show more