@flint.fyi/typescript-language 0.20.1 → 0.21.0

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import * as ts$1 from "typescript";
 import ts, { CallLikeExpression, Declaration, Node, Program, Signature, SyntaxKind, TupleTypeReference, Type, TypeChecker, TypeReference } from "typescript";
-import { AnyOptionalSchema, CharacterReportRange, FileAboutData, InferredOutputObject, Language, LanguageFile, LanguageFileDefinition, LanguageReport, LanguageReports, NormalizedReportRangeObject, RuleRuntime, SourceFileWithLineMapAndFileName, WithExitKeys } from "@flint.fyi/core";
+import { CharacterReportRange, FileAboutData, FileVisitorSubscription, FileVisitors, Language, LanguageFileDefinition, LanguageReport, LanguageReports, NormalizedReportRangeObject, SourceFileWithLineMapAndFileName, WithExitKeys } from "@flint.fyi/core";
 //#endregion
 //#region src/convertTypeScriptDiagnosticToLanguageReport.d.ts
 interface TSDiagnostic extends TSDiagnosticRelatedInformation {
@@ -13,7 +13,7 @@ interface TSDiagnosticRelatedInformation {
   messageText: string | ts.DiagnosticMessageChain;
   start: number | undefined;
 }
-declare function convertTypeScriptDiagnosticToLanguageReport(diagnostic: TSDiagnostic): LanguageReport;
+export declare function convertTypeScriptDiagnosticToLanguageReport(diagnostic: TSDiagnostic): LanguageReport;
 declare namespace ast_d_exports {
   export { AbstractKeyword, AccessorDeclaration, AccessorKeyword, AdditiveOperator, AdditiveOperatorOrHigher, AnyKeyword, AnyNode, ArrayBindingElement, ArrayBindingPattern, ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AssertsKeyword, AssignmentOperator, AssignmentOperatorOrHigher, AsteriskToken, AsyncKeyword, AwaitExpression, AwaitKeyword, BigIntKeyword, BigIntLiteral, BinaryExpression, BinaryOperator, BinaryOperatorToken, BindingElement, BindingName, BindingPattern, BitwiseOperator, BitwiseOperatorOrHigher, Block, BooleanKeyword, BooleanLiteral, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseClause, CaseOrDefaultClause, CatchClause, ClassDeclaration, ClassElement, ClassExpression, ClassStaticBlockDeclaration, ColonToken, CommaListExpression, CompoundAssignmentOperator, ComputedPropertyName, ConciseBody, ConditionalExpression, ConditionalTypeNode, ConstKeyword, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, DebuggerStatement, DeclarationStatement, DeclareKeyword, Decorator, DefaultClause, DefaultKeyword, DeleteExpression, DoStatement, DotDotDotToken, ElementAccessExpression, EmptyStatement, EntityName, EnumDeclaration, EnumMember, EqualityOperator, EqualityOperatorOrHigher, EqualsGreaterThanToken, EqualsToken, ExclamationToken, ExponentiationOperator, ExportAssignment, ExportDeclaration, ExportKeyword, ExportSpecifier, Expression, ExpressionParent, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleReference, FalseLiteral, ForInStatement, ForInitializer, ForOfStatement, ForStatement, FunctionBody, FunctionDeclaration, FunctionExpression, FunctionOrConstructorTypeNodeBase, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, IfStatement, ImportAttribute, ImportAttributeName, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportExpression, ImportPhaseModifierSyntaxKind, ImportSpecifier, ImportTypeNode, InKeyword, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, IntrinsicKeyword, IterationStatement, JSDocAllType, JSDocComment, JSDocFunctionType, JSDocLink, JSDocLinkCode, JSDocLinkPlain, JSDocMemberName, JSDocNamepathType, JSDocNamespaceBody, JSDocNamespaceDeclaration, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocParameterTag, JSDocPropertyLikeTag, JSDocPropertyTag, JSDocReturnTag, JSDocSignature, JSDocTemplateTag, JSDocText, JSDocType, JSDocTypeExpression, JSDocTypeLiteral, JSDocUnknownType, JSDocVariadicType, JsxAttribute, JsxAttributeLike, JsxAttributeName, JsxAttributeValue, JsxAttributes, JsxChild, JsxClosingElement, JsxClosingFragment, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxOpeningFragment, JsxSelfClosingElement, JsxSpreadAttribute, JsxTagNameExpression, JsxTagNamePropertyAccess, JsxText, LabeledStatement, LeftHandSideExpression, LeftHandSideExpressionParent, LiteralExpression, LiteralTypeNode, LogicalOperator, LogicalOperatorOrHigher, MappedTypeNode, MemberExpression, MemberName, MetaProperty, MethodDeclaration, MethodSignature, MinusToken, MissingDeclaration, Modifier, ModifierLike, ModifierParent, ModuleBlock, ModuleBody, ModuleDeclaration, ModuleExportName, ModuleName, ModuleReference, MultiplicativeOperator, MultiplicativeOperatorOrHigher, NamedExportBindings, NamedExports, NamedImportBindings, NamedImports, NamedTupleMember, NamespaceBody, NamespaceDeclaration, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NeverKeyword, NewExpression, NoSubstitutionTemplateLiteral, NodeWithTypeArguments, NonNullExpression, NotEmittedStatement, NotEmittedTypeElement, NullLiteral, NumberKeyword, NumericLiteral, ObjectBindingPattern, ObjectKeyword, ObjectLiteralElementLike, ObjectLiteralExpression, ObjectLiteralExpressionBase, OmittedExpression, OptionalTypeNode, OutKeyword, OverrideKeyword, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PartiallyEmittedExpression, PlusToken, PostfixUnaryExpression, PostfixUnaryOperator, PrefixUnaryExpression, PrefixUnaryOperator, PrimaryExpression, PrivateIdentifier, PrivateKeyword, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertyName, PropertySignature, ProtectedKeyword, PublicKeyword, QualifiedName, QuestionDotToken, QuestionToken, ReadonlyKeyword, RegularExpressionLiteral, RelationalOperator, RelationalOperatorOrHigher, RestTypeNode, ReturnStatement, SatisfiesExpression, SemicolonClassElement, SetAccessorDeclaration, ShiftOperator, ShiftOperatorOrHigher, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, Statement, StatementParent, StaticKeyword, StringKeyword, StringLiteral, SuperExpression, SwitchStatement, SymbolKeyword, SyntheticExpression, TaggedTemplateExpression, TemplateExpression, TemplateHead, TemplateLiteral, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateMiddle, TemplateSpan, TemplateTail, ThisExpression, ThisTypeNode, ThrowStatement, TrueLiteral, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeElement, TypeLiteralNode, TypeNode, TypeNodeParent, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnaryExpression, UndefinedKeyword, UnionTypeNode, UnknownKeyword, UpdateExpression, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, VoidKeyword, WhileStatement, WithStatement, YieldExpression };
 }
@@ -2080,16 +2080,63 @@ 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
+//#region src/types/checker.d.ts
+type Checker = CheckerOverrides & Omit<TypeChecker, keyof CheckerOverrides>;
+interface CheckerOverrides {
+  getResolvedSignature(node: CallExpression | Decorator | JsxOpeningElement | JsxSelfClosingElement | NewExpression | TaggedTemplateExpression | CallLikeExpression): Signature | undefined;
+  /** Improve narrowing, borrow from typescript-eslint */
+  isArrayType(type: Type): type is TypeReference;
+  isTupleType(type: Type): type is TupleTypeReference;
+  /**
+   * TS internal api
+   * Return the type of the given property in the given type, or undefined if no such property exists
+   */
+  getTypeOfPropertyOfType(type: Type, propertyName: string): Type | undefined;
+  /**
+   * TS internal api
+   */
+  getContextualTypeForArgumentAtIndex(node: Node, argIndex: number): Type;
+}
+//#endregion
+//#region src/types/services.d.ts
+interface TypeScriptFileServices {
+  program: Program;
+  sourceFile: SourceFile;
+  typeChecker: Checker;
+}
+//#endregion
+//#region src/createNodeVisitorsForFile.d.ts
+/**
+ * All visitor subscriptions for a file, along with the callback to run on them.
+ */
+interface NodeVisitorsForFile {
+  enter: NodeVisitorSubscriptionsByKind | undefined;
+  exit: NodeVisitorSubscriptionsByKind | undefined;
+  visit: (node: Node) => void;
+}
+/**
+ * For each node, the visitor subscriptions that will run when that node is visited.
+ */
+type NodeVisitorSubscriptions = FileVisitorSubscription<Node, TypeScriptFileServices>[];
+/**
+ * For each node kind that has visitors registered, its associated subscriptions.
+ */
+type NodeVisitorSubscriptionsByKind = Partial<Record<SyntaxKind, NodeVisitorSubscriptions>>;
+/**
+ * Given all rule visitors for a file, collects them into a single {@link NodeVisitorsForFile}.
+ */
+export declare function createNodeVisitorsForFile(fileVisitors: readonly FileVisitors<object, TypeScriptFileServices>[]): NodeVisitorsForFile | undefined;
+//#endregion
 //#region src/directives/parseDirectivesFromTypeScriptFile.d.ts
 interface ExtractedDirective {
   range: NormalizedReportRangeObject;
   selection: string;
   type: string;
 }
-declare function extractDirectivesFromTypeScriptFile(sourceFile: SourceFile): ExtractedDirective[];
+export declare function extractDirectivesFromTypeScriptFile(sourceFile: SourceFile): ExtractedDirective[];
 //#endregion
 //#region src/getTSNodeRange.d.ts
-declare function getTSNodeRange(node: ts$1.Node, sourceFile: SourceFile): CharacterReportRange;
+export declare function getTSNodeRange(node: ts$1.Node, sourceFile: SourceFile): CharacterReportRange;
 //#endregion
 //#region src/nodes.d.ts
 interface TypeScriptNodesByName {
@@ -2290,41 +2337,20 @@ interface TypeScriptNodesByName {
 }
 type TypeScriptNodeVisitors = WithExitKeys<TypeScriptNodesByName>;
 //#endregion
-//#region src/types/checker.d.ts
-type Checker = CheckerOverrides & Omit<TypeChecker, keyof CheckerOverrides>;
-interface CheckerOverrides {
-  getResolvedSignature(node: CallExpression | Decorator | JsxOpeningElement | JsxSelfClosingElement | NewExpression | TaggedTemplateExpression | CallLikeExpression): Signature | undefined;
-  /** Improve narrowing, borrow from typescript-eslint */
-  isArrayType(type: Type): type is TypeReference;
-  isTupleType(type: Type): type is TupleTypeReference;
-  /**
-   * TS internal api
-   * Return the type of the given property in the given type, or undefined if no such property exists
-   */
-  getTypeOfPropertyOfType(type: Type, propertyName: string): Type | undefined;
-  /**
-   * TS internal api
-   */
-  getContextualTypeForArgumentAtIndex(node: Node, argIndex: number): Type;
-}
-//#endregion
 //#region src/language.d.ts
-interface TypeScriptFileServices {
-  program: Program;
-  sourceFile: SourceFile;
-  typeChecker: Checker;
-}
-declare const NodeSyntaxKinds: typeof SyntaxKind;
 type VolarCreateFile = (data: FileAboutData, program: Program, sourceFile: SourceFile) => VolarLanguageFileDefinition;
 type VolarLanguageFileDefinition = LanguageFileDefinition<TypeScriptFileServices> & {
   __volarServices: {
     getLanguageReports(): LanguageReports;
-    runVisitors(file: LanguageFile<TypeScriptFileServices>, options: InferredOutputObject<AnyOptionalSchema | undefined>, runtime: RuleRuntime<TypeScriptNodeVisitors, TypeScriptFileServices>): void;
+    runVisitors(fileVisitors: readonly FileVisitors<TypeScriptNodeVisitors, TypeScriptFileServices>[]): void;
   };
 };
-declare function setVolarCreateFile(create: VolarCreateFile): void;
-declare const typescriptLanguage: Language<TypeScriptNodeVisitors, TypeScriptFileServices>;
-declare function throwUnknownLanguageExtension(filename: string): never;
+export declare function setVolarCreateFile(create: VolarCreateFile): void;
+export declare const typescriptLanguage: Language<TypeScriptNodeVisitors, TypeScriptFileServices>;
+export declare function throwUnknownLanguageExtension(filename: string): never;
+//#endregion
+//#region src/nodeSyntaxKinds.d.ts
+export declare const NodeSyntaxKinds: typeof SyntaxKind;
 //#endregion
 //#region src/scope/types.d.ts
 type FunctionWithParameters = ArrowFunction | ConstructorDeclaration | FunctionDeclaration | FunctionExpression | GetAccessorDeclaration | MethodDeclaration | SetAccessorDeclaration;
@@ -2364,40 +2390,40 @@ interface ScopeVariable {
 }
 //#endregion
 //#region src/scope/scopeManager.d.ts
-declare function getScopeManager(sourceFile: SourceFile): ScopeManager;
+export declare function getScopeManager(sourceFile: SourceFile): ScopeManager;
 //#endregion
 //#region src/utils/createRuleTesterTSConfig.d.ts
-declare function createRuleTesterTSConfig(defaultCompilerOptions?: Record<string, unknown>): {
+export declare function createRuleTesterTSConfig(defaultCompilerOptions?: Record<string, unknown>): {
   "tsconfig.base.json": string;
   "tsconfig.json": string;
 };
 //#endregion
 //#region src/utils/declarationIncludesGlobal.d.ts
-declare function declarationIncludesGlobal(declaration: Declaration, program: Program): boolean;
+export declare function declarationIncludesGlobal(declaration: Declaration, program: Program): boolean;
 //#endregion
 //#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;
+export declare const forEachChild: <T>(node: AnyNode, cbNode: (node: AnyNode) => T | undefined, cbNodes?: (nodes: ts.NodeArray<AnyNode>) => T | undefined) => T | undefined;
 //#endregion
 //#region src/utils/getDeclarationsIfGlobal.d.ts
-declare function getDeclarationsIfGlobal(node: Expression, typeChecker: Checker, program: Program): Declaration[] | undefined;
+export declare function getDeclarationsIfGlobal(node: Expression, typeChecker: Checker, program: Program): Declaration[] | undefined;
 //#endregion
 //#region src/utils/getModifyingReferences.d.ts
 /**
  * Gets all references to a variable that modify it (assignments, increments, decrements).
  * @returns An array of identifier nodes that modify the variable.
  */
-declare function getModifyingReferences(identifier: Identifier, sourceFile: SourceFile): Identifier[];
+export declare function getModifyingReferences(identifier: Identifier, sourceFile: SourceFile): Identifier[];
 //#endregion
 //#region src/utils/getStaticValue.d.ts
 interface StaticValue {
   value: unknown;
 }
-declare function getStaticNumberValue(node: Expression): number | undefined;
-declare function getStaticStringValue(node: Expression): string | undefined;
-declare function getStaticValue(node: Expression): StaticValue | undefined;
+export declare function getStaticNumberValue(node: Expression): number | undefined;
+export declare function getStaticStringValue(node: Expression): string | undefined;
+export declare function getStaticValue(node: Expression): StaticValue | undefined;
 //#endregion
 //#region src/utils/hasSameTokens.d.ts
-declare function hasSameTokens(nodeA: AnyNode, nodeB: AnyNode, sourceFile: SourceFile): boolean;
+export declare function hasSameTokens(nodeA: AnyNode, nodeB: AnyNode, sourceFile: SourceFile): boolean;
 //#endregion
 //#region src/utils/isBuiltinArrayMethod.d.ts
 type BuiltInArrayMethodNode = CallExpression & {
@@ -2405,19 +2431,19 @@ type BuiltInArrayMethodNode = CallExpression & {
     expression: ts.Expression;
   };
 };
-declare function isBuiltinArrayMethod(name: string, node: CallExpression, typeChecker: Checker): node is BuiltInArrayMethodNode;
+export declare function isBuiltinArrayMethod(name: string, node: CallExpression, typeChecker: Checker): node is BuiltInArrayMethodNode;
 //#endregion
 //#region src/utils/isFunction.d.ts
-declare function isFunction(node: Expression, typeChecker: Checker): boolean;
+export declare function isFunction(node: Expression, typeChecker: Checker): boolean;
 //#endregion
 //#region src/utils/isGlobalDeclaration.d.ts
-declare function isGlobalDeclaration(node: Expression, typeChecker: Checker, program: Program): boolean;
+export declare function isGlobalDeclaration(node: Expression, typeChecker: Checker, program: Program): boolean;
 //#endregion
 //#region src/utils/isGlobalDeclarationOfName.d.ts
 /**
  * TODO: Use a scope analyzer (#400).
  */
-declare function isGlobalDeclarationOfName(node: Node, name: string, typeChecker: Checker, program: Program): boolean;
+export declare function isGlobalDeclarationOfName(node: Node, name: string, typeChecker: Checker, program: Program): boolean;
 //#endregion
 //#region src/utils/isGlobalVariable.d.ts
 /**
@@ -2426,7 +2452,7 @@ declare function isGlobalDeclarationOfName(node: Node, name: string, typeChecker
  * like undefined which have symbols but no user-defined declarations.
  * TODO: Use a scope manager (#400).
  */
-declare function isGlobalVariable(node: Expression, typeChecker: Checker, program: Program): boolean;
+export declare function isGlobalVariable(node: Expression, typeChecker: Checker, program: Program): boolean;
 //#endregion
 //#region src/utils/isInlineArrayCreation.d.ts
 /**
@@ -2434,22 +2460,22 @@ declare function isGlobalVariable(node: Expression, typeChecker: Checker, progra
  * These are cases where a new array is created immediately before the method call,
  * so mutating methods like .sort() or .reverse() are safe to use.
  */
-declare function isInlineArrayCreation(node: ts.Expression): boolean;
+export declare function isInlineArrayCreation(node: Expression): boolean;
 //#endregion
 //#region src/utils/isStaticString.d.ts
 type StaticString = NoSubstitutionTemplateLiteral | StringLiteral;
-declare function isStaticString(node: Expression): node is StaticString;
+export declare function isStaticString(node: Expression): node is StaticString;
 //#endregion
 //#region src/utils/isStringRawNoSubstitution.d.ts
 interface StringRawNoSubstitution extends TaggedTemplateExpression {
   template: NoSubstitutionTemplateLiteral;
 }
-declare function isStringRawNoSubstitution(node: Expression): node is StringRawNoSubstitution;
+export declare function isStringRawNoSubstitution(node: Expression): node is StringRawNoSubstitution;
 //#endregion
 //#region src/utils/unwrapParenthesizedNode.d.ts
-declare function unwrapParenthesizedNode(node: AnyNode): AnyNode;
+export declare function unwrapParenthesizedNode(node: AnyNode): AnyNode;
 //#endregion
 //#region src/utils/unwrapParentParenthesizedExpressions.d.ts
-declare function unwrapParentParenthesizedExpressions(node: BinaryExpression | ParenthesizedExpression): LeftHandSideExpressionParent;
+export declare function unwrapParentParenthesizedExpressions(node: BinaryExpression | ParenthesizedExpression): LeftHandSideExpressionParent;
 //#endregion
-export { type ast_d_exports as AST, type BuiltInArrayMethodNode, type Checker, type ExtractedDirective, type FunctionWithParameters, NodeSyntaxKinds, type Scope, type ScopeDefinition, type ScopeDefinitionKind, type ScopeManager, type ScopeReference, type ScopeVariable, type StaticString, type StaticValue, type StringRawNoSubstitution, type TSDiagnostic, type TypeScriptFileServices, type TypeScriptNodeVisitors, type TypeScriptNodesByName, convertTypeScriptDiagnosticToLanguageReport, createRuleTesterTSConfig, declarationIncludesGlobal, extractDirectivesFromTypeScriptFile, forEachChild, getDeclarationsIfGlobal, getModifyingReferences, getScopeManager, getStaticNumberValue, getStaticStringValue, getStaticValue, getTSNodeRange, hasSameTokens, isBuiltinArrayMethod, isFunction, isGlobalDeclaration, isGlobalDeclarationOfName, isGlobalVariable, isInlineArrayCreation, isStaticString, isStringRawNoSubstitution, setVolarCreateFile, throwUnknownLanguageExtension, typescriptLanguage, unwrapParentParenthesizedExpressions, unwrapParenthesizedNode };
+export type { ast_d_exports as AST, BuiltInArrayMethodNode, Checker, ExtractedDirective, FunctionWithParameters, NodeVisitorSubscriptions, NodeVisitorsForFile, Scope, ScopeDefinition, ScopeDefinitionKind, ScopeManager, ScopeReference, ScopeVariable, StaticString, StaticValue, StringRawNoSubstitution, TSDiagnostic, TypeScriptFileServices, TypeScriptNodeVisitors, TypeScriptNodesByName };

package/dist/index.mjs

@@ -1,14 +1,12 @@
-import ts, { SyntaxKind, getPreEmitDiagnostics, isClassDeclaration, isFunctionDeclaration, isIdentifier, isInterfaceDeclaration, isPropertySignature, isVariableDeclaration } from "typescript";
-import { DirectivesCollector, commonlyIgnoredPaths, createLanguage, getColumnAndLineOfPosition, getPositionOfColumnAndLine } from "@flint.fyi/core";
+import ts, { SyntaxKind, getPreEmitDiagnostics } from "typescript";
+import { DirectivesCollector, commonlyIgnoredPaths, createLanguage, getColumnAndLineOfPosition, getPositionOfColumnAndLine, groupFileVisitors, runFileVisitorSubscriptions } from "@flint.fyi/core";
 import * as tsutils from "ts-api-utils";
 import { FlintAssertionError, assert, normalizePath, nullThrows, pathKey } from "@flint.fyi/utils";
-import * as path$1 from "node:path";
-import path from "node:path";
 import { createProjectService } from "@typescript-eslint/project-service";
 import { debugForFile } from "debug-for-file";
+import { dirname, extname, relative, resolve } from "pathe";
 import fs from "node:fs";
 import timers from "node:timers";
-import { dirname, resolve } from "pathe";
 import { WeakCachedFactory } from "cached-factory";
 //#region src/convertTypeScriptDiagnosticToLanguageReport.ts
 function convertTypeScriptDiagnosticToLanguageReport(diagnostic) {
@@ -119,6 +117,102 @@ function formatLocation(file, start) {
 	return output;
 }
 //#endregion
+//#region src/getFirstEnumValues.ts
+/**
+* Removes TypeScript enum values that alias earlier values.
+* @param original Any TypeScript enum with numeric values.
+* @returns A version of the enum with only the first occurrence of each value.
+* @example
+* Given the following enum:
+* ```ts
+* enum Example {
+*   A = 1,
+*   B = 2,
+*   C = A
+* }
+* ```
+* Its original value looks like:
+* ```ts
+* {
+*   1: 'C', // <-- Points to 'C', the alias of 'A'
+*   2: 'B',
+*   A: 1,
+*   B: 2,
+*   C: 1,
+* }
+* ```
+* Calling `getFirstEnumValues(Example)` would return:
+* ```ts
+* {
+*   1: 'A', // <-- Corrected to the original 'A'
+*   2: 'B',
+*   A: 1,
+*   B: 2,
+*   C: 1,
+* }
+* ```
+*/
+function getFirstEnumValues(original) {
+	const result = {};
+	for (const key in original) {
+		if (typeof original[key] !== "number") continue;
+		if (!(key in result)) result[key] = original[key];
+		if (!(original[key] in result)) result[original[key]] = key;
+	}
+	return result;
+}
+//#endregion
+//#region src/nodeSyntaxKinds.ts
+const NodeSyntaxKinds = getFirstEnumValues(SyntaxKind);
+//#endregion
+//#region src/createNodeVisitorsForFile.ts
+/**
+* Given all rule visitors for a file, collects them into a single {@link NodeVisitorsForFile}.
+*/
+function createNodeVisitorsForFile(fileVisitors) {
+	const grouped = groupFileVisitors(fileVisitors);
+	const enter = grouped.enter && createSubscriptionsByKind(grouped.enter);
+	const exit = grouped.exit && createSubscriptionsByKind(grouped.exit);
+	if (enter) {
+		const visit = exit ? (node) => {
+			const entering = enter[node.kind];
+			if (entering !== void 0) runFileVisitorSubscriptions(entering, node);
+			node.forEachChild(visit);
+			const exiting = exit[node.kind];
+			if (exiting !== void 0) runFileVisitorSubscriptions(exiting, node);
+		} : (node) => {
+			const entering = enter[node.kind];
+			if (entering !== void 0) runFileVisitorSubscriptions(entering, node);
+			node.forEachChild(visit);
+		};
+		return {
+			enter,
+			exit,
+			visit
+		};
+	}
+	if (exit) {
+		const visit = (node) => {
+			node.forEachChild(visit);
+			const exiting = exit[node.kind];
+			if (exiting !== void 0) runFileVisitorSubscriptions(exiting, node);
+		};
+		return {
+			enter,
+			exit,
+			visit
+		};
+	}
+}
+function createSubscriptionsByKind(group) {
+	const byKind = Object.create(null);
+	for (const [name, subscriptions] of group) {
+		const kind = NodeSyntaxKinds[name];
+		if (typeof kind === "number" && NodeSyntaxKinds[kind] === name) byKind[kind] = subscriptions;
+	}
+	return byKind;
+}
+//#endregion
 //#region src/normalizeRange.ts
 function normalizeRange(original, sourceFile) {
 	const onCharacters = isNode(original) ? {
@@ -203,7 +297,7 @@ function getTSNodeRange(node, sourceFile) {
 //#endregion
 //#region package.json
 var name = "@flint.fyi/typescript-language";
-var version = "0.20.1";
+var version = "0.21.0";
 //#endregion
 //#region src/createTypeScriptServerHost.ts
 function serverHostMethodNotImplemented(methodName) {
@@ -300,57 +394,15 @@ function createTypeScriptServerHost(host) {
 	};
 }
 //#endregion
-//#region src/getFirstEnumValues.ts
-/**
-* Removes TypeScript enum values that alias earlier values.
-* @param original Any TypeScript enum with numeric values.
-* @returns A version of the enum with only the first occurrence of each value.
-* @example
-* Given the following enum:
-* ```ts
-* enum Example {
-*   A = 1,
-*   B = 2,
-*   C = A
-* }
-* ```
-* Its original value looks like:
-* ```ts
-* {
-*   1: 'C', // <-- Points to 'C', the alias of 'A'
-*   2: 'B',
-*   A: 1,
-*   B: 2,
-*   C: 1,
-* }
-* ```
-* Calling `getFirstEnumValues(Example)` would return:
-* ```ts
-* {
-*   1: 'A', // <-- Corrected to the original 'A'
-*   2: 'B',
-*   A: 1,
-*   B: 2,
-*   C: 1,
-* }
-* ```
-*/
-function getFirstEnumValues(original) {
-	const result = {};
-	for (const key in original) {
-		if (typeof original[key] !== "number") continue;
-		if (!(key in result)) result[key] = original[key];
-		if (!(original[key] in result)) result[original[key]] = key;
-	}
-	return result;
-}
+//#region src/utils/forEachChild.ts
+const forEachChild = ts.forEachChild;
 //#endregion
 //#region src/collectReferencedFilePaths.ts
 function collectReferencedFilePaths(program, sourceFile) {
 	const modulePaths = /* @__PURE__ */ new Set();
 	function resolveModulePath(moduleSpecifier) {
 		const resolved = ts.resolveModuleName(moduleSpecifier, sourceFile.fileName, program.getCompilerOptions(), ts.sys);
-		if (resolved.resolvedModule?.isExternalLibraryImport === false) return path$1.relative(program.getCurrentDirectory(), resolved.resolvedModule.resolvedFileName);
+		if (resolved.resolvedModule?.isExternalLibraryImport === false) return relative(program.getCurrentDirectory(), resolved.resolvedModule.resolvedFileName);
 	}
 	function visit(node) {
 		let path;
@@ -361,25 +413,25 @@ function collectReferencedFilePaths(program, sourceFile) {
 		else if (isImportTypeNode(node)) path = node.argument.literal.text;
 		const resolvedPath = path && resolveModulePath(path);
 		if (resolvedPath) modulePaths.add(resolvedPath);
-		ts.forEachChild(node, visit);
+		forEachChild(node, visit);
 	}
 	visit(sourceFile);
 	return Array.from(modulePaths);
 }
 function isAwaitImportCall(node) {
-	return ts.isAwaitExpression(node) && isImportCall(node.expression);
+	return node.kind === SyntaxKind.AwaitExpression && isImportCall(node.expression);
 }
 function isExportDeclaration(node) {
-	return ts.isExportDeclaration(node) && node.moduleSpecifier != null && ts.isStringLiteral(node.moduleSpecifier);
+	return node.kind === SyntaxKind.ExportDeclaration && node.moduleSpecifier?.kind === SyntaxKind.StringLiteral;
 }
 function isImportCall(node) {
-	return ts.isCallExpression(node) && tsutils.isImportExpression(node.expression) && !!node.arguments.length && ts.isStringLiteral(nullThrows(node.arguments[0], "First argument is expected to be present by prior length check"));
+	return node.kind === SyntaxKind.CallExpression && node.expression.kind === SyntaxKind.ImportKeyword && node.arguments[0]?.kind === SyntaxKind.StringLiteral;
 }
 function isImportDeclaration(node) {
-	return ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier);
+	return node.kind === SyntaxKind.ImportDeclaration && node.moduleSpecifier.kind === SyntaxKind.StringLiteral;
 }
 function isImportTypeNode(node) {
-	return ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument) && ts.isStringLiteral(node.argument.literal);
+	return node.kind === SyntaxKind.ImportType && node.argument.kind === SyntaxKind.LiteralType && node.argument.literal.kind === SyntaxKind.StringLiteral;
 }
 //#endregion
 //#region src/utils/containsGlobalDeclarations.ts
@@ -390,7 +442,7 @@ function isImportTypeNode(node) {
 function containsGlobalDeclarations(sourceFileNode) {
 	const isModule = ts.isExternalModule(sourceFileNode);
 	return sourceFileNode.statements.some((statement) => {
-		if (ts.isModuleDeclaration(statement) && statement.name.text === "global") return true;
+		if (statement.kind === SyntaxKind.ModuleDeclaration && statement.name.text === "global") return true;
 		if (isModule) return false;
 		if (!ts.canHaveModifiers(statement)) return false;
 		return ts.getModifiers(statement)?.some((mod) => mod.kind === SyntaxKind.DeclareKeyword);
@@ -491,8 +543,7 @@ function orderTypeScriptFilePaths(filePaths, host) {
 }
 //#endregion
 //#region src/language.ts
-const log = debugForFile(import.meta.filename);
-const NodeSyntaxKinds = getFirstEnumValues(SyntaxKind);
+const log = debugForFile(import.meta.url);
 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}`);
@@ -516,7 +567,7 @@ const typescriptLanguage = createLanguage({
 			const defaultProject = nullThrows(service.getDefaultProjectForFile(scriptInfo.fileName, true), `Could not find default project for file: ${data.filePathAbsolute}`);
 			const program = nullThrows(defaultProject.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);
+			const fileExtension = extname(data.filePathAbsolute);
 			if (typeScriptCoreSupportedExtensions.has(fileExtension)) return {
 				...parseDirectivesFromTypeScriptFile(sourceFile),
 				about: data,
@@ -546,24 +597,12 @@ const typescriptLanguage = createLanguage({
 		return getPreEmitDiagnostics(file.services.program, file.services.sourceFile).map(convertTypeScriptDiagnosticToLanguageReport);
 	},
 	orderFilePaths: orderTypeScriptFilePaths,
-	runFileVisitors(file, options, runtime) {
-		if (!runtime.visitors) return;
+	runFileVisitors(file, fileVisitors) {
 		if ("__volarServices" in file) {
-			file.__volarServices.runVisitors(file, options, runtime);
+			file.__volarServices.runVisitors(fileVisitors);
 			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);
+		createNodeVisitorsForFile(fileVisitors)?.visit(file.services.sourceFile);
 	}
 });
 const typeScriptCoreSupportedExtensions = /* @__PURE__ */ new Set([
@@ -589,14 +628,11 @@ const fileExtToFlintPlugin = {
 	".vue": "@flint.fyi/vue"
 };
 function throwUnknownLanguageExtension(filename) {
-	const pluginName = fileExtToFlintPlugin[path.extname(filename)];
+	const pluginName = fileExtToFlintPlugin[extname(filename)];
 	const message = pluginName ? `Did you install & import ${pluginName}?` : "Unknown extension.";
 	throw new Error(`Cannot process ${filename}. ${message}`);
 }
 //#endregion
-//#region src/utils/forEachChild.ts
-const forEachChild = ts.forEachChild;
-//#endregion
 //#region src/scope/identifierReferences.ts
 function isNonReferenceIdentifier(identifier) {
 	if (isIdentifierDeclaration(identifier) || isTypeReferenceIdentifier(identifier)) return true;
@@ -997,7 +1033,7 @@ function hasSameTokens(nodeA, nodeB, sourceFile) {
 	return queueA.length === queueB.length;
 }
 function areSameToken(nodeA, nodeB, sourceFile) {
-	if (ts.isIdentifier(nodeA) || ts.isPrivateIdentifier(nodeA) || ts.isNumericLiteral(nodeA) || ts.isBigIntLiteral(nodeA) || ts.isStringLiteral(nodeA) || ts.isNoSubstitutionTemplateLiteral(nodeA)) return nodeA.text === nodeB.text;
+	if (nodeA.kind === SyntaxKind.Identifier || nodeA.kind === SyntaxKind.PrivateIdentifier || nodeA.kind === SyntaxKind.NumericLiteral || nodeA.kind === SyntaxKind.BigIntLiteral || nodeA.kind === SyntaxKind.StringLiteral || nodeA.kind === SyntaxKind.NoSubstitutionTemplateLiteral) return nodeA.text === nodeB.text;
 	if (nodeA.kind === SyntaxKind.RegularExpressionLiteral) return sourceFile.text.slice(nodeA.getStart(sourceFile), nodeA.getEnd()) === sourceFile.text.slice(nodeB.getStart(sourceFile), nodeB.getEnd());
 	return true;
 }
@@ -1024,15 +1060,21 @@ function isGlobalDeclaration(node, typeChecker, program) {
 function isGlobalDeclarationOfName(node, name, typeChecker, program) {
 	const declarations = typeChecker.getSymbolAtLocation(node)?.getDeclarations();
 	if (!declarations) return false;
-	return declarations.every((declaration) => {
-		if (isVariableDeclaration(declaration) && declaration.initializer && isIdentifier(declaration.initializer)) return isGlobalDeclarationOfName(declaration.initializer, name, typeChecker, program);
-		if (isPropertySignature(declaration)) return isGlobalDeclarationOfName(declaration.parent, name, typeChecker, program);
-		return isDeclarationOfName(declaration, name) && declarationIncludesGlobal(declaration, program);
+	return declarations.every((tsDeclaration) => {
+		const declaration = tsDeclaration;
+		if (declaration.kind === SyntaxKind.VariableDeclaration && declaration.initializer?.kind === SyntaxKind.Identifier) return isGlobalDeclarationOfName(declaration.initializer, name, typeChecker, program);
+		if (declaration.kind === SyntaxKind.PropertySignature) return isGlobalDeclarationOfName(declaration.parent, name, typeChecker, program);
+		return isDeclarationOfName(declaration, name) && declarationIncludesGlobal(tsDeclaration, program);
 	});
 }
 function isDeclarationOfName(node, name) {
-	if (isClassDeclaration(node) || isFunctionDeclaration(node) || isInterfaceDeclaration(node) || isVariableDeclaration(node)) return node.name && isIdentifier(node.name) && node.name.text === name;
-	return false;
+	switch (node.kind) {
+		case SyntaxKind.ClassDeclaration:
+		case SyntaxKind.FunctionDeclaration:
+		case SyntaxKind.InterfaceDeclaration:
+		case SyntaxKind.VariableDeclaration: return node.name?.kind === SyntaxKind.Identifier && node.name.text === name;
+		default: return false;
+	}
 }
 //#endregion
 //#region src/utils/isGlobalVariable.ts
@@ -1076,18 +1118,18 @@ const objectStaticMethods = /* @__PURE__ */ new Set([
 * so mutating methods like .sort() or .reverse() are safe to use.
 */
 function isInlineArrayCreation(node) {
-	if (ts.isArrayLiteralExpression(node)) return true;
-	if (ts.isParenthesizedExpression(node)) return isInlineArrayCreation(node.expression);
-	if (ts.isCallExpression(node)) {
-		if (ts.isPropertyAccessExpression(node.expression)) {
+	if (node.kind === SyntaxKind.ArrayLiteralExpression) return true;
+	if (node.kind === SyntaxKind.ParenthesizedExpression) return isInlineArrayCreation(node.expression);
+	if (node.kind === SyntaxKind.CallExpression) {
+		if (node.expression.kind === SyntaxKind.PropertyAccessExpression) {
 			const methodName = node.expression.name.text;
-			if (ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "Object" && objectStaticMethods.has(methodName)) return true;
-			if (ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "Array" && (methodName === "from" || methodName === "of")) return true;
+			if (node.expression.expression.kind === SyntaxKind.Identifier && node.expression.expression.text === "Object" && objectStaticMethods.has(methodName)) return true;
+			if (node.expression.expression.kind === SyntaxKind.Identifier && node.expression.expression.text === "Array" && (methodName === "from" || methodName === "of")) return true;
 			if (methodsReturningNewArray.has(methodName)) return true;
 		}
-		if (ts.isIdentifier(node.expression) && node.expression.text === "Array" && ts.isNewExpression(node.parent)) return true;
+		if (node.expression.kind === SyntaxKind.Identifier && node.expression.text === "Array" && node.parent.kind === SyntaxKind.NewExpression) return true;
 	}
-	if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "Array") return true;
+	if (node.kind === SyntaxKind.NewExpression && node.expression.kind === SyntaxKind.Identifier && node.expression.text === "Array") return true;
 	return false;
 }
 //#endregion
@@ -1108,4 +1150,4 @@ function unwrapParentParenthesizedExpressions(node) {
 	return node.parent.kind === SyntaxKind.ParenthesizedExpression ? unwrapParentParenthesizedExpressions(node.parent) : node.parent;
 }
 //#endregion
-export { NodeSyntaxKinds, convertTypeScriptDiagnosticToLanguageReport, createRuleTesterTSConfig, declarationIncludesGlobal, extractDirectivesFromTypeScriptFile, forEachChild, getDeclarationsIfGlobal, getModifyingReferences, getScopeManager, getStaticNumberValue, getStaticStringValue, getStaticValue, getTSNodeRange, hasSameTokens, isBuiltinArrayMethod, isFunction, isGlobalDeclaration, isGlobalDeclarationOfName, isGlobalVariable, isInlineArrayCreation, isStaticString, isStringRawNoSubstitution, setVolarCreateFile, throwUnknownLanguageExtension, typescriptLanguage, unwrapParentParenthesizedExpressions, unwrapParenthesizedNode };
+export { NodeSyntaxKinds, convertTypeScriptDiagnosticToLanguageReport, createNodeVisitorsForFile, createRuleTesterTSConfig, declarationIncludesGlobal, extractDirectivesFromTypeScriptFile, forEachChild, getDeclarationsIfGlobal, getModifyingReferences, getScopeManager, getStaticNumberValue, getStaticStringValue, getStaticValue, getTSNodeRange, hasSameTokens, isBuiltinArrayMethod, isFunction, isGlobalDeclaration, isGlobalDeclarationOfName, isGlobalVariable, isInlineArrayCreation, isStaticString, isStringRawNoSubstitution, setVolarCreateFile, throwUnknownLanguageExtension, typescriptLanguage, unwrapParentParenthesizedExpressions, unwrapParenthesizedNode };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flint.fyi/typescript-language",
-  "version": "0.20.1",
+  "version": "0.21.0",
   "description": "[Experimental] TypeScript language for Flint.",
   "homepage": "https://flint.fyi",
   "repository": {
@@ -22,19 +22,19 @@
     "dist/"
   ],
   "dependencies": {
-    "@flint.fyi/core": "^0.26.0",
+    "@flint.fyi/core": "^0.27.0",
     "@flint.fyi/utils": "^0.16.0",
     "@typescript-eslint/project-service": "^8.53.0",
     "cached-factory": "^0.3.0",
     "debug-for-file": "^0.4.0",
     "pathe": "^2.0.3",
     "ts-api-utils": "^2.4.0",
-    "typescript": "^5.9.0 || ^6.0.0"
+    "typescript": "^6.0.3"
   },
   "devDependencies": {
     "@flint.fyi/build": "^0.1.0",
-    "tsdown": "0.22.14",
-    "vitest": "4.1.11"
+    "tsdown": "0.23.0",
+    "vitest": "5.0.1"
   },
   "engines": {
     "node": ">=26.1.0"