@flint.fyi/typescript-language 0.18.2 → 0.18.4

package/lib/normalizeRange.js

@@ -15,5 +15,3 @@ function isNode(value) {
 }
 //#endregion
 export { normalizeRange };
-
-//# sourceMappingURL=normalizeRange.js.map

package/lib/orderTypeScriptFilePaths.d.ts

@@ -1,3 +1,2 @@
 import type { LinterHost } from "@flint.fyi/core";
 export declare function orderTypeScriptFilePaths(filePaths: readonly string[], host: LinterHost): string[];
-//# sourceMappingURL=orderTypeScriptFilePaths.d.ts.map

package/lib/orderTypeScriptFilePaths.js

@@ -88,5 +88,3 @@ function orderTypeScriptFilePaths(filePaths, host) {
 }
 //#endregion
 export { orderTypeScriptFilePaths };
-
-//# sourceMappingURL=orderTypeScriptFilePaths.js.map

package/lib/package.js

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

package/lib/scope/identifierReferences.d.ts

@@ -0,0 +1,3 @@
+import type * as AST from "../types/ast.ts";
+export declare function isNonReferenceIdentifier(identifier: AST.Identifier): boolean;
+export declare function isWriteReference(identifier: AST.Identifier): boolean;

package/lib/scope/identifierReferences.js

@@ -0,0 +1,89 @@
+import { SyntaxKind } from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/scope/identifierReferences.ts
+function isNonReferenceIdentifier(identifier) {
+	if (isIdentifierDeclaration(identifier) || isTypeReferenceIdentifier(identifier)) return true;
+	const { parent } = identifier;
+	switch (parent.kind) {
+		case SyntaxKind.BindingElement:
+		case SyntaxKind.ImportSpecifier: return parent.propertyName === identifier;
+		case SyntaxKind.BreakStatement:
+		case SyntaxKind.ContinueStatement:
+		case SyntaxKind.LabeledStatement: return parent.label === identifier;
+		case SyntaxKind.JsxAttribute:
+		case SyntaxKind.MethodDeclaration:
+		case SyntaxKind.MethodSignature:
+		case SyntaxKind.PropertyAccessExpression:
+		case SyntaxKind.PropertyAssignment:
+		case SyntaxKind.PropertyDeclaration:
+		case SyntaxKind.PropertySignature: return parent.name === identifier;
+	}
+	return false;
+}
+function isWriteReference(identifier) {
+	const { parent } = identifier;
+	if (isAssignmentTarget(identifier)) return true;
+	switch (parent.kind) {
+		case SyntaxKind.PostfixUnaryExpression:
+		case SyntaxKind.PrefixUnaryExpression: return parent.operand === identifier && (parent.operator === SyntaxKind.PlusPlusToken || parent.operator === SyntaxKind.MinusMinusToken);
+		default: return false;
+	}
+}
+function isAssignmentTarget(identifier) {
+	let current = identifier;
+	while (true) {
+		const parent = current.parent;
+		switch (parent.kind) {
+			case SyntaxKind.ArrayLiteralExpression:
+			case SyntaxKind.ObjectLiteralExpression:
+			case SyntaxKind.ShorthandPropertyAssignment:
+				current = parent;
+				continue;
+			case SyntaxKind.PropertyAssignment:
+				if (parent.name === current) return false;
+				current = parent;
+				continue;
+			case SyntaxKind.BinaryExpression: return parent.left === current && tsutils.isAssignmentKind(parent.operatorToken.kind);
+			case SyntaxKind.ForInStatement:
+			case SyntaxKind.ForOfStatement: return parent.initializer === current;
+		}
+		return false;
+	}
+}
+function isIdentifierDeclaration(identifier) {
+	const { parent } = identifier;
+	switch (parent.kind) {
+		case SyntaxKind.BindingElement:
+		case SyntaxKind.Parameter:
+		case SyntaxKind.VariableDeclaration: return isIdentifierWithinParent(identifier, parent.name);
+		case SyntaxKind.ClassDeclaration:
+		case SyntaxKind.ClassExpression:
+		case SyntaxKind.FunctionDeclaration:
+		case SyntaxKind.FunctionExpression:
+		case SyntaxKind.InterfaceDeclaration:
+		case SyntaxKind.ModuleDeclaration:
+		case SyntaxKind.TypeAliasDeclaration: return parent.name === identifier;
+		case SyntaxKind.ImportClause:
+		case SyntaxKind.ImportSpecifier:
+		case SyntaxKind.NamespaceImport: return parent.name === identifier;
+	}
+	return false;
+}
+function isIdentifierWithinParent(identifier, parent) {
+	let current = identifier;
+	while (current !== parent) {
+		const next = current.parent;
+		if (!next) return false;
+		current = next;
+	}
+	return true;
+}
+function isTypeReferenceIdentifier(identifier) {
+	let current = identifier;
+	while (current.parent.kind === SyntaxKind.QualifiedName) current = current.parent;
+	const parent = current.parent;
+	if (parent.kind !== SyntaxKind.TypeReference) return false;
+	return isIdentifierWithinParent(identifier, parent.typeName);
+}
+//#endregion
+export { isNonReferenceIdentifier, isWriteReference };

package/lib/scope/scopeManager.d.ts

@@ -0,0 +1,14 @@
+import { AnyNode, Identifier, SourceFile } from "../types/ast.js";
+import { FunctionWithParameters, Scope, ScopeDefinition, ScopeDefinitionKind, ScopeInternal, ScopeManager, ScopeReference, ScopeVariable } from "./types.js";
+
+//#region src/scope/scopeManager.d.ts
+declare function createScopeManager(sourceFile: SourceFile): {
+  findVariable(identifier: Identifier): ScopeVariable | undefined;
+  getDeclaredVariables(node: AnyNode): ScopeVariable[];
+  getReferencesInScope(node: AnyNode): ScopeReference[];
+  getScope(node: AnyNode): ScopeInternal;
+  globalScope: ScopeInternal;
+};
+declare function getScopeManager(sourceFile: SourceFile): ScopeManager;
+//#endregion
+export { createScopeManager, getScopeManager };

package/lib/scope/scopeManager.js

@@ -0,0 +1,153 @@
+import { forEachChild } from "../utils/forEachChild.js";
+import { isNonReferenceIdentifier, isWriteReference } from "./identifierReferences.js";
+import { createScope, getReferencesInScope, getVariableDeclarationScope, isScopeBoundary, resolveVariable } from "./scopes.js";
+import { SyntaxKind } from "typescript";
+//#region src/scope/scopeManager.ts
+const scopeManagers = /* @__PURE__ */ new WeakMap();
+function createScopeManager(sourceFile) {
+	const declarationVariablesByIdentifier = /* @__PURE__ */ new WeakMap();
+	const declaredVariablesByNode = /* @__PURE__ */ new WeakMap();
+	const nodeScopes = /* @__PURE__ */ new WeakMap();
+	const globalScope = createScope(sourceFile, void 0);
+	function addBindingName(scope, name, node, kind) {
+		if (name.kind === SyntaxKind.Identifier) return [addVariable(scope, name, node, kind)];
+		const variables = [];
+		for (const element of name.elements) if (element.kind !== SyntaxKind.OmittedExpression) variables.push(...addBindingName(scope, element.name, node, kind));
+		return variables;
+	}
+	function addImportVariables(scope, node) {
+		if (!node.importClause || node.importClause.isTypeOnly) return;
+		if (node.importClause.name) addVariable(scope, node.importClause.name, node, "import");
+		const { namedBindings } = node.importClause;
+		if (!namedBindings) return;
+		if (namedBindings.kind === SyntaxKind.NamespaceImport) {
+			addVariable(scope, namedBindings.name, node, "import");
+			return;
+		}
+		for (const element of namedBindings.elements) {
+			if (element.isTypeOnly) continue;
+			addVariable(scope, element.name, node, "import");
+		}
+	}
+	function addParameters(scope, node) {
+		for (const parameter of node.parameters) {
+			const variables = addBindingName(scope, parameter.name, node, "parameter");
+			declaredVariablesByNode.set(parameter, variables);
+		}
+	}
+	function addVariable(scope, identifier, node, kind) {
+		let variable = scope.variablesByName.get(identifier.text);
+		if (!variable) {
+			variable = {
+				declarations: [],
+				definitions: [],
+				name: identifier.text,
+				references: [],
+				scope
+			};
+			scope.variablesByName.set(identifier.text, variable);
+			scope.variables.push(variable);
+		}
+		variable.declarations.push(identifier);
+		variable.definitions.push({
+			identifier,
+			kind,
+			node
+		});
+		declarationVariablesByIdentifier.set(identifier, variable);
+		const declaredVariables = declaredVariablesByNode.get(node) ?? [];
+		declaredVariables.push(variable);
+		declaredVariablesByNode.set(node, declaredVariables);
+		return variable;
+	}
+	function collectDeclarations(node, scope) {
+		const nodeScope = node !== sourceFile && isScopeBoundary(node) ? createScope(node, scope) : scope;
+		nodeScopes.set(node, nodeScope);
+		switch (node.kind) {
+			case SyntaxKind.ArrowFunction:
+			case SyntaxKind.Constructor:
+			case SyntaxKind.GetAccessor:
+			case SyntaxKind.MethodDeclaration:
+			case SyntaxKind.SetAccessor:
+				addParameters(nodeScope, node);
+				break;
+			case SyntaxKind.CatchClause:
+				if (node.variableDeclaration) addBindingName(nodeScope, node.variableDeclaration.name, node, "catch");
+				break;
+			case SyntaxKind.ClassDeclaration:
+				if (node.name) addVariable(nodeScope, node.name, node, "class");
+				break;
+			case SyntaxKind.ClassExpression:
+				if (node.name) addVariable(nodeScope, node.name, node, "class");
+				break;
+			case SyntaxKind.FunctionDeclaration:
+				if (node.name) addVariable(scope, node.name, node, "function");
+				addParameters(nodeScope, node);
+				break;
+			case SyntaxKind.FunctionExpression:
+				if (node.name) addVariable(nodeScope, node.name, node, "function");
+				addParameters(nodeScope, node);
+				break;
+			case SyntaxKind.ImportDeclaration:
+				addImportVariables(nodeScope, node);
+				break;
+			case SyntaxKind.VariableDeclaration:
+				if (node.parent.kind === SyntaxKind.CatchClause) {
+					forEachChild(node, (child) => {
+						collectDeclarations(child, nodeScope);
+					});
+					return;
+				}
+				addBindingName(getVariableDeclarationScope(node, nodeScope), node.name, node, "variable");
+				break;
+		}
+		forEachChild(node, (child) => {
+			collectDeclarations(child, nodeScope);
+		});
+	}
+	function collectReferences(node) {
+		if (node.kind === SyntaxKind.Identifier && !isNonReferenceIdentifier(node)) {
+			const scope = nodeScopes.get(node) ?? globalScope;
+			const variable = resolveVariable(scope, node.text);
+			const reference = {
+				from: scope,
+				identifier: node,
+				isWrite: isWriteReference(node),
+				text: node.text,
+				variable
+			};
+			scope.references.push(reference);
+			variable?.references.push(reference);
+		}
+		forEachChild(node, collectReferences);
+	}
+	collectDeclarations(sourceFile, globalScope);
+	collectReferences(sourceFile);
+	return {
+		findVariable(identifier) {
+			const declarationVariable = declarationVariablesByIdentifier.get(identifier);
+			if (declarationVariable) return declarationVariable;
+			return resolveVariable(nodeScopes.get(identifier) ?? globalScope, identifier.text);
+		},
+		getDeclaredVariables(node) {
+			return declaredVariablesByNode.get(node) ?? [];
+		},
+		getReferencesInScope(node) {
+			return getReferencesInScope(nodeScopes.get(node) ?? globalScope);
+		},
+		getScope(node) {
+			return nodeScopes.get(node) ?? globalScope;
+		},
+		globalScope
+	};
+}
+function getScopeManager(sourceFile) {
+	let scopeManager = scopeManagers.get(sourceFile);
+	if (!scopeManager) {
+		scopeManager = createScopeManager(sourceFile);
+		scopeManagers.set(sourceFile, scopeManager);
+	}
+	return scopeManager;
+}
+//#endregion
+export { createScopeManager, getScopeManager };

package/lib/scope/scopes.d.ts

@@ -0,0 +1,7 @@
+import type * as AST from "../types/ast.ts";
+import type { ScopeInternal, ScopeVariable } from "./types.ts";
+export declare function createScope(block: AST.AnyNode, upper: ScopeInternal | undefined): ScopeInternal;
+export declare function getReferencesInScope(scope: ScopeInternal): import("./types.ts").ScopeReference[];
+export declare function getVariableDeclarationScope(node: AST.VariableDeclaration, scope: ScopeInternal): ScopeInternal;
+export declare function isScopeBoundary(node: AST.AnyNode): boolean;
+export declare function resolveVariable(scope: ScopeInternal, name: string): ScopeVariable | undefined;

package/lib/scope/scopes.js

@@ -0,0 +1,64 @@
+import ts, { SyntaxKind } from "typescript";
+//#region src/scope/scopes.ts
+function createScope(block, upper) {
+	const variablesByName = /* @__PURE__ */ new Map();
+	const scope = {
+		block,
+		childScopes: [],
+		references: [],
+		upper,
+		variables: [],
+		variablesByName
+	};
+	Object.defineProperty(scope, "variablesByName", {
+		enumerable: false,
+		value: variablesByName
+	});
+	upper?.childScopes.push(scope);
+	return scope;
+}
+function getReferencesInScope(scope) {
+	const references = [...scope.references];
+	for (const childScope of scope.childScopes) if (!isFunctionLike(childScope.block)) references.push(...getReferencesInScope(childScope));
+	return references;
+}
+function getVariableDeclarationScope(node, scope) {
+	if (node.parent.kind === SyntaxKind.VariableDeclarationList && !(node.parent.flags & ts.NodeFlags.BlockScoped)) return findContainingVariableScope(scope);
+	return scope;
+}
+function isScopeBoundary(node) {
+	return isFunctionLike(node) || node.kind === SyntaxKind.CatchClause || node.kind === SyntaxKind.ClassExpression || node.kind === SyntaxKind.ForInStatement || node.kind === SyntaxKind.ForOfStatement || node.kind === SyntaxKind.ForStatement || isBlockScopeBoundary(node);
+}
+function resolveVariable(scope, name) {
+	let current = scope;
+	while (current) {
+		const variable = current.variablesByName.get(name);
+		if (variable) return variable;
+		current = current.upper;
+	}
+}
+function findContainingVariableScope(scope) {
+	let current = scope;
+	while (current.upper && !isVariableScopeBoundary(current.block)) current = current.upper;
+	return current;
+}
+function isBlockScopeBoundary(node) {
+	return node.kind === SyntaxKind.Block && node.parent.kind !== SyntaxKind.CatchClause && !isFunctionLike(node.parent);
+}
+function isFunctionLike(node) {
+	switch (node?.kind) {
+		case SyntaxKind.ArrowFunction:
+		case SyntaxKind.Constructor:
+		case SyntaxKind.FunctionDeclaration:
+		case SyntaxKind.FunctionExpression:
+		case SyntaxKind.GetAccessor:
+		case SyntaxKind.MethodDeclaration:
+		case SyntaxKind.SetAccessor: return true;
+		default: return false;
+	}
+}
+function isVariableScopeBoundary(node) {
+	return node.kind === SyntaxKind.SourceFile || isFunctionLike(node);
+}
+//#endregion
+export { createScope, getReferencesInScope, getVariableDeclarationScope, isScopeBoundary, resolveVariable };

package/lib/scope/types.d.ts

@@ -0,0 +1,45 @@
+import { AnyNode, ArrowFunction, ConstructorDeclaration, FunctionDeclaration, FunctionExpression, GetAccessorDeclaration, Identifier, MethodDeclaration, SetAccessorDeclaration } from "../types/ast.js";
+
+//#region src/scope/types.d.ts
+type FunctionWithParameters = ArrowFunction | ConstructorDeclaration | FunctionDeclaration | FunctionExpression | GetAccessorDeclaration | MethodDeclaration | SetAccessorDeclaration;
+interface Scope {
+  block: AnyNode;
+  childScopes: Scope[];
+  references: ScopeReference[];
+  upper: Scope | undefined;
+  variables: ScopeVariable[];
+}
+interface ScopeDefinition {
+  identifier: Identifier;
+  kind: ScopeDefinitionKind;
+  node: AnyNode;
+}
+type ScopeDefinitionKind = "catch" | "class" | "function" | "import" | "parameter" | "variable";
+interface ScopeInternal extends Scope {
+  childScopes: ScopeInternal[];
+  upper: ScopeInternal | undefined;
+  variablesByName: Map<string, ScopeVariable>;
+}
+interface ScopeManager {
+  findVariable(identifier: Identifier): ScopeVariable | undefined;
+  getDeclaredVariables(node: AnyNode): ScopeVariable[];
+  getReferencesInScope(node: AnyNode): ScopeReference[];
+  getScope(node: AnyNode): Scope;
+  globalScope: Scope;
+}
+interface ScopeReference {
+  from: Scope;
+  identifier: Identifier;
+  isWrite: boolean;
+  text: string;
+  variable: ScopeVariable | undefined;
+}
+interface ScopeVariable {
+  declarations: Identifier[];
+  definitions: ScopeDefinition[];
+  name: string;
+  references: ScopeReference[];
+  scope: Scope;
+}
+//#endregion
+export { FunctionWithParameters, Scope, ScopeDefinition, ScopeDefinitionKind, ScopeInternal, ScopeManager, ScopeReference, ScopeVariable };

package/lib/types/ast.d.ts

@@ -1662,6 +1662,7 @@ interface SourceFile extends ts.Node {
   libReferenceDirectives: readonly ts.FileReference[];
   moduleName?: string;
   readonly parent: NullNode;
+  path: ts.Path;
   referencedFiles: readonly ts.FileReference[];
   readonly statements: ts.NodeArray<Statement>;
   text: string;
@@ -2066,5 +2067,4 @@ 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, 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
+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 };

package/lib/types/checker.d.ts

@@ -19,5 +19,4 @@ interface CheckerOverrides {
   getContextualTypeForArgumentAtIndex(node: Node, argIndex: number): Type;
 }
 //#endregion
-export { Checker };
-//# sourceMappingURL=checker.d.ts.map
+export { Checker };

package/lib/utils/containsGlobalDeclarations.d.ts

@@ -0,0 +1,6 @@
+import ts from "typescript";
+/**
+ * Inspects top-level statements of a TS source file to determine
+ * if it introduces or modifies entities in the global scope.
+ */
+export declare function containsGlobalDeclarations(sourceFileNode: ts.SourceFile): boolean;

package/lib/utils/containsGlobalDeclarations.js

@@ -0,0 +1,17 @@
+import ts from "typescript";
+//#region src/utils/containsGlobalDeclarations.ts
+/**
+* Inspects top-level statements of a TS source file to determine
+* if it introduces or modifies entities in the global scope.
+*/
+function containsGlobalDeclarations(sourceFileNode) {
+	const isModule = ts.isExternalModule(sourceFileNode);
+	return sourceFileNode.statements.some((statement) => {
+		if (ts.isModuleDeclaration(statement) && statement.name.text === "global") return true;
+		if (isModule) return false;
+		if (!ts.canHaveModifiers(statement)) return false;
+		return ts.getModifiers(statement)?.some((mod) => mod.kind === ts.SyntaxKind.DeclareKeyword);
+	});
+}
+//#endregion
+export { containsGlobalDeclarations };

package/lib/utils/createRuleTesterTSConfig.d.ts

@@ -4,5 +4,4 @@ declare function createRuleTesterTSConfig(defaultCompilerOptions?: Record<string
   "tsconfig.json": string;
 };
 //#endregion
-export { createRuleTesterTSConfig };
-//# sourceMappingURL=createRuleTesterTSConfig.d.ts.map
+export { createRuleTesterTSConfig };

package/lib/utils/createRuleTesterTSConfig.js

@@ -14,5 +14,3 @@ function createRuleTesterTSConfig(defaultCompilerOptions) {
 }
 //#endregion
 export { createRuleTesterTSConfig };
-
-//# sourceMappingURL=createRuleTesterTSConfig.js.map

package/lib/utils/declarationIncludesGlobal.d.ts

@@ -3,5 +3,4 @@ import ts from "typescript";
 //#region src/utils/declarationIncludesGlobal.d.ts
 declare function declarationIncludesGlobal(declaration: ts.Declaration): boolean;
 //#endregion
-export { declarationIncludesGlobal };
-//# sourceMappingURL=declarationIncludesGlobal.d.ts.map
+export { declarationIncludesGlobal };

package/lib/utils/declarationIncludesGlobal.js

@@ -5,5 +5,3 @@ function declarationIncludesGlobal(declaration) {
 }
 //#endregion
 export { declarationIncludesGlobal };
-
-//# sourceMappingURL=declarationIncludesGlobal.js.map

package/lib/utils/declarationsIncludeGlobal.d.ts

@@ -1,3 +1,2 @@
 import type ts from "typescript";
 export declare function declarationsIncludeGlobal(declarations: ts.Declaration[]): boolean;
-//# sourceMappingURL=declarationsIncludeGlobal.d.ts.map

package/lib/utils/declarationsIncludeGlobal.js

@@ -5,5 +5,3 @@ function declarationsIncludeGlobal(declarations) {
 }
 //#endregion
 export { declarationsIncludeGlobal };
-
-//# sourceMappingURL=declarationsIncludeGlobal.js.map

package/lib/utils/forEachChild.d.ts

@@ -0,0 +1,7 @@
+import { AnyNode } from "../types/ast.js";
+import ts from "typescript";
+
+//#region src/utils/forEachChild.d.ts
+declare const forEachChild: <T>(node: AnyNode, cbNode: (node: AnyNode) => T | undefined, cbNodes?: (nodes: ts.NodeArray<AnyNode>) => T | undefined) => T | undefined;
+//#endregion
+export { forEachChild };

package/lib/utils/forEachChild.js

@@ -0,0 +1,5 @@
+import ts from "typescript";
+//#region src/utils/forEachChild.ts
+const forEachChild = ts.forEachChild;
+//#endregion
+export { forEachChild };

package/lib/utils/getDeclarationsIfGlobal.d.ts

@@ -1,9 +1,6 @@
 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): typescript.Declaration[] | undefined;
+declare function getDeclarationsIfGlobal(node: Expression, typeChecker: Checker): import("typescript").Declaration[] | undefined;
 //#endregion
-export { getDeclarationsIfGlobal };
-//# sourceMappingURL=getDeclarationsIfGlobal.d.ts.map
+export { getDeclarationsIfGlobal };

package/lib/utils/getDeclarationsIfGlobal.js

@@ -6,5 +6,3 @@ function getDeclarationsIfGlobal(node, typeChecker) {
 }
 //#endregion
 export { getDeclarationsIfGlobal };
-
-//# sourceMappingURL=getDeclarationsIfGlobal.js.map

package/lib/utils/getModifyingReferences.d.ts

@@ -1,15 +1,10 @@
 import { Identifier, SourceFile } from "../types/ast.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).
- *
- * TODO: Replace with a proper scope manager when available (see #400).
  * @returns An array of identifier nodes that modify the variable.
  */
-declare function getModifyingReferences(identifier: Identifier, sourceFile: SourceFile, typeChecker: Checker): ts.Identifier[];
+declare function getModifyingReferences(identifier: Identifier, sourceFile: SourceFile): Identifier[];
 //#endregion
-export { getModifyingReferences };
-//# sourceMappingURL=getModifyingReferences.d.ts.map
+export { getModifyingReferences };

package/lib/utils/getModifyingReferences.js

@@ -1,35 +1,13 @@
-import ts from "typescript";
-import * as tsutils from "ts-api-utils";
+import { getScopeManager } from "../scope/scopeManager.js";
 //#region src/utils/getModifyingReferences.ts
 /**
 * Gets all references to a variable that modify it (assignments, increments, decrements).
-*
-* TODO: Replace with a proper scope manager when available (see #400).
 * @returns An array of identifier nodes that modify the variable.
 */
-function getModifyingReferences(identifier, sourceFile, typeChecker) {
-	const symbol = typeChecker.getSymbolAtLocation(identifier);
-	if (!symbol?.valueDeclaration) return [];
-	const { valueDeclaration } = symbol;
-	const modifyingReferences = [];
-	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;
+function getModifyingReferences(identifier, sourceFile) {
+	const variable = getScopeManager(sourceFile).findVariable(identifier);
+	if (!variable || variable.declarations.length > 1) return [];
+	return variable.references.filter((reference) => reference.isWrite).map((reference) => reference.identifier);
 }
 //#endregion
 export { getModifyingReferences };
-
-//# sourceMappingURL=getModifyingReferences.js.map

package/lib/utils/hasSameTokens.d.ts

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

package/lib/utils/hasSameTokens.js

@@ -28,5 +28,3 @@ function areSameToken(nodeA, nodeB, sourceFile) {
 }
 //#endregion
 export { hasSameTokens };
-
-//# sourceMappingURL=hasSameTokens.js.map

package/lib/utils/isBuiltinArrayMethod.d.ts

@@ -10,5 +10,4 @@ type BuiltInArrayMethodNode = CallExpression & {
 };
 declare function isBuiltinArrayMethod(name: string, node: CallExpression, typeChecker: Checker): node is BuiltInArrayMethodNode;
 //#endregion
-export { isBuiltinArrayMethod };
-//# sourceMappingURL=isBuiltinArrayMethod.d.ts.map
+export { BuiltInArrayMethodNode, isBuiltinArrayMethod };

package/lib/utils/isBuiltinArrayMethod.js

@@ -5,5 +5,3 @@ function isBuiltinArrayMethod(name, node, typeChecker) {
 }
 //#endregion
 export { isBuiltinArrayMethod };
-
-//# sourceMappingURL=isBuiltinArrayMethod.js.map

package/lib/utils/isFunction.d.ts

@@ -3,5 +3,4 @@ import { Checker } from "../types/checker.js";
 //#region src/utils/isFunction.d.ts
 declare function isFunction(node: Expression, typeChecker: Checker): boolean;
 //#endregion
-export { isFunction };
-//# sourceMappingURL=isFunction.d.ts.map
+export { isFunction };