@flint.fyi/typescript-language 0.18.4 → 0.19.0

package/dist/index.mjs

@@ -0,0 +1,1104 @@
+import ts, { SyntaxKind, isClassDeclaration, isFunctionDeclaration, isIdentifier, isInterfaceDeclaration, isPropertySignature, isVariableDeclaration } from "typescript";
+import { DirectivesCollector, commonlyIgnoredPaths, createLanguage, getColumnAndLineOfPosition, getPositionOfColumnAndLine } 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 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) {
+	return {
+		code: `TS${diagnostic.code}`,
+		source: "typescript",
+		text: formatReport(diagnostic),
+		...diagnostic.file !== void 0 && diagnostic.start !== void 0 && { range: {
+			begin: diagnostic.start,
+			end: diagnostic.start + (diagnostic.length ?? 0)
+		} }
+	};
+}
+function color(text, formatStyle) {
+	return formatStyle + text + resetEscapeSequence;
+}
+function formatReport(diagnostic) {
+	let output = "";
+	if (diagnostic.file !== void 0) {
+		output += formatLocation(diagnostic.file, diagnostic.start);
+		output += " - ";
+	}
+	output += color(`TS${diagnostic.code}`, COLOR.Grey);
+	output += ": ";
+	output += ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+	if (diagnostic.file !== void 0) {
+		output += "\n";
+		output += formatCodeSpan(diagnostic.file, diagnostic.start, diagnostic.length, "", COLOR.Red);
+	}
+	if (diagnostic.relatedInformation) {
+		output += "\n";
+		for (const { file, length, messageText, start } of diagnostic.relatedInformation) {
+			const indent = "  ";
+			if (file) {
+				output += "\n";
+				output += " " + formatLocation(file, start);
+				output += formatCodeSpan(file, start, length, indent, COLOR.Cyan);
+			}
+			output += "\n";
+			output += indent + ts.flattenDiagnosticMessageText(messageText, "\n");
+		}
+	}
+	return output;
+}
+const gutterStyleSequence = "\x1B[7m";
+const ellipsis = "...";
+const gutterSeparator = " ";
+const resetEscapeSequence = "\x1B[0m";
+const COLOR = {
+	Blue: "\x1B[94m",
+	Cyan: "\x1B[96m",
+	Grey: "\x1B[90m",
+	Red: "\x1B[91m",
+	Yellow: "\x1B[93m"
+};
+function displayFilename(name) {
+	if (name.startsWith("./")) return name.slice(2);
+	return name.slice(process.cwd().length + 1);
+}
+function formatCodeSpan(file, start, length, indent, squiggleColor) {
+	const { column: firstLineChar, line: firstLine } = getColumnAndLineOfPosition(file, start);
+	const { column: lastLineChar, line: lastLine } = getColumnAndLineOfPosition(file, start + length);
+	const lastLineInFile = getColumnAndLineOfPosition(file, file.text.length).line;
+	const hasMoreThanFiveLines = lastLine - firstLine >= 4;
+	let gutterWidth = (lastLine + 1 + "").length;
+	if (hasMoreThanFiveLines) gutterWidth = Math.max(3, gutterWidth);
+	let context = "";
+	for (let i = firstLine; i <= lastLine; i++) {
+		context += "\n";
+		if (hasMoreThanFiveLines && firstLine + 1 < i && i < lastLine - 1) {
+			context += indent + color(ellipsis.padStart(gutterWidth), gutterStyleSequence) + " \n";
+			i = lastLine - 1;
+		}
+		const lineStart = getPositionOfColumnAndLine(file, {
+			column: 0,
+			line: i
+		});
+		const lineEnd = i < lastLineInFile ? getPositionOfColumnAndLine(file, {
+			column: 0,
+			line: i + 1
+		}) : file.text.length;
+		let lineContent = file.text.slice(lineStart, lineEnd);
+		lineContent = lineContent.trimEnd();
+		lineContent = lineContent.replace(/\t/g, " ");
+		context += indent + color((i + 1 + "").padStart(gutterWidth), gutterStyleSequence) + gutterSeparator;
+		context += lineContent + "\n";
+		context += indent + color("".padStart(gutterWidth), gutterStyleSequence) + gutterSeparator;
+		context += squiggleColor;
+		if (i === firstLine) {
+			const lastCharForLine = i === lastLine ? lastLineChar : void 0;
+			context += lineContent.slice(0, firstLineChar).replace(/\S/g, " ");
+			context += lineContent.slice(firstLineChar, lastCharForLine).replace(/./g, "~");
+		} else if (i === lastLine) context += lineContent.slice(0, lastLineChar).replace(/./g, "~");
+		else context += lineContent.replace(/./g, "~");
+		context += resetEscapeSequence;
+	}
+	return context;
+}
+function formatLocation(file, start) {
+	const { column, line } = getColumnAndLineOfPosition(file, start);
+	const relativeFileName = displayFilename(file.fileName);
+	let output = "";
+	output += color(relativeFileName, COLOR.Cyan);
+	output += ":";
+	output += color(`${line + 1}`, COLOR.Yellow);
+	output += ":";
+	output += color(`${column + 1}`, COLOR.Yellow);
+	return output;
+}
+//#endregion
+//#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
+//#region src/directives/parseDirectivesFromTypeScriptFile.ts
+function extractDirectivesFromTypeScriptFile(sourceFile) {
+	const directives = [];
+	tsutils.forEachComment(sourceFile, (fullText, sourceRange) => {
+		const commentText = fullText.slice(sourceRange.pos, sourceRange.end);
+		const match = /^\/\/\s*flint-(\S+)(?:\s+(.+))?/.exec(commentText);
+		if (!match) return;
+		let range = normalizeRange({
+			begin: sourceRange.pos,
+			end: sourceRange.end
+		}, sourceFile);
+		const matches = match.slice(1);
+		const type = nullThrows(matches[0], "First match is expected to be present by the regex match");
+		const selection = matches[1] ?? "";
+		if (type === "disable-next-line") range = extendRangeToNextCodeLine(sourceFile, range);
+		directives.push({
+			range,
+			selection,
+			type
+		});
+	});
+	return directives;
+}
+function parseDirectivesFromTypeScriptFile(sourceFile) {
+	const collector = new DirectivesCollector(sourceFile.statements.at(0)?.getStart(sourceFile) ?? sourceFile.text.length);
+	for (const { range, selection, type } of extractDirectivesFromTypeScriptFile(sourceFile)) collector.add(range, selection, type);
+	return collector.collect();
+}
+function computeNextCodeLine(sourceFile, directiveLine) {
+	const lineStarts = sourceFile.getLineStarts();
+	const nextLineStart = lineStarts[directiveLine + 1];
+	if (nextLineStart === void 0) return;
+	const scanner = ts.createScanner(sourceFile.languageVersion, true, sourceFile.languageVariant, sourceFile.text, void 0, nextLineStart);
+	if (scanner.scan() === SyntaxKind.EndOfFileToken) return;
+	const tokenPos = scanner.getTokenStart();
+	const codeLine = sourceFile.getLineAndCharacterOfPosition(tokenPos).line;
+	for (let line = directiveLine + 1; line < codeLine; line++) {
+		const start = lineStarts[line];
+		const end = lineStarts[line + 1] ?? sourceFile.text.length;
+		if (sourceFile.text.slice(start, end).trim() === "") return;
+	}
+	return codeLine;
+}
+function extendRangeToNextCodeLine(sourceFile, range) {
+	const codeLine = computeNextCodeLine(sourceFile, range.begin.line);
+	if (codeLine === void 0 || codeLine <= range.end.line + 1) return range;
+	const endPosition = nullThrows(sourceFile.getLineStarts()[codeLine], "Code line start is expected to be present by the computed code line") - 1;
+	const { character, line } = sourceFile.getLineAndCharacterOfPosition(endPosition);
+	return {
+		...range,
+		end: {
+			column: character,
+			line,
+			raw: endPosition
+		}
+	};
+}
+//#endregion
+//#region src/getTSNodeRange.ts
+function getTSNodeRange(node, sourceFile) {
+	return {
+		begin: node.getStart(sourceFile),
+		end: node.getEnd()
+	};
+}
+//#endregion
+//#region package.json
+var name = "@flint.fyi/typescript-language";
+var version = "0.19.0";
+//#endregion
+//#region src/createTypeScriptServerHost.ts
+function serverHostMethodNotImplemented(methodName) {
+	throw new FlintAssertionError(`ts.ServerHost's method '${methodName}' is not implemented.`);
+}
+const UV_DIRENT_TYPE = {
+	UV_DIRENT_DIR: 2,
+	UV_DIRENT_FILE: 1
+};
+const DirentCtor = fs.Dirent;
+function createTypeScriptServerHost(host) {
+	return {
+		...ts.sys,
+		args: [],
+		clearImmediate: timers.clearImmediate,
+		clearTimeout: timers.clearTimeout,
+		createDirectory() {
+			serverHostMethodNotImplemented("createDirectory");
+		},
+		directoryExists(directoryPath) {
+			return host.fileTypeSync(resolve(host.getCurrentDirectory(), directoryPath)) === "directory";
+		},
+		exit() {
+			serverHostMethodNotImplemented("exit");
+		},
+		fileExists(filePath) {
+			return host.fileTypeSync(resolve(host.getCurrentDirectory(), filePath)) === "file";
+		},
+		readDirectory(directoryPath, extensions, exclude, include, depth) {
+			const originalCwd = process.cwd.bind(process);
+			process.cwd = () => host.getCurrentDirectory();
+			const originalReadDirSync = fs.readdirSync;
+			const patchedReaddirSync = (readPath, options) => {
+				assert(typeof options === "object" && options != null && Object.keys(options).length === 1 && options.withFileTypes === true, `ts.sys.readDirectory passed unexpected options to fs.readdirSync: ${JSON.stringify(options)}`);
+				assert(typeof readPath === "string", "ts.sys.readDirectory passed unexpected path to fs.readdirSync");
+				try {
+					fs.readdirSync = originalReadDirSync;
+					return host.readDirectorySync(resolve(host.getCurrentDirectory(), readPath)).map((dirent) => new DirentCtor(dirent.name, dirent.type === "file" ? UV_DIRENT_TYPE.UV_DIRENT_FILE : UV_DIRENT_TYPE.UV_DIRENT_DIR, readPath));
+				} finally {
+					fs.readdirSync = patchedReaddirSync;
+				}
+			};
+			fs.readdirSync = patchedReaddirSync;
+			try {
+				return ts.sys.readDirectory(directoryPath, extensions, exclude, include, depth);
+			} finally {
+				process.cwd = originalCwd;
+				fs.readdirSync = originalReadDirSync;
+			}
+		},
+		readFile(filePath) {
+			return host.readFileSync(resolve(host.getCurrentDirectory(), filePath));
+		},
+		setImmediate: timers.setImmediate,
+		setTimeout: timers.setTimeout,
+		watchDirectory(directoryPath, callback, recursive = false) {
+			const watcher = host.watchDirectorySync(resolve(host.getCurrentDirectory(), directoryPath), (filePathAbsolute) => {
+				callback(filePathAbsolute);
+			}, {
+				ignoredPaths: commonlyIgnoredPaths,
+				recursive
+			});
+			return { close() {
+				watcher[Symbol.dispose]();
+			} };
+		},
+		watchFile(filePath, callback) {
+			const watcher = host.watchFileSync(resolve(host.getCurrentDirectory(), filePath), (event) => {
+				let eventKind;
+				switch (event) {
+					case "changed":
+						eventKind = ts.FileWatcherEventKind.Changed;
+						break;
+					case "created":
+						eventKind = ts.FileWatcherEventKind.Created;
+						break;
+					case "deleted":
+						eventKind = ts.FileWatcherEventKind.Deleted;
+						break;
+				}
+				callback(filePath, eventKind);
+			}, { ignoredPaths: commonlyIgnoredPaths });
+			return { close() {
+				watcher[Symbol.dispose]();
+			} };
+		},
+		write() {
+			serverHostMethodNotImplemented("write");
+		},
+		writeFile() {
+			serverHostMethodNotImplemented("writeFile");
+		}
+	};
+}
+//#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/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(process.cwd(), resolved.resolvedModule.resolvedFileName);
+	}
+	function visit(node) {
+		let path;
+		if (isImportDeclaration(node)) path = node.moduleSpecifier.text;
+		else if (isImportCall(node)) path = node.arguments[0].text;
+		else if (isAwaitImportCall(node)) path = node.expression.arguments[0].text;
+		else if (isImportTypeNode(node)) path = node.argument.literal.text;
+		const resolvedPath = path && resolveModulePath(path);
+		if (resolvedPath) modulePaths.add(resolvedPath);
+		ts.forEachChild(node, visit);
+	}
+	visit(sourceFile);
+	return Array.from(modulePaths);
+}
+function isAwaitImportCall(node) {
+	return ts.isAwaitExpression(node) && isImportCall(node.expression);
+}
+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"));
+}
+function isImportDeclaration(node) {
+	return ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier);
+}
+function isImportTypeNode(node) {
+	return ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument) && ts.isStringLiteral(node.argument.literal);
+}
+//#endregion
+//#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 === SyntaxKind.DeclareKeyword);
+	});
+}
+//#endregion
+//#region src/getTypeScriptFileCacheImpacts.ts
+function getTypeScriptFileCacheImpacts(file) {
+	return {
+		dependencies: ["tsconfig.json", ...collectReferencedFilePaths(file.services.program, file.services.sourceFile)],
+		invalidatesCache: containsGlobalDeclarations(file.services.sourceFile)
+	};
+}
+//#endregion
+//#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
+//#region src/language.ts
+const log = debugForFile(import.meta.filename);
+const NodeSyntaxKinds = getFirstEnumValues(SyntaxKind);
+const stateSymbol = Symbol.for("@flint.fyi/typescript-language/state");
+const globalTyped = globalThis;
+assert(globalTyped[stateSymbol] == null, `Two different versions of ${name} are imported: ${version} and ${globalTyped[stateSymbol]?.packageVersion}`);
+const languageState = globalTyped[stateSymbol] = {
+	packageVersion: version,
+	volarCreateFile: null
+};
+function setVolarCreateFile(create) {
+	assert(languageState.volarCreateFile == null, "setVolarCreateFile is expected to be called only once");
+	languageState.volarCreateFile = create;
+}
+const typescriptLanguage = createLanguage({
+	about: { name: "TypeScript" },
+	createFileFactory: (host) => {
+		const { service } = createProjectService({ host: createTypeScriptServerHost(host) });
+		function createFile(data) {
+			log("Opening client file:", data.filePathAbsolute);
+			service.openClientFile(data.filePathAbsolute);
+			log("Retrieving client services:", data.filePathAbsolute);
+			const scriptInfo = nullThrows(service.getScriptInfo(data.filePathAbsolute), `Could not find script info for file: ${data.filePathAbsolute}`);
+			const program = nullThrows(nullThrows(service.getDefaultProjectForFile(scriptInfo.fileName, true), `Could not find default project for file: ${data.filePathAbsolute}`).getLanguageService(true).getProgram(), `Could not retrieve program for file: ${data.filePathAbsolute}`);
+			const sourceFile = nullThrows(program.getSourceFile(data.filePathAbsolute), `Could not retrieve source file for: ${data.filePathAbsolute}`);
+			const fileExtension = path.extname(data.filePathAbsolute);
+			if (typeScriptCoreSupportedExtensions.has(fileExtension)) return {
+				...parseDirectivesFromTypeScriptFile(sourceFile),
+				about: data,
+				language: typescriptLanguage,
+				services: {
+					program,
+					sourceFile,
+					typeChecker: program.getTypeChecker()
+				},
+				[Symbol.dispose]() {
+					service.closeClientFile(data.filePathAbsolute);
+				}
+			};
+			if (languageState.volarCreateFile == null) throwUnknownLanguageExtension(data.filePathAbsolute);
+			return {
+				...languageState.volarCreateFile(data, program, sourceFile),
+				[Symbol.dispose]() {
+					service.closeClientFile(data.filePathAbsolute);
+				}
+			};
+		}
+		return { createFile };
+	},
+	getFileCacheImpacts: getTypeScriptFileCacheImpacts,
+	getLanguageReports(file) {
+		if ("__volarServices" in file) return file.__volarServices.getLanguageReports();
+		return ts.getPreEmitDiagnostics(file.services.program, file.services.sourceFile).map(convertTypeScriptDiagnosticToLanguageReport);
+	},
+	orderFilePaths: orderTypeScriptFilePaths,
+	runFileVisitors(file, options, runtime) {
+		if (!runtime.visitors) return;
+		if ("__volarServices" in file) {
+			file.__volarServices.runVisitors(file, options, runtime);
+			return;
+		}
+		const { visitors } = runtime;
+		const visitorServices = {
+			options,
+			...file.services
+		};
+		const visit = (node) => {
+			const key = NodeSyntaxKinds[node.kind];
+			visitors[key]?.(node, visitorServices);
+			node.forEachChild(visit);
+			visitors[`${key}:exit`]?.(node, visitorServices);
+		};
+		visit(file.services.sourceFile);
+	}
+});
+const typeScriptCoreSupportedExtensions = /* @__PURE__ */ new Set([
+	".cjs",
+	".cts",
+	".d.cts",
+	".d.mts",
+	".d.ts",
+	".js",
+	".json",
+	".jsx",
+	".mjs",
+	".mts",
+	".ts",
+	".tsx"
+]);
+const fileExtToFlintPlugin = {
+	".astro": "@flint.fyi/astro",
+	".gjs": "@flint.fyi/ember",
+	".gts": "@flint.fyi/ember",
+	".mdx": "@flint.fyi/mdx",
+	".svelte": "@flint.fyi/svelte",
+	".vue": "@flint.fyi/vue"
+};
+function throwUnknownLanguageExtension(filename) {
+	const pluginName = fileExtToFlintPlugin[path.extname(filename)];
+	const message = pluginName ? `Did you install & import ${pluginName}?` : "Unknown extension.";
+	throw new Error(`Cannot process ${filename}. ${message}`);
+}
+//#endregion
+//#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;
+	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
+//#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
+//#region src/scope/scopeManager.ts
+const scopeManagers = new WeakCachedFactory(createScopeManager);
+function getScopeManager(sourceFile) {
+	return scopeManagers.get(sourceFile);
+}
+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
+	};
+}
+//#endregion
+//#region src/utils/createRuleTesterTSConfig.ts
+function createRuleTesterTSConfig(defaultCompilerOptions) {
+	return {
+		"tsconfig.base.json": JSON.stringify({ compilerOptions: {
+			lib: ["esnext"],
+			moduleResolution: "bundler",
+			strict: true,
+			target: "esnext",
+			types: [],
+			...defaultCompilerOptions
+		} }, null, 2),
+		"tsconfig.json": JSON.stringify({ extends: "./tsconfig.base.json" }, null, 2)
+	};
+}
+//#endregion
+//#region src/utils/declarationIncludesGlobal.ts
+function declarationIncludesGlobal(declaration, program) {
+	const sourceFile = declaration.getSourceFile();
+	return program.isSourceFileDefaultLibrary(sourceFile) || /\/lib\.[^/]*\.d\.ts$/.test(sourceFile.fileName);
+}
+//#endregion
+//#region src/utils/declarationsIncludeGlobal.ts
+function declarationsIncludeGlobal(declarations, program) {
+	return declarations.some((declaration) => declarationIncludesGlobal(declaration, program));
+}
+//#endregion
+//#region src/utils/getDeclarationsIfGlobal.ts
+function getDeclarationsIfGlobal(node, typeChecker, program) {
+	const declarations = typeChecker.getSymbolAtLocation(node)?.getDeclarations();
+	return !!declarations && declarationsIncludeGlobal(declarations, program) ? declarations : void 0;
+}
+//#endregion
+//#region src/utils/getModifyingReferences.ts
+/**
+* Gets all references to a variable that modify it (assignments, increments, decrements).
+* @returns An array of identifier nodes that modify the variable.
+*/
+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
+//#region src/utils/unwrapParenthesizedNode.ts
+function unwrapParenthesizedNode(node) {
+	return node.kind === SyntaxKind.ParenthesizedExpression ? unwrapParenthesizedNode(node.expression) : node;
+}
+//#endregion
+//#region src/utils/getStaticValue.ts
+function getStaticNumberValue(node) {
+	const value = getStaticValue(node)?.value;
+	return typeof value === "number" ? value : void 0;
+}
+function getStaticStringValue(node) {
+	const value = getStaticValue(node)?.value;
+	return typeof value === "string" ? value : void 0;
+}
+function getStaticValue(node) {
+	const unwrapped = unwrapParenthesizedNode(node);
+	switch (unwrapped.kind) {
+		case SyntaxKind.AsExpression:
+		case SyntaxKind.NonNullExpression:
+		case SyntaxKind.SatisfiesExpression:
+		case SyntaxKind.TypeAssertionExpression: return getStaticValue(unwrapped.expression);
+		case SyntaxKind.BigIntLiteral: return { value: BigInt(unwrapped.text.slice(0, -1)) };
+		case SyntaxKind.FalseKeyword: return { value: false };
+		case SyntaxKind.NoSubstitutionTemplateLiteral: return { value: unwrapped.text };
+		case SyntaxKind.NullKeyword: return { value: null };
+		case SyntaxKind.NumericLiteral: return { value: Number(unwrapped.text) };
+		case SyntaxKind.PrefixUnaryExpression: return getPrefixUnaryStaticValue(unwrapped);
+		case SyntaxKind.StringLiteral: return { value: unwrapped.text };
+		case SyntaxKind.TrueKeyword: return { value: true };
+	}
+}
+function getPrefixUnaryStaticValue(node) {
+	const operand = getStaticValue(node.operand);
+	if (!operand) return;
+	switch (node.operator) {
+		case SyntaxKind.ExclamationToken: return { value: !operand.value };
+		case SyntaxKind.MinusToken:
+			if (typeof operand.value === "bigint" || typeof operand.value === "number") return { value: -operand.value };
+			return;
+		case SyntaxKind.PlusToken: return typeof operand.value === "number" ? { value: operand.value } : void 0;
+		case SyntaxKind.TildeToken: if (typeof operand.value === "bigint" || typeof operand.value === "number") return { value: ~operand.value };
+	}
+}
+//#endregion
+//#region src/utils/hasSameTokens.ts
+function hasSameTokens(nodeA, nodeB, sourceFile) {
+	const queueA = [unwrapParenthesizedNode(nodeA)];
+	const queueB = [unwrapParenthesizedNode(nodeB)];
+	while (true) {
+		const currentA = queueA.shift();
+		const currentB = queueB.shift();
+		if (!currentA || !currentB) break;
+		if (currentA.kind !== currentB.kind) return false;
+		if (ts.isTokenKind(currentA.kind)) {
+			if (!areSameToken(currentA, currentB, sourceFile)) return false;
+			continue;
+		}
+		const childrenA = currentA.getChildren(sourceFile);
+		const childrenB = currentB.getChildren(sourceFile);
+		if (childrenA.length !== childrenB.length) return false;
+		queueA.push(...childrenA);
+		queueB.push(...childrenB);
+	}
+	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.RegularExpressionLiteral) return sourceFile.text.slice(nodeA.getStart(sourceFile), nodeA.getEnd()) === sourceFile.text.slice(nodeB.getStart(sourceFile), nodeB.getEnd());
+	return true;
+}
+//#endregion
+//#region src/utils/isBuiltinArrayMethod.ts
+function isBuiltinArrayMethod(name, node, typeChecker) {
+	return node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.name.text === name && typeChecker.isArrayType(typeChecker.getTypeAtLocation(node.expression.expression)) && node.parent.kind !== SyntaxKind.ExpressionStatement;
+}
+//#endregion
+//#region src/utils/isFunction.ts
+function isFunction(node, typeChecker) {
+	return !!typeChecker.getTypeAtLocation(node).getCallSignatures().length;
+}
+//#endregion
+//#region src/utils/isGlobalDeclaration.ts
+function isGlobalDeclaration(node, typeChecker, program) {
+	return !!getDeclarationsIfGlobal(node, typeChecker, program);
+}
+//#endregion
+//#region src/utils/isGlobalDeclarationOfName.ts
+/**
+* TODO: Use a scope analyzer (#400).
+*/
+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);
+	});
+}
+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;
+}
+//#endregion
+//#region src/utils/isGlobalVariable.ts
+/**
+* Checks if a node is a reference to a global variable (e.g., Object, undefined, NaN).
+* Global variables are those declared in TypeScript's lib files or are global identifiers
+* like undefined which have symbols but no user-defined declarations.
+* TODO: Use a scope manager (#400).
+*/
+function isGlobalVariable(node, typeChecker, program) {
+	const symbol = typeChecker.getSymbolAtLocation(node);
+	if (!symbol) return false;
+	const declarations = symbol.getDeclarations();
+	if (!declarations?.length) return true;
+	return declarationsIncludeGlobal(declarations, program);
+}
+//#endregion
+//#region src/utils/isInlineArrayCreation.ts
+const methodsReturningNewArray = /* @__PURE__ */ new Set([
+	"concat",
+	"entries",
+	"filter",
+	"flat",
+	"flatMap",
+	"from",
+	"keys",
+	"map",
+	"of",
+	"slice",
+	"split",
+	"values"
+]);
+const objectStaticMethods = /* @__PURE__ */ new Set([
+	"entries",
+	"keys",
+	"values"
+]);
+/**
+* Checks if a node represents an inline array creation expression.
+* 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.
+*/
+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)) {
+			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 (methodsReturningNewArray.has(methodName)) return true;
+		}
+		if (ts.isIdentifier(node.expression) && node.expression.text === "Array" && ts.isNewExpression(node.parent)) return true;
+	}
+	if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "Array") return true;
+	return false;
+}
+//#endregion
+//#region src/utils/isStaticString.ts
+function isStaticString(node) {
+	return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+//#endregion
+//#region src/utils/isStringRawNoSubstitution.ts
+function isStringRawNoSubstitution(node) {
+	if (node.kind !== SyntaxKind.TaggedTemplateExpression) return false;
+	const tag = node.tag;
+	return tag.kind === SyntaxKind.PropertyAccessExpression && tag.expression.kind === SyntaxKind.Identifier && tag.expression.text === "String" && tag.name.kind === SyntaxKind.Identifier && tag.name.text === "raw" && node.template.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+//#endregion
+//#region src/utils/unwrapParentParenthesizedExpressions.ts
+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 };