@typescript-eslint/typescript-estree 6.0.0-alpha.98 → 6.0.0

package/README.md

@@ -1,10 +1,14 @@
 # `@typescript-eslint/typescript-estree`
 
+> A parser that produces an ESTree-compatible AST for TypeScript code.
+
 [![NPM Version](https://img.shields.io/npm/v/@typescript-eslint/typescript-estree.svg?style=flat-square)](https://www.npmjs.com/package/@typescript-eslint/utils)
 [![NPM Downloads](https://img.shields.io/npm/dm/@typescript-eslint/typescript-estree.svg?style=flat-square)](https://www.npmjs.com/package/@typescript-eslint/utils)
 
 ## Contributing
 
-👉 See **https://typescript-eslint.io/architecture/typescript-estree** for documentation on this package.
+👉 See **https://typescript-eslint.io/packages/typescript-estree** for documentation on this package.
 
 > See https://typescript-eslint.io for general documentation on typescript-eslint, the tooling that allows you to run ESLint and Prettier on TypeScript code.
+
+<!-- Local path for docs: docs/packages/TypeScript_ESTree.mdx -->

package/{_ts4.2 → _ts4.3}/dist/convert.d.ts

@@ -14,7 +14,7 @@ export interface ConverterOptions {
  * @param error the error object
  * @returns converted error object
  */
-export declare function convertError(error: ts.DiagnosticWithLocation | SemanticOrSyntacticError): TSError;
+export declare function convertError(error: SemanticOrSyntacticError | ts.DiagnosticWithLocation): TSError;
 export interface ASTMaps {
     esTreeNodeToTSNodeMap: ParserWeakMapESTreeToTSNode;
     tsNodeToESTreeNodeMap: ParserWeakMap<TSNode, TSESTree.Node>;

package/{_ts4.2 → _ts4.3}/dist/create-program/shared.d.ts

@@ -9,7 +9,7 @@ interface ASTAndDefiniteProgram {
     ast: ts.SourceFile;
     program: ts.Program;
 }
-type ASTAndProgram = ASTAndNoProgram | ASTAndDefiniteProgram;
+type ASTAndProgram = ASTAndDefiniteProgram | ASTAndNoProgram;
 /**
  * Compiler options required to avoid critical functionality issues
  */

package/{_ts4.2 → _ts4.3}/dist/getModifiers.d.ts

@@ -1,4 +1,4 @@
 import * as ts from 'typescript';
-export declare function getModifiers(node: ts.Node | null | undefined): undefined | ts.Modifier[];
-export declare function getDecorators(node: ts.Node | null | undefined): undefined | ts.Decorator[];
+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

package/{_ts4.2 → _ts4.3}/dist/index.d.ts

@@ -1,9 +1,10 @@
-export { AST, parse, parseAndGenerateServices, parseWithNodeMaps, ParseAndGenerateServicesResult, ParseWithNodeMapsResult, } from './parser';
+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';

package/{_ts4.2 → _ts4.3}/dist/node-utils.d.ts

@@ -1,34 +1,31 @@
 import * as ts from 'typescript';
-import type { TSESTree } from './ts-estree';
+import type { TSESTree, TSNode } from './ts-estree';
 import { AST_NODE_TYPES, AST_TOKEN_TYPES } from './ts-estree';
 declare const SyntaxKind: typeof ts.SyntaxKind;
-interface TokenToText extends TSESTree.PunctuatorTokenToText {
+type LogicalOperatorKind = ts.SyntaxKind.AmpersandAmpersandToken | ts.SyntaxKind.BarBarToken | ts.SyntaxKind.QuestionQuestionToken;
+interface TokenToText extends TSESTree.PunctuatorTokenToText, TSESTree.BinaryOperatorToText {
     [SyntaxKind.ImportKeyword]: 'import';
-    [SyntaxKind.InKeyword]: 'in';
-    [SyntaxKind.InstanceOfKeyword]: 'instanceof';
     [SyntaxKind.NewKeyword]: 'new';
     [SyntaxKind.KeyOfKeyword]: 'keyof';
     [SyntaxKind.ReadonlyKeyword]: 'readonly';
     [SyntaxKind.UniqueKeyword]: 'unique';
 }
-/**
- * Returns true if the given ts.Token is the assignment operator
- * @param operator the operator token
- * @returns is assignment
- */
-export declare function isAssignmentOperator<T extends ts.SyntaxKind>(operator: ts.Token<T>): boolean;
+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<T extends ts.SyntaxKind>(operator: ts.Token<T>): boolean;
+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): T extends keyof TokenToText ? TokenToText[T] : string | undefined;
+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
@@ -60,18 +57,21 @@ export declare function isComma(token: ts.Node): token is ts.Token<ts.SyntaxKind
  * @returns is comment
  */
 export declare function isComment(node: ts.Node): boolean;
-/**
- * Returns true if the given ts.Node is a JSDoc comment
- * @param node the TypeScript node
- * @returns is JSDoc comment
- */
-export declare function isJSDocComment(node: ts.Node): node is ts.JSDoc;
 /**
  * Returns the binary expression type of the given ts.Token
  * @param operator the operator token
  * @returns the binary expression type
  */
-export declare function getBinaryExpressionType<T extends ts.SyntaxKind>(operator: ts.Token<T>): AST_NODE_TYPES.AssignmentExpression | AST_NODE_TYPES.LogicalExpression | AST_NODE_TYPES.BinaryExpression;
+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
@@ -82,18 +82,17 @@ export declare function getLineAndCharacterFor(pos: number, ast: ts.SourceFile):
 /**
  * Returns line and column data for the given start and end positions,
  * for the given AST
- * @param start start data
- * @param end   end data
+ * @param range start end data
  * @param ast   the AST object
  * @returns the loc data
  */
-export declare function getLocFor(start: number, end: number, ast: ts.SourceFile): TSESTree.SourceLocation;
+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.SourceFile | ts.Block | ts.ModuleBlock | ts.ClassStaticBlockDeclaration): boolean;
+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
@@ -104,12 +103,6 @@ export declare function getRange(node: Pick<ts.Node, 'getEnd' | 'getStart'>, ast
     number,
     number
 ];
-/**
- * Returns true if a given ts.Node is a token
- * @param node the ts.Node
- * @returns is a token
- */
-export declare function isToken(node: ts.Node): node is ts.Token<ts.TokenSyntaxKind>;
 /**
  * Returns true if a given ts.Node is a JSX token
  * @param node ts.Node to be checked
@@ -121,13 +114,13 @@ export declare function isJSXToken(node: ts.Node): boolean;
  * @param node TypeScript AST node
  * @returns declaration kind
  */
-export declare function getDeclarationKind(node: ts.VariableDeclarationList): 'let' | 'const' | 'var';
+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): 'public' | 'protected' | 'private' | undefined;
+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
@@ -177,13 +170,13 @@ export declare function isChainExpression(node: TSESTree.Node): node is TSESTree
 /**
  * Returns true of the child of property access expression is an optional chain
  */
-export declare function isChildUnwrappableOptionalChain(node: ts.PropertyAccessExpression | ts.ElementAccessExpression | ts.CallExpression | ts.NonNullExpression, child: TSESTree.Node): boolean;
+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.Line | AST_TOKEN_TYPES.Block>;
+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
@@ -256,5 +249,6 @@ export declare function isThisIdentifier(node: ts.Node | undefined): node is ts.
 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 {};
 //# sourceMappingURL=node-utils.d.ts.map

package/{_ts4.2 → _ts4.3}/dist/parseSettings/createParseSettings.d.ts

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

package/{_ts4.2 → _ts4.3}/dist/parseSettings/getProjectConfigFiles.d.ts

@@ -8,5 +8,5 @@ import type { ParseSettings } from '.';
  * cache file checks for rapid subsequent calls to fs.existsSync. See discussion
  * in https://github.com/typescript-eslint/typescript-eslint/issues/101.
  */
-export declare function getProjectConfigFiles(parseSettings: Pick<ParseSettings, 'filePath' | 'tsconfigMatchCache' | 'tsconfigRootDir'>, project: string | string[] | true | undefined | null): string[] | null;
+export declare function getProjectConfigFiles(parseSettings: Pick<ParseSettings, 'filePath' | 'tsconfigMatchCache' | 'tsconfigRootDir'>, project: string[] | string | true | null | undefined): string[] | null;
 //# sourceMappingURL=getProjectConfigFiles.d.ts.map

package/{_ts4.2 → _ts4.3}/dist/parseSettings/index.d.ts

@@ -2,7 +2,7 @@ import type * as ts from 'typescript';
 import type { CanonicalPath } from '../create-program/shared';
 import type { TSESTree } from '../ts-estree';
 import type { CacheLike } from './ExpiringCache';
-type DebugModule = 'typescript-eslint' | 'eslint' | 'typescript';
+type DebugModule = 'eslint' | 'typescript-eslint' | 'typescript';
 /**
  * Internal settings used by the parser to run on a file.
  */
@@ -14,7 +14,7 @@ export interface MutableParseSettings {
     /**
      * Code of the file being parsed, or raw source file containing it.
      */
-    code: string | ts.SourceFile;
+    code: ts.SourceFile | string;
     /**
      * Full text of the file being parsed.
      */
@@ -82,7 +82,7 @@ export interface MutableParseSettings {
     /**
      * One or more instances of TypeScript Program objects to be used for type information.
      */
-    programs: null | Iterable<ts.Program>;
+    programs: Iterable<ts.Program> | null;
     /**
      * Normalized paths to provided project paths.
      */
@@ -102,7 +102,7 @@ export interface MutableParseSettings {
     /**
      * If the `tokens` parse option is enabled, retrieved tokens.
      */
-    tokens: null | TSESTree.Token[];
+    tokens: TSESTree.Token[] | null;
     /**
      * Caches searches for TSConfigs from project directories.
      */

package/{_ts4.2 → _ts4.3}/dist/parser-options.d.ts

@@ -47,7 +47,7 @@ interface ParseOptions {
      * This is similar to the `range` property, except it is line/column relative.
      */
     loc?: boolean;
-    loggerFn?: ((message: string) => void) | false;
+    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.
@@ -105,7 +105,7 @@ interface ParseAndGenerateServicesOptions extends ParseOptions {
      * 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;
+    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.
@@ -179,6 +179,6 @@ export interface ParserServicesWithTypeInformation extends ParserServicesNodeMap
 export interface ParserServicesWithoutTypeInformation extends ParserServicesNodeMaps {
     program: null;
 }
-export type ParserServices = ParserServicesWithTypeInformation | ParserServicesWithoutTypeInformation;
+export type ParserServices = ParserServicesWithoutTypeInformation | ParserServicesWithTypeInformation;
 export {};
 //# sourceMappingURL=parser-options.d.ts.map

package/_ts4.3/dist/parser.d.ts

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

package/{_ts4.2 → _ts4.3}/dist/simple-traverse.d.ts

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

package/{_ts4.2 → _ts4.3}/dist/source-files.d.ts

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

package/{_ts4.2 → _ts4.3}/dist/ts-estree/estree-to-ts-node-types.d.ts

@@ -4,17 +4,17 @@ 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.ArrayLiteralExpression | ts.ArrayBindingPattern;
+    [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.ShorthandPropertyAssignment | ts.BindingElement | ts.BinaryExpression | ts.ParameterDeclaration;
+    [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.PropertyAccessExpression | ts.ElementAccessExpression | ts.NonNullExpression;
+    [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;
@@ -26,16 +26,16 @@ export interface EstreeToTsNodeTypes {
     [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.ImportEqualsDeclaration | ts.InterfaceDeclaration | ts.EnumDeclaration | ts.ModuleDeclaration;
+    [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.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.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;
@@ -57,23 +57,23 @@ export interface EstreeToTsNodeTypes {
     [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.JSXNamespacedName]: ts.JsxNamespacedName;
     [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.Literal]: ts.BigIntLiteral | ts.BooleanLiteral | ts.NullLiteral | ts.NumericLiteral | ts.RegularExpressionLiteral | ts.StringLiteral;
     [AST_NODE_TYPES.LogicalExpression]: ts.BinaryExpression;
-    [AST_NODE_TYPES.MemberExpression]: ts.PropertyAccessExpression | ts.ElementAccessExpression;
+    [AST_NODE_TYPES.MemberExpression]: ts.ElementAccessExpression | ts.PropertyAccessExpression;
     [AST_NODE_TYPES.MetaProperty]: ts.MetaProperty;
-    [AST_NODE_TYPES.MethodDefinition]: ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.MethodDeclaration | ts.ConstructorDeclaration;
+    [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.ObjectLiteralExpression | ts.ObjectBindingPattern;
+    [AST_NODE_TYPES.ObjectPattern]: ts.ObjectBindingPattern | ts.ObjectLiteralExpression;
     [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.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.SpreadElement | ts.SpreadAssignment;
+    [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;
@@ -81,12 +81,12 @@ export interface EstreeToTsNodeTypes {
     [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.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.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.MethodDeclaration | ts.ConstructorDeclaration;
+    [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;
@@ -113,7 +113,7 @@ export interface EstreeToTsNodeTypes {
     [AST_NODE_TYPES.TSSatisfiesExpression]: ts.SatisfiesExpression;
     [AST_NODE_TYPES.TSLiteralType]: ts.LiteralTypeNode;
     [AST_NODE_TYPES.TSMappedType]: ts.MappedTypeNode;
-    [AST_NODE_TYPES.TSMethodSignature]: ts.MethodSignature | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration;
+    [AST_NODE_TYPES.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;
@@ -123,7 +123,7 @@ export interface EstreeToTsNodeTypes {
     [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.RestTypeNode | ts.NamedTupleMember;
+    [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;
@@ -134,21 +134,21 @@ export interface EstreeToTsNodeTypes {
     [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.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.TypeQueryNode | ts.ImportTypeNode;
+    [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.PrefixUnaryExpression | ts.PostfixUnaryExpression;
-    [AST_NODE_TYPES.UnaryExpression]: ts.PrefixUnaryExpression | ts.PostfixUnaryExpression | ts.DeleteExpression | ts.VoidExpression | ts.TypeOfExpression;
+    [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.FunctionExpression | ts.ConstructorDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.MethodDeclaration;
+    [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.NullLiteral | ts.KeywordTypeNode;
+    [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;
@@ -174,5 +174,5 @@ export interface EstreeToTsNodeTypes {
  * Maps TSESTree AST Node type to the expected TypeScript AST Node type(s).
  * This mapping is based on the internal logic of the parser.
  */
-export type TSESTreeToTSNode<T extends TSESTree.Node = TSESTree.Node> = Extract<TSNode | ts.Token<ts.SyntaxKind.NewKeyword | ts.SyntaxKind.ImportKeyword>, EstreeToTsNodeTypes[T['type']]>;
+export type TSESTreeToTSNode<T extends TSESTree.Node = TSESTree.Node> = Extract<ts.Token<ts.SyntaxKind.ImportKeyword | ts.SyntaxKind.NewKeyword> | TSNode, EstreeToTsNodeTypes[T['type']]>;
 //# sourceMappingURL=estree-to-ts-node-types.d.ts.map

package/{_ts4.2 → _ts4.3}/dist/ts-estree/ts-nodes.d.ts

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

package/_ts4.3/dist/use-at-your-own-risk.d.ts

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

package/_ts4.3/dist/version-check.d.ts

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

package/dist/convert-comments.js

@@ -42,7 +42,7 @@ function convertComments(ast, code) {
             ? ts_estree_1.AST_TOKEN_TYPES.Line
             : ts_estree_1.AST_TOKEN_TYPES.Block;
         const range = [comment.pos, comment.end];
-        const loc = (0, node_utils_1.getLocFor)(range[0], range[1], ast);
+        const loc = (0, node_utils_1.getLocFor)(range, ast);
         // both comments start with 2 characters - /* or //
         const textStart = range[0] + 2;
         const textEnd = comment.kind === ts.SyntaxKind.SingleLineCommentTrivia

package/dist/convert-comments.js.map

@@ -1 +1 @@
-{"version":3,"file":"convert-comments.js","sourceRoot":"","sources":["../src/convert-comments.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,sDAAwC;AACxC,+CAAiC;AAEjC,6CAAyC;AAEzC,2CAA8C;AAE9C;;;;;;GAMG;AACH,SAAgB,eAAe,CAC7B,GAAkB,EAClB,IAAY;IAEZ,MAAM,QAAQ,GAAuB,EAAE,CAAC;IAExC,OAAO,CAAC,cAAc,CACpB,GAAG,EACH,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE;QACb,MAAM,IAAI,GACR,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,uBAAuB;YACpD,CAAC,CAAC,2BAAe,CAAC,IAAI;YACtB,CAAC,CAAC,2BAAe,CAAC,KAAK,CAAC;QAC5B,MAAM,KAAK,GAAmB,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;QACzD,MAAM,GAAG,GAAG,IAAA,sBAAS,EAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAE/C,mDAAmD;QACnD,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC/B,MAAM,OAAO,GACX,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,uBAAuB;YACpD,CAAC,CAAC,sCAAsC;gBACtC,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS;YACtB,CAAC,CAAC,4CAA4C;gBAC5C,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,CAAC,CAAC;QAC/B,QAAQ,CAAC,IAAI,CAAC;YACZ,IAAI;YACJ,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC;YACjD,KAAK;YACL,GAAG;SACJ,CAAC,CAAC;IACL,CAAC,EACD,GAAG,CACJ,CAAC;IAEF,OAAO,QAAQ,CAAC;AAClB,CAAC;AAnCD,0CAmCC"}
+{"version":3,"file":"convert-comments.js","sourceRoot":"","sources":["../src/convert-comments.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,sDAAwC;AACxC,+CAAiC;AAEjC,6CAAyC;AAEzC,2CAA8C;AAE9C;;;;;;GAMG;AACH,SAAgB,eAAe,CAC7B,GAAkB,EAClB,IAAY;IAEZ,MAAM,QAAQ,GAAuB,EAAE,CAAC;IAExC,OAAO,CAAC,cAAc,CACpB,GAAG,EACH,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE;QACb,MAAM,IAAI,GACR,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,uBAAuB;YACpD,CAAC,CAAC,2BAAe,CAAC,IAAI;YACtB,CAAC,CAAC,2BAAe,CAAC,KAAK,CAAC;QAC5B,MAAM,KAAK,GAAmB,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;QACzD,MAAM,GAAG,GAAG,IAAA,sBAAS,EAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAElC,mDAAmD;QACnD,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC/B,MAAM,OAAO,GACX,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,uBAAuB;YACpD,CAAC,CAAC,sCAAsC;gBACtC,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS;YACtB,CAAC,CAAC,4CAA4C;gBAC5C,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,CAAC,CAAC;QAC/B,QAAQ,CAAC,IAAI,CAAC;YACZ,IAAI;YACJ,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC;YACjD,KAAK;YACL,GAAG;SACJ,CAAC,CAAC;IACL,CAAC,EACD,GAAG,CACJ,CAAC;IAEF,OAAO,QAAQ,CAAC;AAClB,CAAC;AAnCD,0CAmCC"}

package/dist/convert.d.ts

@@ -14,7 +14,7 @@ export interface ConverterOptions {
  * @param error the error object
  * @returns converted error object
  */
-export declare function convertError(error: ts.DiagnosticWithLocation | SemanticOrSyntacticError): TSError;
+export declare function convertError(error: SemanticOrSyntacticError | ts.DiagnosticWithLocation): TSError;
 export interface ASTMaps {
     esTreeNodeToTSNodeMap: ParserWeakMapESTreeToTSNode;
     tsNodeToESTreeNodeMap: ParserWeakMap<TSNode, TSESTree.Node>;

package/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;AAGjC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AA0B5C,OAAO,KAAK,EACV,aAAa,EACb,2BAA2B,EAC5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAoB,MAAM,EAAE,MAAM,aAAa,CAAC;AAKtE,MAAM,WAAW,gBAAgB;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,kCAAkC,CAAC,EAAE,OAAO,CAAC;CAC9C;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;IAE7B;;;;;OAKG;gBACS,GAAG,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,gBAAgB;IAK1D,UAAU,IAAI,OAAO;IAOrB,cAAc,IAAI,QAAQ,CAAC,OAAO;IAIlC;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IA8BjB;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAmElB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAW/B;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAItB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,UAAU;IAelB,OAAO,CAAC,oCAAoC;IAe5C;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IAqB7B;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAkC9B;;;;;OAKG;IACH,OAAO,CAAC,gDAAgD;IAexD;;;;OAIG;IACH,OAAO,CAAC,kDAAkD;IAe1D;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAgBzB,OAAO,CAAC,sBAAsB;IA4C9B;;;;OAIG;IACH,OAAO,CAAC,UAAU;IA+FlB,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,+BAA+B;IA6BvC;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,sBAAsB;IAoC9B,OAAO,CAAC,mBAAmB;IAQ3B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,qBAAqB;IAsB7B;;;;;;;OAOG;IACH,OAAO,CAAC,WAAW;CAwlFpB"}
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../src/convert.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAGjC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AA2B5C,OAAO,KAAK,EACV,aAAa,EACb,2BAA2B,EAC5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAoB,MAAM,EAAE,MAAM,aAAa,CAAC;AAKtE,MAAM,WAAW,gBAAgB;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,kCAAkC,CAAC,EAAE,OAAO,CAAC;CAC9C;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,wBAAwB,GAAG,EAAE,CAAC,sBAAsB,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;IAE7B;;;;;OAKG;gBACS,GAAG,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,gBAAgB;IAK1D,UAAU,IAAI,OAAO;IAOrB,cAAc,IAAI,QAAQ,CAAC,OAAO;IAIlC;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IA8BjB;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAmElB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAW/B;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAItB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,UAAU;IAelB,OAAO,CAAC,oCAAoC;IAe5C;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IAsB7B;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAkC9B;;;;;OAKG;IACH,OAAO,CAAC,gDAAgD;IAexD;;;;OAIG;IACH,OAAO,CAAC,kDAAkD;IAmB1D;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAgBzB,OAAO,CAAC,sBAAsB;IA4C9B;;;;OAIG;IACH,OAAO,CAAC,UAAU;IA+FlB,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,+BAA+B;IAiDvC;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,sBAAsB;IAoC9B,OAAO,CAAC,mBAAmB;IAQ3B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,qBAAqB;IAsB7B;;;;;;;OAOG;IACH,OAAO,CAAC,WAAW;CAknFpB"}