xo 0.52.2 → 0.52.3

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

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

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

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

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

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

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

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

package/node_modules/@typescript-eslint/typescript-estree/dist/convert.d.ts

@@ -130,10 +130,12 @@ export declare class Converter {
     private convertAssertClasue;
     /**
      * Applies the given TS modifiers to the given result object.
+     *
+     * This method adds not standardized `modifiers` property in nodes
+     *
      * @param result
      * @param modifiers original ts.Nodes from the node.modifiers array
      * @returns the current result object will be mutated
-     * @deprecated This method adds not standardized `modifiers` property in nodes
      */
     private applyModifiersToResult;
     /**

package/node_modules/@typescript-eslint/typescript-estree/dist/convert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../src/convert.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAoBL,OAAO,EAER,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EACV,aAAa,EACb,2BAA2B,EAC5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,EAEL,QAAQ,EAER,MAAM,EACP,MAAM,aAAa,CAAC;AAKrB,UAAU,gBAAgB;IACxB,qBAAqB,EAAE,OAAO,CAAC;IAC/B,sBAAsB,EAAE,OAAO,CAAC;CACjC;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,EAAE,CAAC,sBAAsB,GAAG,wBAAwB,GAC1D,OAAO,CAMT;AAED,MAAM,WAAW,OAAO;IACtB,qBAAqB,EAAE,2BAA2B,CAAC;IACnD,qBAAqB,EAAE,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;CAC7D;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAgB;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IACvD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IAEvD,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,UAAU,CAAS;IAE3B;;;;;OAKG;gBACS,GAAG,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,gBAAgB;IAKzD,UAAU,IAAI,OAAO;IAOrB,cAAc,IAAI,QAAQ,CAAC,OAAO;IAIlC;;;;;;;OAOG;IACH,OAAO,CAAC,SAAS;IAkCjB;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IA+DlB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAW/B;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAItB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAIpB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,UAAU;IAsBlB,OAAO,CAAC,oCAAoC;IAe5C;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IAqB7B;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAkC9B;;;;;OAKG;IACH,OAAO,CAAC,oCAAoC;IAa5C;;;;OAIG;IACH,OAAO,CAAC,kDAAkD;IAe1D;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAkBzB,OAAO,CAAC,sBAAsB;IA4C9B;;;;OAIG;IACH,OAAO,CAAC,UAAU;IAmElB,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,+BAA+B;IA6BvC;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,sBAAsB;IA4D9B,OAAO,CAAC,mBAAmB;IAQ3B;;;;;;OAMG;IACH,OAAO,CAAC,sBAAsB;IA8C9B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,qBAAqB;IAwB7B;;;;;;;OAOG;IACH,OAAO,CAAC,WAAW;CAumEpB"}
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../src/convert.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAoBL,OAAO,EAER,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EACV,aAAa,EACb,2BAA2B,EAC5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,EAEL,QAAQ,EAER,MAAM,EACP,MAAM,aAAa,CAAC;AAKrB,UAAU,gBAAgB;IACxB,qBAAqB,EAAE,OAAO,CAAC;IAC/B,sBAAsB,EAAE,OAAO,CAAC;CACjC;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,EAAE,CAAC,sBAAsB,GAAG,wBAAwB,GAC1D,OAAO,CAMT;AAED,MAAM,WAAW,OAAO;IACtB,qBAAqB,EAAE,2BAA2B,CAAC;IACnD,qBAAqB,EAAE,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;CAC7D;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAgB;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IACvD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IAEvD,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,UAAU,CAAS;IAE3B;;;;;OAKG;gBACS,GAAG,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,gBAAgB;IAKzD,UAAU,IAAI,OAAO;IAOrB,cAAc,IAAI,QAAQ,CAAC,OAAO;IAIlC;;;;;;;OAOG;IACH,OAAO,CAAC,SAAS;IAkCjB;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAgElB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAW/B;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAItB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAIpB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,UAAU;IAsBlB,OAAO,CAAC,oCAAoC;IAe5C;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IAqB7B;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAkC9B;;;;;OAKG;IACH,OAAO,CAAC,oCAAoC;IAa5C;;;;OAIG;IACH,OAAO,CAAC,kDAAkD;IAe1D;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAiBzB,OAAO,CAAC,sBAAsB;IA4C9B;;;;OAIG;IACH,OAAO,CAAC,UAAU;IAwFlB,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,+BAA+B;IA6BvC;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,sBAAsB;IA4D9B,OAAO,CAAC,mBAAmB;IAQ3B;;;;;;;;OAQG;IACH,OAAO,CAAC,sBAAsB;IA+C9B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,qBAAqB;IAwB7B;;;;;;;OAOG;IACH,OAAO,CAAC,WAAW;CAgnEpB"}

package/node_modules/@typescript-eslint/typescript-estree/dist/convert.js

@@ -27,6 +27,7 @@ exports.Converter = exports.convertError = void 0;
 // There's lots of funny stuff due to the typing of ts.Node
 /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access */
 const ts = __importStar(require("typescript"));
+const getModifiers_1 = require("./getModifiers");
 const node_utils_1 = require("./node-utils");
 const ts_estree_1 = require("./ts-estree");
 const version_check_1 = require("./version-check");
@@ -101,13 +102,14 @@ class Converter {
      */
     fixExports(node, result) {
         // check for exports
-        if (node.modifiers && node.modifiers[0].kind === SyntaxKind.ExportKeyword) {
+        const modifiers = (0, getModifiers_1.getModifiers)(node);
+        if ((modifiers === null || modifiers === void 0 ? void 0 : modifiers[0].kind) === SyntaxKind.ExportKeyword) {
             /**
              * Make sure that original node is registered instead of export
              */
             this.registerTSNodeInNodeMap(node, result);
-            const exportKeyword = node.modifiers[0];
-            const nextModifier = node.modifiers[1];
+            const exportKeyword = modifiers[0];
+            const nextModifier = modifiers[1];
             const declarationIsDefault = nextModifier && nextModifier.kind === SyntaxKind.DefaultKeyword;
             const varToken = declarationIsDefault
                 ? (0, node_utils_1.findNextToken)(nextModifier, this.ast, this.ast)
@@ -288,10 +290,10 @@ class Converter {
             return [];
         }
         return parameters.map(param => {
-            var _a;
             const convertedParam = this.convertChild(param);
-            if ((_a = param.decorators) === null || _a === void 0 ? void 0 : _a.length) {
-                convertedParam.decorators = param.decorators.map(el => this.convertChild(el));
+            const decorators = (0, getModifiers_1.getDecorators)(param);
+            if (decorators === null || decorators === void 0 ? void 0 : decorators.length) {
+                convertedParam.decorators = decorators.map(el => this.convertChild(el));
             }
             return convertedParam;
         });
@@ -366,11 +368,36 @@ class Converter {
                     ? this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters)
                     : null;
         }
-        if ('decorators' in node && node.decorators && node.decorators.length) {
-            result.decorators = node.decorators.map(el => this.convertChild(el));
+        const decorators = (0, getModifiers_1.getDecorators)(node);
+        if (decorators === null || decorators === void 0 ? void 0 : decorators.length) {
+            result.decorators = decorators.map(el => this.convertChild(el));
         }
+        // keys we never want to clone from the base typescript node as they
+        // introduce garbage into our AST
+        const KEYS_TO_NOT_COPY = new Set([
+            '_children',
+            'decorators',
+            'end',
+            'flags',
+            'illegalDecorators',
+            'heritageClauses',
+            'locals',
+            'localSymbol',
+            'jsDoc',
+            'kind',
+            'modifierFlagsCache',
+            'modifiers',
+            'nextContainer',
+            'parent',
+            'pos',
+            'symbol',
+            'transformFlags',
+            'type',
+            'typeArguments',
+            'typeParameters',
+        ]);
         Object.entries(node)
-            .filter(([key]) => !/^(?:_children|kind|parent|pos|end|flags|modifierFlagsCache|jsDoc|type|typeArguments|typeParameters|decorators|transformFlags)$/.test(key))
+            .filter(([key]) => !KEYS_TO_NOT_COPY.has(key))
             .forEach(([key, value]) => {
             if (Array.isArray(value)) {
                 result[key] = value.map(el => this.convertChild(el));
@@ -496,13 +523,15 @@ class Converter {
     }
     /**
      * Applies the given TS modifiers to the given result object.
+     *
+     * This method adds not standardized `modifiers` property in nodes
+     *
      * @param result
      * @param modifiers original ts.Nodes from the node.modifiers array
      * @returns the current result object will be mutated
-     * @deprecated This method adds not standardized `modifiers` property in nodes
      */
     applyModifiersToResult(result, modifiers) {
-        if (!(modifiers === null || modifiers === void 0 ? void 0 : modifiers.length)) {
+        if (!modifiers) {
             return;
         }
         const remainingModifiers = [];
@@ -537,7 +566,7 @@ class Converter {
          * not been explicitly handled above, we just convert and
          * add the modifiers array to the result node.
          */
-        if (remainingModifiers.length) {
+        if (remainingModifiers.length > 0) {
             result.modifiers = remainingModifiers;
         }
     }
@@ -773,12 +802,11 @@ class Converter {
                 });
                 /**
                  * Semantically, decorators are not allowed on variable declarations,
-                 * but the TypeScript compiler will parse them and produce a valid AST,
-                 * so we handle them here too.
+                 * Pre 4.8 TS would include them in the AST, so we did as well.
+                 * However as of 4.8 TS no longer includes it (as it is, well, invalid).
+                 *
+                 * So for consistency across versions, we no longer include it either.
                  */
-                if (node.decorators) {
-                    result.decorators = node.decorators.map(el => this.convertChild(el));
-                }
                 if ((0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, node)) {
                     result.declare = true;
                 }
@@ -889,8 +917,9 @@ class Converter {
                 if (node.type) {
                     result.typeAnnotation = this.convertTypeAnnotation(node.type, node);
                 }
-                if (node.decorators) {
-                    result.decorators = node.decorators.map(el => this.convertChild(el));
+                const decorators = (0, getModifiers_1.getDecorators)(node);
+                if (decorators) {
+                    result.decorators = decorators.map(el => this.convertChild(el));
                 }
                 const accessibility = (0, node_utils_1.getTSNodeAccessibility)(node);
                 if (accessibility) {
@@ -974,8 +1003,9 @@ class Converter {
                         kind: 'method',
                         override: (0, node_utils_1.hasModifier)(SyntaxKind.OverrideKeyword, node),
                     });
-                    if (node.decorators) {
-                        result.decorators = node.decorators.map(el => this.convertChild(el));
+                    const decorators = (0, getModifiers_1.getDecorators)(node);
+                    if (decorators) {
+                        result.decorators = decorators.map(el => this.convertChild(el));
                     }
                     const accessibility = (0, node_utils_1.getTSNodeAccessibility)(node);
                     if (accessibility) {
@@ -1252,7 +1282,8 @@ class Converter {
                         left: parameter,
                         right: this.convertChild(node.initializer),
                     });
-                    if (node.modifiers) {
+                    const modifiers = (0, getModifiers_1.getModifiers)(node);
+                    if (modifiers) {
                         // AssignmentPattern should not contain modifiers in range
                         result.range[0] = parameter.range[0];
                         result.loc = (0, node_utils_1.getLocFor)(result.range[0], result.range[1], this.ast);
@@ -1272,7 +1303,12 @@ class Converter {
                     }
                     parameter.optional = true;
                 }
-                if (node.modifiers) {
+                const decorators = (0, getModifiers_1.getDecorators)(node);
+                if (decorators) {
+                    parameter.decorators = decorators.map(d => this.convertChild(d));
+                }
+                const modifiers = (0, getModifiers_1.getModifiers)(node);
+                if (modifiers) {
                     return this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.TSParameterProperty,
                         accessibility: (_c = (0, node_utils_1.getTSNodeAccessibility)(node)) !== null && _c !== void 0 ? _c : undefined,
@@ -1331,8 +1367,9 @@ class Converter {
                 if ((0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, node)) {
                     result.declare = true;
                 }
-                if (node.decorators) {
-                    result.decorators = node.decorators.map(el => this.convertChild(el));
+                const decorators = (0, getModifiers_1.getDecorators)(node);
+                if (decorators) {
+                    result.decorators = decorators.map(el => this.convertChild(el));
                 }
                 const filteredMembers = node.members.filter(node_utils_1.isESTreeClassMember);
                 if (filteredMembers.length) {
@@ -1967,7 +2004,9 @@ class Converter {
                     typeAnnotation: node.type
                         ? this.convertTypeAnnotation(node.type, node)
                         : undefined,
-                    initializer: this.convertChild(node.initializer) || undefined,
+                    initializer: this.convertChild(
+                    // eslint-disable-next-line deprecation/deprecation -- TODO breaking change remove this from the AST
+                    node.initializer) || undefined,
                     readonly: (0, node_utils_1.hasModifier)(SyntaxKind.ReadonlyKeyword, node) || undefined,
                     static: (0, node_utils_1.hasModifier)(SyntaxKind.StaticKeyword, node) || undefined,
                     export: (0, node_utils_1.hasModifier)(SyntaxKind.ExportKeyword, node) || undefined,
@@ -2134,7 +2173,7 @@ class Converter {
                     members: node.members.map(el => this.convertChild(el)),
                 });
                 // apply modifiers first...
-                this.applyModifiersToResult(result, node.modifiers);
+                this.applyModifiersToResult(result, (0, getModifiers_1.getModifiers)(node));
                 // ...then check for exports
                 return this.fixExports(node, result);
             }
@@ -2160,7 +2199,7 @@ class Converter {
                     result.body = this.convertChild(node.body);
                 }
                 // apply modifiers first...
-                this.applyModifiersToResult(result, node.modifiers);
+                this.applyModifiersToResult(result, (0, getModifiers_1.getModifiers)(node));
                 if (node.flags & ts.NodeFlags.GlobalAugmentation) {
                     result.global = true;
                 }