@flint.fyi/typescript-language 0.18.4 → 0.19.0

package/lib/nodes.d.ts

@@ -1,203 +0,0 @@
-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 {
-  AnyKeyword: AnyKeyword;
-  ArrayBindingPattern: ArrayBindingPattern;
-  ArrayLiteralExpression: ArrayLiteralExpression;
-  ArrayType: ArrayTypeNode;
-  ArrowFunction: ArrowFunction;
-  AsExpression: AsExpression;
-  AwaitExpression: AwaitExpression;
-  BigIntKeyword: BigIntKeyword;
-  BigIntLiteral: BigIntLiteral;
-  BinaryExpression: BinaryExpression;
-  BindingElement: BindingElement;
-  Block: Block;
-  BooleanKeyword: BooleanKeyword;
-  BreakStatement: BreakStatement;
-  CallExpression: CallExpression;
-  CallSignature: CallSignatureDeclaration;
-  CaseBlock: CaseBlock;
-  CaseClause: CaseClause;
-  CatchClause: CatchClause;
-  ClassDeclaration: ClassDeclaration;
-  ClassExpression: ClassExpression;
-  ClassStaticBlockDeclaration: ClassStaticBlockDeclaration;
-  CommaListExpression: CommaListExpression;
-  ComputedPropertyName: ComputedPropertyName;
-  ConditionalExpression: ConditionalExpression;
-  ConditionalType: ConditionalTypeNode;
-  Constructor: ConstructorDeclaration;
-  ConstructorType: ConstructorTypeNode;
-  ConstructSignature: ConstructSignatureDeclaration;
-  ContinueStatement: ContinueStatement;
-  DebuggerStatement: DebuggerStatement;
-  Decorator: Decorator;
-  DefaultClause: DefaultClause;
-  DeleteExpression: DeleteExpression;
-  DoStatement: DoStatement;
-  ElementAccessExpression: ElementAccessExpression;
-  EmptyStatement: EmptyStatement;
-  EnumDeclaration: EnumDeclaration;
-  EnumMember: EnumMember;
-  ExportAssignment: ExportAssignment;
-  ExportDeclaration: ExportDeclaration;
-  ExportSpecifier: ExportSpecifier;
-  ExpressionStatement: ExpressionStatement;
-  ExpressionWithTypeArguments: ExpressionWithTypeArguments;
-  ExternalModuleReference: ExternalModuleReference;
-  FalseKeyword: FalseLiteral;
-  ForInStatement: ForInStatement;
-  ForOfStatement: ForOfStatement;
-  ForStatement: ForStatement;
-  FunctionDeclaration: FunctionDeclaration;
-  FunctionExpression: FunctionExpression;
-  FunctionType: FunctionTypeNode;
-  GetAccessor: GetAccessorDeclaration;
-  HeritageClause: HeritageClause;
-  Identifier: Identifier;
-  IfStatement: IfStatement;
-  ImportAttribute: ImportAttribute;
-  ImportAttributes: ImportAttributes;
-  ImportClause: ImportClause;
-  ImportDeclaration: ImportDeclaration;
-  ImportEqualsDeclaration: ImportEqualsDeclaration;
-  ImportKeyword: ImportExpression;
-  ImportSpecifier: ImportSpecifier;
-  ImportType: ImportTypeNode;
-  IndexedAccessType: IndexedAccessTypeNode;
-  IndexSignature: IndexSignatureDeclaration;
-  InferType: InferTypeNode;
-  InterfaceDeclaration: InterfaceDeclaration;
-  IntersectionType: IntersectionTypeNode;
-  IntrinsicKeyword: IntrinsicKeyword;
-  JSDocAllType: JSDocAllType;
-  JSDocFunctionType: JSDocFunctionType;
-  JSDocLink: JSDocLink;
-  JSDocLinkCode: JSDocLinkCode;
-  JSDocLinkPlain: JSDocLinkPlain;
-  JSDocMemberName: JSDocMemberName;
-  JSDocNamepathType: JSDocNamepathType;
-  JSDocNonNullableType: JSDocNonNullableType;
-  JSDocNullableType: JSDocNullableType;
-  JSDocOptionalType: JSDocOptionalType;
-  JSDocParameterTag: JSDocParameterTag;
-  JSDocPropertyTag: JSDocPropertyTag;
-  JSDocReturnTag: JSDocReturnTag;
-  JSDocSignature: JSDocSignature;
-  JSDocTemplateTag: JSDocTemplateTag;
-  JSDocText: JSDocText;
-  JSDocTypeExpression: JSDocTypeExpression;
-  JSDocTypeLiteral: JSDocTypeLiteral;
-  JSDocUnknownType: JSDocUnknownType;
-  JSDocVariadicType: JSDocVariadicType;
-  JsxAttribute: JsxAttribute;
-  JsxAttributes: JsxAttributes;
-  JsxClosingElement: JsxClosingElement;
-  JsxClosingFragment: JsxClosingFragment;
-  JsxElement: JsxElement;
-  JsxExpression: JsxExpression;
-  JsxFragment: JsxFragment;
-  JsxNamespacedName: JsxNamespacedName;
-  JsxOpeningElement: JsxOpeningElement;
-  JsxOpeningFragment: JsxOpeningFragment;
-  JsxSelfClosingElement: JsxSelfClosingElement;
-  JsxSpreadAttribute: JsxSpreadAttribute;
-  JsxText: JsxText;
-  LabeledStatement: LabeledStatement;
-  LiteralType: LiteralTypeNode;
-  MappedType: MappedTypeNode;
-  MetaProperty: MetaProperty;
-  MethodDeclaration: MethodDeclaration;
-  MethodSignature: MethodSignature;
-  MissingDeclaration: MissingDeclaration;
-  ModuleBlock: ModuleBlock;
-  ModuleDeclaration: ModuleDeclaration;
-  NamedExports: NamedExports;
-  NamedImports: NamedImports;
-  NamedTupleMember: NamedTupleMember;
-  NamespaceExport: NamespaceExport;
-  NamespaceExportDeclaration: NamespaceExportDeclaration;
-  NamespaceImport: NamespaceImport;
-  NeverKeyword: NeverKeyword;
-  NewExpression: NewExpression;
-  NonNullExpression: NonNullExpression;
-  NoSubstitutionTemplateLiteral: NoSubstitutionTemplateLiteral;
-  NotEmittedStatement: NotEmittedStatement;
-  NotEmittedTypeElement: NotEmittedTypeElement;
-  NullKeyword: NullLiteral;
-  NumberKeyword: NumberKeyword;
-  NumericLiteral: NumericLiteral;
-  ObjectBindingPattern: ObjectBindingPattern;
-  ObjectKeyword: ObjectKeyword;
-  ObjectLiteralExpression: ObjectLiteralExpression;
-  OmittedExpression: OmittedExpression;
-  OptionalType: OptionalTypeNode;
-  Parameter: ParameterDeclaration;
-  ParenthesizedExpression: ParenthesizedExpression;
-  ParenthesizedType: ParenthesizedTypeNode;
-  PartiallyEmittedExpression: PartiallyEmittedExpression;
-  PostfixUnaryExpression: PostfixUnaryExpression;
-  PrefixUnaryExpression: PrefixUnaryExpression;
-  PrivateIdentifier: PrivateIdentifier;
-  PropertyAccessExpression: PropertyAccessExpression;
-  PropertyAssignment: PropertyAssignment;
-  PropertyDeclaration: PropertyDeclaration;
-  PropertySignature: PropertySignature;
-  QualifiedName: QualifiedName;
-  RegularExpressionLiteral: RegularExpressionLiteral;
-  RestType: RestTypeNode;
-  ReturnStatement: ReturnStatement;
-  SatisfiesExpression: SatisfiesExpression;
-  SemicolonClassElement: SemicolonClassElement;
-  SetAccessor: SetAccessorDeclaration;
-  ShorthandPropertyAssignment: ShorthandPropertyAssignment;
-  SourceFile: SourceFile;
-  SpreadAssignment: SpreadAssignment;
-  SpreadElement: SpreadElement;
-  StringKeyword: StringKeyword;
-  StringLiteral: StringLiteral;
-  SuperKeyword: SuperExpression;
-  SwitchStatement: SwitchStatement;
-  SymbolKeyword: SymbolKeyword;
-  SyntheticExpression: SyntheticExpression;
-  TaggedTemplateExpression: TaggedTemplateExpression;
-  TemplateExpression: TemplateExpression;
-  TemplateHead: TemplateHead;
-  TemplateLiteralType: TemplateLiteralTypeNode;
-  TemplateLiteralTypeSpan: TemplateLiteralTypeSpan;
-  TemplateMiddle: TemplateMiddle;
-  TemplateSpan: TemplateSpan;
-  TemplateTail: TemplateTail;
-  ThisKeyword: ThisExpression;
-  ThisType: ThisTypeNode;
-  ThrowStatement: ThrowStatement;
-  TrueKeyword: TrueLiteral;
-  TryStatement: TryStatement;
-  TupleType: TupleTypeNode;
-  TypeAliasDeclaration: TypeAliasDeclaration;
-  TypeAssertionExpression: TypeAssertion;
-  TypeLiteral: TypeLiteralNode;
-  TypeOfExpression: TypeOfExpression;
-  TypeOperator: TypeOperatorNode;
-  TypeParameter: TypeParameterDeclaration;
-  TypePredicate: TypePredicateNode;
-  TypeQuery: TypeQueryNode;
-  TypeReference: TypeReferenceNode;
-  UndefinedKeyword: UndefinedKeyword;
-  UnionType: UnionTypeNode;
-  UnknownKeyword: UnknownKeyword;
-  VariableDeclaration: VariableDeclaration;
-  VariableDeclarationList: VariableDeclarationList;
-  VariableStatement: VariableStatement;
-  VoidExpression: VoidExpression;
-  VoidKeyword: VoidKeyword;
-  WhileStatement: WhileStatement;
-  WithStatement: WithStatement;
-  YieldExpression: YieldExpression;
-}
-type TypeScriptNodeVisitors = WithExitKeys<TypeScriptNodesByName>;
-//#endregion
-export { TypeScriptNodeVisitors, TypeScriptNodesByName };

package/lib/normalizeRange.d.ts

@@ -1,3 +0,0 @@
-import { type CharacterReportRange, type NormalizedReportRangeObject } from "@flint.fyi/core";
-import type * as AST from "./types/ast.ts";
-export declare function normalizeRange(original: CharacterReportRange, sourceFile: AST.SourceFile): NormalizedReportRangeObject;

package/lib/normalizeRange.js

@@ -1,17 +0,0 @@
-import { getColumnAndLineOfPosition } from "@flint.fyi/core";
-//#region src/normalizeRange.ts
-function normalizeRange(original, sourceFile) {
-	const onCharacters = isNode(original) ? {
-		begin: original.getStart(sourceFile),
-		end: original.getEnd()
-	} : original;
-	return {
-		begin: getColumnAndLineOfPosition(sourceFile, onCharacters.begin),
-		end: getColumnAndLineOfPosition(sourceFile, onCharacters.end)
-	};
-}
-function isNode(value) {
-	return typeof value === "object" && value !== null && "kind" in value;
-}
-//#endregion
-export { normalizeRange };

package/lib/orderTypeScriptFilePaths.d.ts

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

package/lib/orderTypeScriptFilePaths.js

@@ -1,90 +0,0 @@
-import { createTypeScriptServerHost } from "./createTypeScriptServerHost.js";
-import ts from "typescript";
-import { normalizePath, pathKey } from "@flint.fyi/utils";
-import { dirname, resolve } from "pathe";
-//#region src/orderTypeScriptFilePaths.ts
-const tsConfigFileName = "tsconfig.json";
-function orderTypeScriptFilePaths(filePaths, host) {
-	if (filePaths.length < 2) return [...filePaths];
-	const caseSensitiveFS = host.isCaseSensitiveFS();
-	const cwd = host.getCurrentDirectory();
-	const parseHost = {
-		...createTypeScriptServerHost(host),
-		onUnRecoverableConfigFileDiagnostic() {}
-	};
-	const configByDirectory = /* @__PURE__ */ new Map();
-	const parsedConfigByPath = /* @__PURE__ */ new Map();
-	const configByFile = /* @__PURE__ */ new Map();
-	function comparePaths(a, b) {
-		return pathKey(a, caseSensitiveFS).localeCompare(pathKey(b, caseSensitiveFS));
-	}
-	function findConfigFile(directoryPath) {
-		const directoryPathNormalized = normalizePath(directoryPath);
-		const directoryKey = pathKey(directoryPathNormalized, caseSensitiveFS);
-		if (configByDirectory.has(directoryKey)) return configByDirectory.get(directoryKey);
-		const configPath = ts.findConfigFile(directoryPathNormalized, (path) => parseHost.fileExists(path), tsConfigFileName);
-		const normalizedConfigPath = configPath == null ? void 0 : resolve(cwd, configPath);
-		configByDirectory.set(directoryKey, normalizedConfigPath);
-		return normalizedConfigPath;
-	}
-	function getParsedConfig(configPath) {
-		const configKey = pathKey(configPath, caseSensitiveFS);
-		if (parsedConfigByPath.has(configKey)) return parsedConfigByPath.get(configKey);
-		const parsed = ts.getParsedCommandLineOfConfigFile(configPath, {}, parseHost);
-		const parsedConfig = parsed == null ? void 0 : {
-			fileNames: parsed.fileNames.map((fileName) => resolve(cwd, fileName)),
-			references: (parsed.projectReferences ?? []).map((reference) => resolve(cwd, ts.resolveProjectReferencePath(reference))).sort(comparePaths)
-		};
-		parsedConfigByPath.set(configKey, parsedConfig);
-		return parsedConfig;
-	}
-	function collectConfigsTopologically(configPath) {
-		const orderedConfigs = [];
-		const seen = /* @__PURE__ */ new Set();
-		const visiting = /* @__PURE__ */ new Set();
-		function visit(currentConfigPath) {
-			const configKey = pathKey(currentConfigPath, caseSensitiveFS);
-			if (seen.has(configKey) || visiting.has(configKey)) return;
-			visiting.add(configKey);
-			for (const reference of getParsedConfig(currentConfigPath)?.references ?? []) visit(reference);
-			visiting.delete(configKey);
-			seen.add(configKey);
-			orderedConfigs.push(currentConfigPath);
-		}
-		visit(configPath);
-		return orderedConfigs;
-	}
-	const fileInfos = filePaths.map((original) => {
-		const absolute = resolve(cwd, original);
-		const rootConfig = findConfigFile(dirname(absolute));
-		return {
-			absolute,
-			original,
-			rootConfig,
-			rootConfigKey: rootConfig == null ? void 0 : pathKey(rootConfig, caseSensitiveFS)
-		};
-	});
-	const rootConfigs = Array.from(new Set(fileInfos.map(({ rootConfig }) => rootConfig).filter((rootConfig) => rootConfig != null))).sort(comparePaths);
-	const fileInfoByPath = new Map(fileInfos.map((fileInfo) => [pathKey(fileInfo.absolute, caseSensitiveFS), fileInfo]));
-	const configRanks = /* @__PURE__ */ new Map();
-	for (const rootConfig of rootConfigs) {
-		const rootConfigKey = pathKey(rootConfig, caseSensitiveFS);
-		for (const config of collectConfigsTopologically(rootConfig)) {
-			const configKey = pathKey(config, caseSensitiveFS);
-			if (!configRanks.has(configKey)) configRanks.set(configKey, configRanks.size);
-			for (const fileName of getParsedConfig(config)?.fileNames ?? []) {
-				const fileInfo = fileInfoByPath.get(pathKey(fileName, caseSensitiveFS));
-				if (fileInfo?.rootConfigKey !== rootConfigKey) continue;
-				const fileKey = pathKey(fileInfo.absolute, caseSensitiveFS);
-				if (!configByFile.has(fileKey)) configByFile.set(fileKey, config);
-			}
-		}
-	}
-	return fileInfos.toSorted((a, b) => {
-		const configA = configByFile.get(pathKey(a.absolute, caseSensitiveFS)) ?? a.rootConfig;
-		const configB = configByFile.get(pathKey(b.absolute, caseSensitiveFS)) ?? b.rootConfig;
-		return (configA == null ? Number.MAX_SAFE_INTEGER : configRanks.get(pathKey(configA, caseSensitiveFS)) ?? Number.MAX_SAFE_INTEGER) - (configB == null ? Number.MAX_SAFE_INTEGER : configRanks.get(pathKey(configB, caseSensitiveFS)) ?? Number.MAX_SAFE_INTEGER) || comparePaths(a.absolute, b.absolute);
-	}).map(({ original }) => original);
-}
-//#endregion
-export { orderTypeScriptFilePaths };

package/lib/package.js

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

package/lib/scope/identifierReferences.d.ts

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

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

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

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

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

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