@flint.fyi/typescript-language 0.0.0 → 0.18.0

package/lib/language.js

@@ -1,23 +1,117 @@
-import { prepareTypeScriptBasedLanguage } from "./prepareTypeScriptBasedLanguage.js";
-import { prepareTypeScriptFile } from "./prepareTypeScriptFile.js";
+import { convertTypeScriptDiagnosticToLanguageReport } from "./convertTypeScriptDiagnosticToLanguageReport.js";
+import { parseDirectivesFromTypeScriptFile } from "./directives/parseDirectivesFromTypeScriptFile.js";
+import { name, version } from "./package.js";
+import { createTypeScriptServerHost } from "./createTypeScriptServerHost.js";
+import { getFirstEnumValues } from "./getFirstEnumValues.js";
+import { getTypeScriptFileCacheImpacts } from "./getTypeScriptFileCacheImpacts.js";
 import { createLanguage } from "@flint.fyi/core";
-
+import * as ts$1 from "typescript";
+import { assert, nullThrows } from "@flint.fyi/utils";
+import { createProjectService } from "@typescript-eslint/project-service";
+import { debugForFile } from "debug-for-file";
+import path from "node:path";
 //#region src/language.ts
+const log = debugForFile(import.meta.filename);
+const NodeSyntaxKinds = getFirstEnumValues(ts$1.SyntaxKind);
+const stateSymbol = Symbol.for("@flint.fyi/typescript-language/state");
+const globalTyped = globalThis;
+assert(globalTyped[stateSymbol] == null, `Two different versions of ${name} are imported: ${version} and ${globalTyped[stateSymbol]?.packageVersion}`);
+const languageState = globalTyped[stateSymbol] = {
+	packageVersion: version,
+	volarCreateFile: null
+};
+function setVolarCreateFile(create) {
+	assert(languageState.volarCreateFile == null, "setVolarCreateFile is expected to be called only once");
+	languageState.volarCreateFile = create;
+}
 const typescriptLanguage = createLanguage({
 	about: { name: "TypeScript" },
-	createFileFactory: () => {
-		const language = prepareTypeScriptBasedLanguage();
-		return {
-			prepareFromDisk(data) {
-				return prepareTypeScriptFile(data, language.createFromDisk(data.filePathAbsolute));
-			},
-			prepareFromVirtual(data) {
-				return prepareTypeScriptFile(data, language.createFromVirtual(data.filePathAbsolute, data.sourceText));
-			}
+	createFileFactory: (host) => {
+		const { service } = createProjectService({ host: createTypeScriptServerHost(host) });
+		function createFile(data) {
+			log("Opening client file:", data.filePathAbsolute);
+			service.openClientFile(data.filePathAbsolute);
+			log("Retrieving client services:", data.filePathAbsolute);
+			const scriptInfo = nullThrows(service.getScriptInfo(data.filePathAbsolute), `Could not find script info for file: ${data.filePathAbsolute}`);
+			const program = nullThrows(nullThrows(service.getDefaultProjectForFile(scriptInfo.fileName, true), `Could not find default project for file: ${data.filePathAbsolute}`).getLanguageService(true).getProgram(), `Could not retrieve program for file: ${data.filePathAbsolute}`);
+			const sourceFile = nullThrows(program.getSourceFile(data.filePathAbsolute), `Could not retrieve source file for: ${data.filePathAbsolute}`);
+			const fileExtension = path.extname(data.filePathAbsolute);
+			if (typeScriptCoreSupportedExtensions.has(fileExtension)) return {
+				...parseDirectivesFromTypeScriptFile(sourceFile),
+				about: data,
+				language: typescriptLanguage,
+				services: {
+					program,
+					sourceFile,
+					typeChecker: program.getTypeChecker()
+				},
+				[Symbol.dispose]() {
+					service.closeClientFile(data.filePathAbsolute);
+				}
+			};
+			if (languageState.volarCreateFile == null) throwUnknownLanguageExtension(data.filePathAbsolute);
+			return {
+				...languageState.volarCreateFile(data, program, sourceFile),
+				[Symbol.dispose]() {
+					service.closeClientFile(data.filePathAbsolute);
+				}
+			};
+		}
+		return { createFile };
+	},
+	getFileCacheImpacts: getTypeScriptFileCacheImpacts,
+	getLanguageReports(file) {
+		if ("__volarServices" in file) return file.__volarServices.getLanguageReports();
+		return ts$1.getPreEmitDiagnostics(file.services.program, file.services.sourceFile).map(convertTypeScriptDiagnosticToLanguageReport);
+	},
+	runFileVisitors(file, options, runtime) {
+		if (!runtime.visitors) return;
+		if ("__volarServices" in file) {
+			file.__volarServices.runVisitors(file, options, runtime);
+			return;
+		}
+		const { visitors } = runtime;
+		const visitorServices = {
+			options,
+			...file.services
+		};
+		const visit = (node) => {
+			const key = NodeSyntaxKinds[node.kind];
+			visitors[key]?.(node, visitorServices);
+			node.forEachChild(visit);
+			visitors[`${key}:exit`]?.(node, visitorServices);
 		};
+		visit(file.services.sourceFile);
 	}
 });
-
+const typeScriptCoreSupportedExtensions = new Set([
+	".cjs",
+	".cts",
+	".d.cts",
+	".d.mts",
+	".d.ts",
+	".js",
+	".json",
+	".jsx",
+	".mjs",
+	".mts",
+	".ts",
+	".tsx"
+]);
+const fileExtToFlintPlugin = {
+	".astro": "@flint.fyi/astro",
+	".gjs": "@flint.fyi/ember",
+	".gts": "@flint.fyi/ember",
+	".mdx": "@flint.fyi/mdx",
+	".svelte": "@flint.fyi/svelte",
+	".vue": "@flint.fyi/vue"
+};
+function throwUnknownLanguageExtension(filename) {
+	const pluginName = fileExtToFlintPlugin[path.extname(filename)];
+	const message = pluginName ? `Did you install & import ${pluginName}?` : "Unknown extension.";
+	throw new Error(`Cannot process ${filename}. ${message}`);
+}
 //#endregion
-export { typescriptLanguage };
+export { NodeSyntaxKinds, setVolarCreateFile, throwUnknownLanguageExtension, typescriptLanguage };
+
 //# sourceMappingURL=language.js.map

package/lib/nodes.d.ts

@@ -1,4 +1,5 @@
 import { AnyKeyword, ArrayBindingPattern, ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AwaitExpression, BigIntKeyword, BigIntLiteral, BinaryExpression, BindingElement, Block, BooleanKeyword, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseClause, CatchClause, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, CommaListExpression, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, DebuggerStatement, Decorator, DefaultClause, DeleteExpression, DoStatement, ElementAccessExpression, EmptyStatement, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleReference, FalseLiteral, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportExpression, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, IntrinsicKeyword, JSDocAllType, JSDocFunctionType, JSDocLink, JSDocLinkCode, JSDocLinkPlain, JSDocMemberName, JSDocNamepathType, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocParameterTag, JSDocPropertyTag, JSDocReturnTag, JSDocSignature, JSDocTemplateTag, JSDocText, JSDocTypeExpression, JSDocTypeLiteral, JSDocUnknownType, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxClosingFragment, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxOpeningFragment, JsxSelfClosingElement, JsxSpreadAttribute, JsxText, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignature, MissingDeclaration, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NeverKeyword, NewExpression, NoSubstitutionTemplateLiteral, NonNullExpression, NotEmittedStatement, NotEmittedTypeElement, NullLiteral, NumberKeyword, NumericLiteral, ObjectBindingPattern, ObjectKeyword, ObjectLiteralExpression, OmittedExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignature, QualifiedName, RegularExpressionLiteral, RestTypeNode, ReturnStatement, SatisfiesExpression, SemicolonClassElement, SetAccessorDeclaration, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringKeyword, StringLiteral, SuperExpression, SwitchStatement, SymbolKeyword, SyntheticExpression, TaggedTemplateExpression, TemplateExpression, TemplateHead, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateMiddle, TemplateSpan, TemplateTail, ThisExpression, ThisTypeNode, ThrowStatement, TrueLiteral, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UndefinedKeyword, UnionTypeNode, UnknownKeyword, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, VoidKeyword, WhileStatement, WithStatement, YieldExpression } from "./types/ast.js";
+import { WithExitKeys } from "@flint.fyi/core";
 
 //#region src/nodes.d.ts
 interface TypeScriptNodesByName {
@@ -197,6 +198,7 @@ interface TypeScriptNodesByName {
   WithStatement: WithStatement;
   YieldExpression: YieldExpression;
 }
+type TypeScriptNodeVisitors = WithExitKeys<TypeScriptNodesByName>;
 //#endregion
-export { TypeScriptNodesByName };
+export { TypeScriptNodeVisitors, TypeScriptNodesByName };
 //# sourceMappingURL=nodes.d.ts.map

package/lib/normalizeRange.js

@@ -1,5 +1,4 @@
 import { getColumnAndLineOfPosition } from "@flint.fyi/core";
-
 //#region src/normalizeRange.ts
 function normalizeRange(original, sourceFile) {
 	const onCharacters = isNode(original) ? {
@@ -14,7 +13,7 @@ function normalizeRange(original, sourceFile) {
 function isNode(value) {
 	return typeof value === "object" && value !== null && "kind" in value;
 }
-
 //#endregion
 export { normalizeRange };
+
 //# sourceMappingURL=normalizeRange.js.map

package/lib/package.js

@@ -0,0 +1,7 @@
+//#region package.json
+var name = "@flint.fyi/typescript-language";
+var version = "0.18.0";
+//#endregion
+export { name, version };
+
+//# sourceMappingURL=package.js.map

package/lib/types/ast.d.ts

@@ -1689,7 +1689,7 @@ interface SourceFile extends ts.Node {
    *
    * Note that this field is only set by the module resolution process when
    * `moduleResolution` is `Node16` or `NodeNext`, which is implied by the `module` setting
-   * of `Node16` or `NodeNext`, respectively, but may be overriden (eg, by a `moduleResolution`
+   * of `Node16` or `NodeNext`, respectively, but may be overridden (eg, by a `moduleResolution`
    * of `node`). If so, this field will be unset and source files will be considered to be
    * CommonJS-output-format by the node module transformer and type checker, regardless of extension or context.
    */
@@ -2066,5 +2066,5 @@ type ModifierParent = AccessorDeclaration | ArrowFunction | ClassDeclaration | C
 type StatementParent = Block | CaseOrDefaultClause | IfStatement | IterationStatement | LabeledStatement | ModuleBlock | SourceFile | WithStatement;
 type TypeNodeParent = AccessorDeclaration | ArrayTypeNode | ArrowFunction | AsExpression | CallExpression | CallSignatureDeclaration | ConditionalTypeNode | ConstructorDeclaration | ConstructSignatureDeclaration | FunctionDeclaration | FunctionExpression | FunctionOrConstructorTypeNodeBase | IndexedAccessTypeNode | IndexSignatureDeclaration | IntersectionTypeNode | JSDocFunctionType | JSDocNamepathType | JSDocNonNullableType | JSDocNullableType | JSDocOptionalType | JSDocTypeExpression | JSDocVariadicType | JsxOpeningElement | JsxSelfClosingElement | MappedTypeNode | MethodDeclaration | MethodSignature | NamedTupleMember | NewExpression | NodeWithTypeArguments | OptionalTypeNode | ParameterDeclaration | ParenthesizedTypeNode | PropertyDeclaration | PropertySignature | RestTypeNode | SatisfiesExpression | TaggedTemplateExpression | TemplateLiteralTypeSpan | TupleTypeNode | TypeAliasDeclaration | TypeAssertion | TypeOperatorNode | TypeParameterDeclaration | TypePredicateNode | UnionTypeNode | VariableDeclaration;
 //#endregion
-export { AnyKeyword, ArrayBindingPattern, ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AwaitExpression, BigIntKeyword, BigIntLiteral, BinaryExpression, BindingElement, Block, BooleanKeyword, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseClause, CatchClause, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, CommaListExpression, ComputedPropertyName, ConciseBody, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, DebuggerStatement, Decorator, DefaultClause, DeleteExpression, DoStatement, ElementAccessExpression, EmptyStatement, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, Expression, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleReference, FalseLiteral, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportExpression, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, IntrinsicKeyword, JSDocAllType, JSDocFunctionType, JSDocLink, JSDocLinkCode, JSDocLinkPlain, JSDocMemberName, JSDocNamepathType, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocParameterTag, JSDocPropertyTag, JSDocReturnTag, JSDocSignature, JSDocTemplateTag, JSDocText, JSDocTypeExpression, JSDocTypeLiteral, JSDocUnknownType, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxClosingFragment, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxOpeningFragment, JsxSelfClosingElement, JsxSpreadAttribute, JsxText, LabeledStatement, LeftHandSideExpressionParent, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignature, MissingDeclaration, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NeverKeyword, NewExpression, NoSubstitutionTemplateLiteral, NonNullExpression, NotEmittedStatement, NotEmittedTypeElement, NullLiteral, NumberKeyword, NumericLiteral, ObjectBindingPattern, ObjectKeyword, ObjectLiteralExpression, OmittedExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignature, QualifiedName, RegularExpressionLiteral, RestTypeNode, ReturnStatement, SatisfiesExpression, SemicolonClassElement, SetAccessorDeclaration, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringKeyword, StringLiteral, SuperExpression, SwitchStatement, SymbolKeyword, SyntheticExpression, TaggedTemplateExpression, TemplateExpression, TemplateHead, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateMiddle, TemplateSpan, TemplateTail, ThisExpression, ThisTypeNode, ThrowStatement, TrueLiteral, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UndefinedKeyword, UnionTypeNode, UnknownKeyword, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, VoidKeyword, WhileStatement, WithStatement, YieldExpression, ast_d_exports };
+export { AnyKeyword, AnyNode, ArrayBindingPattern, ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AwaitExpression, BigIntKeyword, BigIntLiteral, BinaryExpression, BindingElement, Block, BooleanKeyword, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseClause, CatchClause, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, CommaListExpression, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, DebuggerStatement, Decorator, DefaultClause, DeleteExpression, DoStatement, ElementAccessExpression, EmptyStatement, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, Expression, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleReference, FalseLiteral, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportExpression, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, IntrinsicKeyword, JSDocAllType, JSDocFunctionType, JSDocLink, JSDocLinkCode, JSDocLinkPlain, JSDocMemberName, JSDocNamepathType, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocParameterTag, JSDocPropertyTag, JSDocReturnTag, JSDocSignature, JSDocTemplateTag, JSDocText, JSDocTypeExpression, JSDocTypeLiteral, JSDocUnknownType, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxClosingFragment, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxOpeningFragment, JsxSelfClosingElement, JsxSpreadAttribute, JsxText, LabeledStatement, LeftHandSideExpressionParent, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignature, MissingDeclaration, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NeverKeyword, NewExpression, NoSubstitutionTemplateLiteral, NonNullExpression, NotEmittedStatement, NotEmittedTypeElement, NullLiteral, NumberKeyword, NumericLiteral, ObjectBindingPattern, ObjectKeyword, ObjectLiteralExpression, OmittedExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignature, QualifiedName, RegularExpressionLiteral, RestTypeNode, ReturnStatement, SatisfiesExpression, SemicolonClassElement, SetAccessorDeclaration, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringKeyword, StringLiteral, SuperExpression, SwitchStatement, SymbolKeyword, SyntheticExpression, TaggedTemplateExpression, TemplateExpression, TemplateHead, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateMiddle, TemplateSpan, TemplateTail, ThisExpression, ThisTypeNode, ThrowStatement, TrueLiteral, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UndefinedKeyword, UnionTypeNode, UnknownKeyword, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, VoidKeyword, WhileStatement, WithStatement, YieldExpression, ast_d_exports };
 //# sourceMappingURL=ast.d.ts.map

package/lib/utils/createRuleTesterTSConfig.d.ts

@@ -0,0 +1,8 @@
+//#region src/utils/createRuleTesterTSConfig.d.ts
+declare function createRuleTesterTSConfig(defaultCompilerOptions?: Record<string, unknown>): {
+  "tsconfig.base.json": string;
+  "tsconfig.json": string;
+};
+//#endregion
+export { createRuleTesterTSConfig };
+//# sourceMappingURL=createRuleTesterTSConfig.d.ts.map

package/lib/utils/createRuleTesterTSConfig.js

@@ -0,0 +1,18 @@
+//#region src/utils/createRuleTesterTSConfig.ts
+function createRuleTesterTSConfig(defaultCompilerOptions) {
+	return {
+		"tsconfig.base.json": JSON.stringify({ compilerOptions: {
+			lib: ["esnext"],
+			moduleResolution: "bundler",
+			strict: true,
+			target: "esnext",
+			types: [],
+			...defaultCompilerOptions
+		} }, null, 2),
+		"tsconfig.json": JSON.stringify({ extends: "./tsconfig.base.json" }, null, 2)
+	};
+}
+//#endregion
+export { createRuleTesterTSConfig };
+
+//# sourceMappingURL=createRuleTesterTSConfig.js.map

package/lib/utils/declarationIncludesGlobal.js

@@ -3,7 +3,7 @@ function declarationIncludesGlobal(declaration) {
 	const sourceFile = declaration.getSourceFile();
 	return sourceFile.hasNoDefaultLib || /\/lib\.[^/]*\.d\.ts$/.test(sourceFile.fileName);
 }
-
 //#endregion
 export { declarationIncludesGlobal };
+
 //# sourceMappingURL=declarationIncludesGlobal.js.map

package/lib/utils/declarationsIncludeGlobal.js

@@ -1,10 +1,9 @@
 import { declarationIncludesGlobal } from "./declarationIncludesGlobal.js";
-
 //#region src/utils/declarationsIncludeGlobal.ts
 function declarationsIncludeGlobal(declarations) {
 	return declarations.some(declarationIncludesGlobal);
 }
-
 //#endregion
 export { declarationsIncludeGlobal };
+
 //# sourceMappingURL=declarationsIncludeGlobal.js.map

package/lib/utils/getDeclarationsIfGlobal.d.ts

@@ -1,10 +1,9 @@
-import { Expression } from "../lib/types/ast.js";
-import { Checker } from "../lib/types/checker.js";
-import "../lib/index.js";
-import * as typescript0 from "typescript";
+import { Expression } from "../types/ast.js";
+import { Checker } from "../types/checker.js";
+import * as typescript from "typescript";
 
 //#region src/utils/getDeclarationsIfGlobal.d.ts
-declare function getDeclarationsIfGlobal(node: Expression, typeChecker: Checker): typescript0.Declaration[] | undefined;
+declare function getDeclarationsIfGlobal(node: Expression, typeChecker: Checker): typescript.Declaration[] | undefined;
 //#endregion
 export { getDeclarationsIfGlobal };
 //# sourceMappingURL=getDeclarationsIfGlobal.d.ts.map

package/lib/utils/getDeclarationsIfGlobal.js

@@ -1,11 +1,10 @@
 import { declarationsIncludeGlobal } from "./declarationsIncludeGlobal.js";
-
 //#region src/utils/getDeclarationsIfGlobal.ts
 function getDeclarationsIfGlobal(node, typeChecker) {
 	const declarations = typeChecker.getSymbolAtLocation(node)?.getDeclarations();
 	return !!declarations && declarationsIncludeGlobal(declarations) ? declarations : void 0;
 }
-
 //#endregion
 export { getDeclarationsIfGlobal };
+
 //# sourceMappingURL=getDeclarationsIfGlobal.js.map

package/lib/utils/getModifyingReferences.d.ts

@@ -1,10 +1,8 @@
 import { Identifier, SourceFile } from "../types/ast.js";
-import { Checker } from "../lib/types/checker.js";
-import "../lib/index.js";
+import { Checker } from "../types/checker.js";
 import ts from "typescript";
 
 //#region src/utils/getModifyingReferences.d.ts
-
 /**
  * Gets all references to a variable that modify it (assignments, increments, decrements).
  *

package/lib/utils/getModifyingReferences.js

@@ -1,6 +1,5 @@
 import ts from "typescript";
 import * as tsutils from "ts-api-utils";
-
 //#region src/utils/getModifyingReferences.ts
 /**
 * Gets all references to a variable that modify it (assignments, increments, decrements).
@@ -11,23 +10,26 @@ import * as tsutils from "ts-api-utils";
 function getModifyingReferences(identifier, sourceFile, typeChecker) {
 	const symbol = typeChecker.getSymbolAtLocation(identifier);
 	if (!symbol?.valueDeclaration) return [];
-	const valueDeclaration = symbol.valueDeclaration;
+	const { valueDeclaration } = symbol;
 	const modifyingReferences = [];
-	function visit(node) {
-		if (ts.isIdentifier(node)) {
-			const nodeSymbol = typeChecker.getSymbolAtLocation(node);
-			if (nodeSymbol?.valueDeclaration && nodeSymbol.valueDeclaration === valueDeclaration) {
-				const parent = node.parent;
-				if (ts.isBinaryExpression(parent) && tsutils.isAssignmentKind(parent.operatorToken.kind) && parent.left === node) modifyingReferences.push(node);
-				else if ((ts.isPostfixUnaryExpression(parent) || ts.isPrefixUnaryExpression(parent)) && parent.operand === node) modifyingReferences.push(node);
-			}
+	function isIdentifierForSameSymbol(node) {
+		if (node.kind !== ts.SyntaxKind.Identifier) return false;
+		if (typeChecker.getSymbolAtLocation(node)?.valueDeclaration !== valueDeclaration) return false;
+		switch (node.parent.kind) {
+			case ts.SyntaxKind.BinaryExpression: return tsutils.isAssignmentKind(node.parent.operatorToken.kind) && node.parent.left === node;
+			case ts.SyntaxKind.PostfixUnaryExpression:
+			case ts.SyntaxKind.PrefixUnaryExpression: return node.parent.operand === node;
+			default: return false;
 		}
+	}
+	function visit(node) {
+		if (isIdentifierForSameSymbol(node)) modifyingReferences.push(node);
 		ts.forEachChild(node, visit);
 	}
 	visit(sourceFile);
 	return modifyingReferences;
 }
-
 //#endregion
 export { getModifyingReferences };
+
 //# sourceMappingURL=getModifyingReferences.js.map

package/lib/utils/hasSameTokens.d.ts

@@ -1,7 +1,7 @@
-import { Expression, SourceFile } from "../types/ast.js";
+import { AnyNode, SourceFile } from "../types/ast.js";
 
 //#region src/utils/hasSameTokens.d.ts
-declare function hasSameTokens(nodeA: Expression, nodeB: Expression, sourceFile: SourceFile): boolean;
+declare function hasSameTokens(nodeA: AnyNode, nodeB: AnyNode, sourceFile: SourceFile): boolean;
 //#endregion
 export { hasSameTokens };
 //# sourceMappingURL=hasSameTokens.d.ts.map

package/lib/utils/hasSameTokens.js

@@ -1,10 +1,9 @@
-import { unwrapParenthesizedExpression } from "./unwrapParenthesizedExpression.js";
+import { unwrapParenthesizedNode } from "./unwrapParenthesizedNode.js";
 import ts from "typescript";
-
 //#region src/utils/hasSameTokens.ts
 function hasSameTokens(nodeA, nodeB, sourceFile) {
-	const queueA = [unwrapParenthesizedExpression(nodeA)];
-	const queueB = [unwrapParenthesizedExpression(nodeB)];
+	const queueA = [unwrapParenthesizedNode(nodeA)];
+	const queueB = [unwrapParenthesizedNode(nodeB)];
 	while (true) {
 		const currentA = queueA.shift();
 		const currentB = queueB.shift();
@@ -27,7 +26,7 @@ function areSameToken(nodeA, nodeB, sourceFile) {
 	if (nodeA.kind === ts.SyntaxKind.RegularExpressionLiteral) return sourceFile.text.slice(nodeA.getStart(sourceFile), nodeA.getEnd()) === sourceFile.text.slice(nodeB.getStart(sourceFile), nodeB.getEnd());
 	return true;
 }
-
 //#endregion
 export { hasSameTokens };
+
 //# sourceMappingURL=hasSameTokens.js.map

package/lib/utils/isBuiltinArrayMethod.d.ts

@@ -1,6 +1,5 @@
-import { CallExpression, PropertyAccessExpression } from "../lib/types/ast.js";
-import { Checker } from "../lib/types/checker.js";
-import "../lib/index.js";
+import { CallExpression, PropertyAccessExpression } from "../types/ast.js";
+import { Checker } from "../types/checker.js";
 import ts from "typescript";
 
 //#region src/utils/isBuiltinArrayMethod.d.ts

package/lib/utils/isBuiltinArrayMethod.js

@@ -1,10 +1,9 @@
 import ts from "typescript";
-
 //#region src/utils/isBuiltinArrayMethod.ts
 function isBuiltinArrayMethod(name, node, typeChecker) {
 	return ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === name && typeChecker.isArrayType(typeChecker.getTypeAtLocation(node.expression.expression)) && !ts.isExpressionStatement(node.parent);
 }
-
 //#endregion
 export { isBuiltinArrayMethod };
+
 //# sourceMappingURL=isBuiltinArrayMethod.js.map

package/lib/utils/isFunction.d.ts

@@ -1,7 +1,5 @@
-import { Expression } from "../lib/types/ast.js";
-import { Checker } from "../lib/types/checker.js";
-import "../lib/index.js";
-
+import { Expression } from "../types/ast.js";
+import { Checker } from "../types/checker.js";
 //#region src/utils/isFunction.d.ts
 declare function isFunction(node: Expression, typeChecker: Checker): boolean;
 //#endregion

package/lib/utils/isFunction.js

@@ -2,7 +2,7 @@
 function isFunction(node, typeChecker) {
 	return !!typeChecker.getTypeAtLocation(node).getCallSignatures().length;
 }
-
 //#endregion
 export { isFunction };
+
 //# sourceMappingURL=isFunction.js.map

package/lib/utils/isGlobalDeclaration.d.ts

@@ -1,7 +1,5 @@
-import { Expression } from "../lib/types/ast.js";
-import { Checker } from "../lib/types/checker.js";
-import "../lib/index.js";
-
+import { Expression } from "../types/ast.js";
+import { Checker } from "../types/checker.js";
 //#region src/utils/isGlobalDeclaration.d.ts
 declare function isGlobalDeclaration(node: Expression, typeChecker: Checker): boolean;
 //#endregion

package/lib/utils/isGlobalDeclaration.js

@@ -1,10 +1,9 @@
 import { getDeclarationsIfGlobal } from "./getDeclarationsIfGlobal.js";
-
 //#region src/utils/isGlobalDeclaration.ts
 function isGlobalDeclaration(node, typeChecker) {
 	return !!getDeclarationsIfGlobal(node, typeChecker);
 }
-
 //#endregion
 export { isGlobalDeclaration };
+
 //# sourceMappingURL=isGlobalDeclaration.js.map

package/lib/utils/isGlobalDeclarationOfName.d.ts

@@ -1,5 +1,4 @@
-import { Checker } from "../lib/types/checker.js";
-import "../lib/index.js";
+import { Checker } from "../types/checker.js";
 import ts from "typescript";
 
 //#region src/utils/isGlobalDeclarationOfName.d.ts

package/lib/utils/isGlobalDeclarationOfName.js

@@ -1,6 +1,5 @@
 import { declarationIncludesGlobal } from "./declarationIncludesGlobal.js";
 import ts from "typescript";
-
 //#region src/utils/isGlobalDeclarationOfName.ts
 /**
 * TODO: Use a scope analyzer (#400).
@@ -18,7 +17,7 @@ function isDeclarationOfName(node, name) {
 	if (ts.isClassDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isVariableDeclaration(node)) return node.name && ts.isIdentifier(node.name) && node.name.text === name;
 	return false;
 }
-
 //#endregion
 export { isGlobalDeclarationOfName };
+
 //# sourceMappingURL=isGlobalDeclarationOfName.js.map

package/lib/utils/isGlobalVariable.d.ts

@@ -1,9 +1,6 @@
-import { Expression } from "../lib/types/ast.js";
-import { Checker } from "../lib/types/checker.js";
-import "../lib/index.js";
-
+import { Expression } from "../types/ast.js";
+import { Checker } from "../types/checker.js";
 //#region src/utils/isGlobalVariable.d.ts
-
 /**
  * Checks if a node is a reference to a global variable (e.g., Object, undefined, NaN).
  * Global variables are those declared in TypeScript's lib files or are global identifiers

package/lib/utils/isGlobalVariable.js

@@ -1,5 +1,4 @@
 import { declarationsIncludeGlobal } from "./declarationsIncludeGlobal.js";
-
 //#region src/utils/isGlobalVariable.ts
 /**
 * Checks if a node is a reference to a global variable (e.g., Object, undefined, NaN).
@@ -14,7 +13,7 @@ function isGlobalVariable(node, typeChecker) {
 	if (!declarations?.length) return true;
 	return declarationsIncludeGlobal(declarations);
 }
-
 //#endregion
 export { isGlobalVariable };
+
 //# sourceMappingURL=isGlobalVariable.js.map

package/lib/utils/isInlineArrayCreation.d.ts

@@ -1,7 +1,6 @@
 import * as ts$1 from "typescript";
 
 //#region src/utils/isInlineArrayCreation.d.ts
-
 /**
  * Checks if a node represents an inline array creation expression.
  * These are cases where a new array is created immediately before the method call,

package/lib/utils/isInlineArrayCreation.js

@@ -1,5 +1,4 @@
 import * as ts$1 from "typescript";
-
 //#region src/utils/isInlineArrayCreation.ts
 const methodsReturningNewArray = new Set([
 	"concat",
@@ -40,7 +39,7 @@ function isInlineArrayCreation(node) {
 	if (ts$1.isNewExpression(node) && ts$1.isIdentifier(node.expression) && node.expression.text === "Array") return true;
 	return false;
 }
-
 //#endregion
 export { isInlineArrayCreation };
+
 //# sourceMappingURL=isInlineArrayCreation.js.map

package/lib/utils/unwrapParentParenthesizedExpressions.d.ts

@@ -1,7 +1,7 @@
 import { BinaryExpression, LeftHandSideExpressionParent, ParenthesizedExpression } from "../types/ast.js";
 
 //#region src/utils/unwrapParentParenthesizedExpressions.d.ts
-declare function unwrapParenthesizedExpressionsParent(node: BinaryExpression | ParenthesizedExpression): LeftHandSideExpressionParent;
+declare function unwrapParentParenthesizedExpressions(node: BinaryExpression | ParenthesizedExpression): LeftHandSideExpressionParent;
 //#endregion
-export { unwrapParenthesizedExpressionsParent };
+export { unwrapParentParenthesizedExpressions };
 //# sourceMappingURL=unwrapParentParenthesizedExpressions.d.ts.map

package/lib/utils/unwrapParentParenthesizedExpressions.js

@@ -1,10 +1,9 @@
 import { SyntaxKind } from "typescript";
-
 //#region src/utils/unwrapParentParenthesizedExpressions.ts
-function unwrapParenthesizedExpressionsParent(node) {
-	return node.parent.kind === SyntaxKind.ParenthesizedExpression ? unwrapParenthesizedExpressionsParent(node.parent) : node.parent;
+function unwrapParentParenthesizedExpressions(node) {
+	return node.parent.kind === SyntaxKind.ParenthesizedExpression ? unwrapParentParenthesizedExpressions(node.parent) : node.parent;
 }
-
 //#endregion
-export { unwrapParenthesizedExpressionsParent };
+export { unwrapParentParenthesizedExpressions };
+
 //# sourceMappingURL=unwrapParentParenthesizedExpressions.js.map

package/lib/utils/unwrapParenthesizedNode.d.ts

@@ -0,0 +1,7 @@
+import { AnyNode } from "../types/ast.js";
+
+//#region src/utils/unwrapParenthesizedNode.d.ts
+declare function unwrapParenthesizedNode(node: AnyNode): AnyNode;
+//#endregion
+export { unwrapParenthesizedNode };
+//# sourceMappingURL=unwrapParenthesizedNode.d.ts.map

package/lib/utils/unwrapParenthesizedNode.js

@@ -0,0 +1,9 @@
+import { SyntaxKind } from "typescript";
+//#region src/utils/unwrapParenthesizedNode.ts
+function unwrapParenthesizedNode(node) {
+	return node.kind === SyntaxKind.ParenthesizedExpression ? unwrapParenthesizedNode(node.expression) : node;
+}
+//#endregion
+export { unwrapParenthesizedNode };
+
+//# sourceMappingURL=unwrapParenthesizedNode.js.map