react-doctor 0.9.13-dev.ff7dd67 → 0.9.14-dev.499a020

package/dist/project-analysis-worker.js

@@ -1,19 +1,22 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="d6e7f765-fd9c-5293-bba2-ca87773f3e5e")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="81139e97-fbde-59ee-9b65-cb0499a5510a")}catch(e){}}();
 import { i as __toESM, n as __exportAll, r as __require, t as __commonJSMin } from "./chunk-ChKA3wi6.js";
-import { n as require_picomatch$2, t as require_semver } from "./semver-DFtnEmN-.js";
+import { n as require_picomatch$2, t as require_semver } from "./semver-BZIuy1gP.js";
+import { t as typescriptBinding } from "./_react-doctor_require-typescript-DXQDYeWK.js";
+import { t as unwrapTypescriptExpression } from "./unwrap-typescript-expression-CrEPQUWz.js";
+import { a as MAX_GLOB_PATTERN_LENGTH_CHARS, c as GIT_CHECK_ATTR_MAX_BUFFER_BYTES } from "./constants-DNh19qg9.js";
+import { n as isPlainObject } from "./fs-utils-C88IbqFa.js";
 import { builtinModules } from "node:module";
-import { spawnSync } from "node:child_process";
-import * as path$1 from "node:path";
-import path, { basename, dirname, extname, isAbsolute, join, parse, posix, relative, resolve, sep } from "node:path";
 import * as fs$1 from "node:fs";
 import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
-import ts from "typescript";
+import * as path$1 from "node:path";
+import path, { basename, dirname, extname, isAbsolute, join, parse, posix, relative, resolve, sep } from "node:path";
+import { spawnSync } from "node:child_process";
+import { devNull } from "node:os";
 import { parseSync } from "oxc-parser";
+import { readFile } from "node:fs/promises";
 import { ResolverFactory } from "oxc-resolver";
-import { devNull } from "node:os";
 import { parseJSONC, parseTOML, parseYAML } from "confbox";
-import { readFile } from "node:fs/promises";
 import { parse as parse$1 } from "@astrojs/compiler/sync";
 //#region ../core/src/project-analysis/constants.ts
 const DEFAULT_EXTENSIONS = [
@@ -13380,19 +13383,19 @@ const collectStylesheetImportSpecifiers = (content) => {
 const extractJitiLoadReferences = (sourceText) => {
 	if (!sourceText.includes("jiti")) return [];
 	const virtualFilePath = "react-doctor-jiti-source.tsx";
-	const sourceFile = ts.createSourceFile(virtualFilePath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+	const sourceFile = typescriptBinding.createSourceFile(virtualFilePath, sourceText, typescriptBinding.ScriptTarget.Latest, true, typescriptBinding.ScriptKind.TSX);
 	const compilerOptions = {
 		allowJs: true,
-		jsx: ts.JsxEmit.Preserve,
+		jsx: typescriptBinding.JsxEmit.Preserve,
 		noLib: true,
 		noResolve: true,
-		target: ts.ScriptTarget.Latest
+		target: typescriptBinding.ScriptTarget.Latest
 	};
-	const compilerHost = ts.createCompilerHost(compilerOptions);
+	const compilerHost = typescriptBinding.createCompilerHost(compilerOptions);
 	compilerHost.fileExists = (candidatePath) => candidatePath === virtualFilePath;
 	compilerHost.getSourceFile = (candidatePath) => candidatePath === virtualFilePath ? sourceFile : void 0;
 	compilerHost.readFile = (candidatePath) => candidatePath === virtualFilePath ? sourceText : void 0;
-	const program = ts.createProgram({
+	const program = typescriptBinding.createProgram({
 		rootNames: [virtualFilePath],
 		options: compilerOptions,
 		host: compilerHost
@@ -13407,60 +13410,60 @@ const extractJitiLoadReferences = (sourceText) => {
 	const factorySymbols = /* @__PURE__ */ new Set();
 	const moduleSymbols = /* @__PURE__ */ new Set();
 	const loaderSymbols = /* @__PURE__ */ new Set();
-	const isRequireJitiCall = (expression) => ts.isCallExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "require" && typeChecker.getSymbolAtLocation(expression.expression) === void 0 && expression.arguments.length === 1 && ts.isStringLiteralLike(expression.arguments[0]) && expression.arguments[0].text === "jiti";
+	const isRequireJitiCall = (expression) => typescriptBinding.isCallExpression(expression) && typescriptBinding.isIdentifier(expression.expression) && expression.expression.text === "require" && typeChecker.getSymbolAtLocation(expression.expression) === void 0 && expression.arguments.length === 1 && typescriptBinding.isStringLiteralLike(expression.arguments[0]) && expression.arguments[0].text === "jiti";
 	for (const statement of boundSourceFile.statements) {
-		if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === "jiti") {
+		if (typescriptBinding.isImportDeclaration(statement) && typescriptBinding.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === "jiti") {
 			const importClause = statement.importClause;
 			if (!importClause) continue;
 			if (importClause.name) {
 				const defaultImportSymbol = typeChecker.getSymbolAtLocation(importClause.name);
 				if (defaultImportSymbol) factorySymbols.add(defaultImportSymbol);
 			}
-			if (importClause.namedBindings && ts.isNamespaceImport(importClause.namedBindings)) {
+			if (importClause.namedBindings && typescriptBinding.isNamespaceImport(importClause.namedBindings)) {
 				const moduleSymbol = typeChecker.getSymbolAtLocation(importClause.namedBindings.name);
 				if (moduleSymbol) moduleSymbols.add(moduleSymbol);
 			}
-			if (importClause.namedBindings && ts.isNamedImports(importClause.namedBindings)) for (const importSpecifier of importClause.namedBindings.elements) {
+			if (importClause.namedBindings && typescriptBinding.isNamedImports(importClause.namedBindings)) for (const importSpecifier of importClause.namedBindings.elements) {
 				if ((importSpecifier.propertyName?.text ?? importSpecifier.name.text) !== "createJiti") continue;
 				const factorySymbol = typeChecker.getSymbolAtLocation(importSpecifier.name);
 				if (factorySymbol) factorySymbols.add(factorySymbol);
 			}
 			continue;
 		}
-		if (!ts.isVariableStatement(statement)) continue;
+		if (!typescriptBinding.isVariableStatement(statement)) continue;
 		for (const declaration of statement.declarationList.declarations) {
 			if (!declaration.initializer || !isRequireJitiCall(declaration.initializer)) continue;
-			if (ts.isIdentifier(declaration.name)) {
+			if (typescriptBinding.isIdentifier(declaration.name)) {
 				const moduleSymbol = typeChecker.getSymbolAtLocation(declaration.name);
 				if (moduleSymbol) moduleSymbols.add(moduleSymbol);
 				continue;
 			}
-			if (!ts.isObjectBindingPattern(declaration.name)) continue;
+			if (!typescriptBinding.isObjectBindingPattern(declaration.name)) continue;
 			for (const bindingElement of declaration.name.elements) {
 				const importedName = bindingElement.propertyName ?? bindingElement.name;
-				if (!ts.isIdentifier(importedName) || importedName.text !== "createJiti") continue;
-				if (!ts.isIdentifier(bindingElement.name)) continue;
+				if (!typescriptBinding.isIdentifier(importedName) || importedName.text !== "createJiti") continue;
+				if (!typescriptBinding.isIdentifier(bindingElement.name)) continue;
 				const factorySymbol = typeChecker.getSymbolAtLocation(bindingElement.name);
 				if (factorySymbol) factorySymbols.add(factorySymbol);
 			}
 		}
 	}
-	const isRequireJitiFactoryCall = (expression) => ts.isCallExpression(expression) && isRequireJitiCall(expression.expression);
+	const isRequireJitiFactoryCall = (expression) => typescriptBinding.isCallExpression(expression) && isRequireJitiCall(expression.expression);
 	const isFactoryExpression = (expression) => {
 		const factorySymbol = typeChecker.getSymbolAtLocation(expression);
 		if (factorySymbol && factorySymbols.has(factorySymbol)) return true;
-		if (!ts.isPropertyAccessExpression(expression) || expression.name.text !== "createJiti") return false;
+		if (!typescriptBinding.isPropertyAccessExpression(expression) || expression.name.text !== "createJiti") return false;
 		const moduleSymbol = typeChecker.getSymbolAtLocation(expression.expression);
 		return moduleSymbol !== void 0 && moduleSymbols.has(moduleSymbol);
 	};
 	const collectLoaderBindings = (node) => {
-		if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && ts.isCallExpression(node.initializer)) {
+		if (typescriptBinding.isVariableDeclaration(node) && typescriptBinding.isIdentifier(node.name) && node.initializer && typescriptBinding.isCallExpression(node.initializer)) {
 			if (isRequireJitiFactoryCall(node.initializer) || isFactoryExpression(node.initializer.expression)) {
 				const loaderSymbol = typeChecker.getSymbolAtLocation(node.name);
 				if (loaderSymbol) loaderSymbols.add(loaderSymbol);
 			}
 		}
-		ts.forEachChild(node, collectLoaderBindings);
+		typescriptBinding.forEachChild(node, collectLoaderBindings);
 	};
 	collectLoaderBindings(boundSourceFile);
 	const references = [];
@@ -13468,25 +13471,25 @@ const extractJitiLoadReferences = (sourceText) => {
 		const firstArgument = callExpression.arguments[0];
 		const position = boundSourceFile.getLineAndCharacterOfPosition(callExpression.getStart());
 		references.push({
-			path: firstArgument && ts.isStringLiteralLike(firstArgument) ? firstArgument.text : void 0,
+			path: firstArgument && typescriptBinding.isStringLiteralLike(firstArgument) ? firstArgument.text : void 0,
 			line: position.line + 1,
 			column: position.character
 		});
 	};
 	const visitLoaderCalls = (node) => {
-		if (ts.isCallExpression(node)) {
+		if (typescriptBinding.isCallExpression(node)) {
 			const calleeSymbol = typeChecker.getSymbolAtLocation(node.expression);
 			if (calleeSymbol && loaderSymbols.has(calleeSymbol)) recordLoaderCall(node);
-			else if (ts.isCallExpression(node.expression)) {
+			else if (typescriptBinding.isCallExpression(node.expression)) {
 				if (isRequireJitiFactoryCall(node.expression) || isFactoryExpression(node.expression.expression)) recordLoaderCall(node);
-			} else if (ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "import") {
+			} else if (typescriptBinding.isPropertyAccessExpression(node.expression) && node.expression.name.text === "import") {
 				const loaderExpression = node.expression.expression;
 				const loaderSymbol = typeChecker.getSymbolAtLocation(loaderExpression);
-				const isInlineFactory = ts.isCallExpression(loaderExpression) && isFactoryExpression(loaderExpression.expression);
+				const isInlineFactory = typescriptBinding.isCallExpression(loaderExpression) && isFactoryExpression(loaderExpression.expression);
 				if (loaderSymbol && loaderSymbols.has(loaderSymbol) || isInlineFactory) recordLoaderCall(node);
 			}
 		}
-		ts.forEachChild(node, visitLoaderCalls);
+		typescriptBinding.forEachChild(node, visitLoaderCalls);
 	};
 	visitLoaderCalls(boundSourceFile);
 	return references;
@@ -36057,10 +36060,10 @@ const extractMarkdownModuleStatements = (sourceText) => {
 //#endregion
 //#region ../core/src/project-analysis/collect/parse.ts
 const extractRecoveryImports = (filePath, sourceText) => {
-	const sourceFile = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, filePath.endsWith("x") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+	const sourceFile = typescriptBinding.createSourceFile(filePath, sourceText, typescriptBinding.ScriptTarget.Latest, true, filePath.endsWith("x") ? typescriptBinding.ScriptKind.TSX : typescriptBinding.ScriptKind.TS);
 	const imports = [];
 	for (const statement of sourceFile.statements) {
-		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		if (!typescriptBinding.isImportDeclaration(statement) || !typescriptBinding.isStringLiteral(statement.moduleSpecifier)) continue;
 		const importedNames = [];
 		const importClause = statement.importClause;
 		if (importClause?.name) importedNames.push({
@@ -36070,14 +36073,14 @@ const extractRecoveryImports = (filePath, sourceText) => {
 			isDefault: true,
 			isTypeOnly: importClause.isTypeOnly
 		});
-		if (importClause?.namedBindings && ts.isNamespaceImport(importClause.namedBindings)) importedNames.push({
+		if (importClause?.namedBindings && typescriptBinding.isNamespaceImport(importClause.namedBindings)) importedNames.push({
 			name: "*",
 			alias: importClause.namedBindings.name.text,
 			isNamespace: true,
 			isDefault: false,
 			isTypeOnly: importClause.isTypeOnly
 		});
-		if (importClause?.namedBindings && ts.isNamedImports(importClause.namedBindings)) for (const element of importClause.namedBindings.elements) importedNames.push({
+		if (importClause?.namedBindings && typescriptBinding.isNamedImports(importClause.namedBindings)) for (const element of importClause.namedBindings.elements) importedNames.push({
 			name: element.propertyName?.text ?? element.name.text,
 			alias: element.name.text,
 			isNamespace: false,
@@ -36102,18 +36105,18 @@ const restoreMaskedSourceRange = (maskedSource, sourceSection, startOffset) => {
 	for (let characterIndex = 0; characterIndex < sourceSection.length; characterIndex++) maskedSource[startOffset + characterIndex] = sourceSection[characterIndex];
 };
 const maskSelectedExportKeywords = (sourceText, shouldMaskStatement) => {
-	const sourceFile = ts.createSourceFile("embedded-component.tsx", sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+	const sourceFile = typescriptBinding.createSourceFile("embedded-component.tsx", sourceText, typescriptBinding.ScriptTarget.Latest, true, typescriptBinding.ScriptKind.TSX);
 	const maskedSource = sourceText.split("");
 	for (const statement of sourceFile.statements) {
-		if (!shouldMaskStatement(statement) || !ts.canHaveModifiers(statement)) continue;
-		const exportModifier = ts.getModifiers(statement)?.find((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+		if (!shouldMaskStatement(statement) || !typescriptBinding.canHaveModifiers(statement)) continue;
+		const exportModifier = typescriptBinding.getModifiers(statement)?.find((modifier) => modifier.kind === typescriptBinding.SyntaxKind.ExportKeyword);
 		if (!exportModifier) continue;
 		for (let characterIndex = exportModifier.getStart(sourceFile); characterIndex < exportModifier.end; characterIndex++) maskedSource[characterIndex] = " ";
 	}
 	return maskedSource.join("");
 };
-const maskAstroPropsExports = (sourceText) => maskSelectedExportKeywords(sourceText, (statement) => (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) && statement.name.text === "Props");
-const maskSvelteInstancePropExports = (sourceText) => maskSelectedExportKeywords(sourceText, (statement) => ts.isVariableStatement(statement) && (statement.declarationList.flags & ts.NodeFlags.Let) !== 0);
+const maskAstroPropsExports = (sourceText) => maskSelectedExportKeywords(sourceText, (statement) => (typescriptBinding.isInterfaceDeclaration(statement) || typescriptBinding.isTypeAliasDeclaration(statement)) && statement.name.text === "Props");
+const maskSvelteInstancePropExports = (sourceText) => maskSelectedExportKeywords(sourceText, (statement) => typescriptBinding.isVariableStatement(statement) && (statement.declarationList.flags & typescriptBinding.NodeFlags.Let) !== 0);
 const extractAstroSources = (sourceText) => {
 	const maskedSource = createWhitespaceMask(sourceText);
 	let astroRoot;
@@ -38057,13 +38060,6 @@ const discoverMobileEntryPoints = (directory) => {
 	}
 };
 //#endregion
-//#region ../core/src/utils/unwrap-typescript-expression.ts
-const unwrapTypescriptExpression = (expression) => {
-	let currentExpression = expression;
-	while (ts.isParenthesizedExpression(currentExpression) || ts.isAsExpression(currentExpression) || ts.isSatisfiesExpression(currentExpression) || ts.isNonNullExpression(currentExpression) || ts.isTypeAssertionExpression(currentExpression)) currentExpression = currentExpression.expression;
-	return currentExpression;
-};
-//#endregion
 //#region ../core/src/project-analysis/collect/expo-config-plugin-entries.ts
 const EXPO_CONFIG_FILE_GLOBS = ["app.config.{ts,mts,cts,js,mjs,cjs}", "app.json"];
 const NESTED_EXPO_CONFIG_FILE_GLOBS = [
@@ -38107,52 +38103,52 @@ const addExpoPluginEntry = (entries, packageNamePlugins, rootDirectory, configDi
 	entries.add(resolvedPath);
 };
 const getPropertyName$4 = (name) => {
-	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
+	if (typescriptBinding.isIdentifier(name) || typescriptBinding.isStringLiteral(name) || typescriptBinding.isNumericLiteral(name)) return name.text;
 };
 const collectExpoPluginPathsFromArray = (array, entries, packageNamePlugins, rootDirectory, configDirectory) => {
 	for (const element of array.elements) {
-		if (ts.isStringLiteral(element) || ts.isNoSubstitutionTemplateLiteral(element)) {
+		if (typescriptBinding.isStringLiteral(element) || typescriptBinding.isNoSubstitutionTemplateLiteral(element)) {
 			addExpoPluginEntry(entries, packageNamePlugins, rootDirectory, configDirectory, element.text);
 			continue;
 		}
-		if (ts.isArrayLiteralExpression(element)) {
+		if (typescriptBinding.isArrayLiteralExpression(element)) {
 			const [pluginName] = element.elements;
-			if (pluginName && (ts.isStringLiteral(pluginName) || ts.isNoSubstitutionTemplateLiteral(pluginName))) addExpoPluginEntry(entries, packageNamePlugins, rootDirectory, configDirectory, pluginName.text);
+			if (pluginName && (typescriptBinding.isStringLiteral(pluginName) || typescriptBinding.isNoSubstitutionTemplateLiteral(pluginName))) addExpoPluginEntry(entries, packageNamePlugins, rootDirectory, configDirectory, pluginName.text);
 		}
 	}
 };
 const collectExpoPluginPathsFromConfigObject = (objectLiteral, entries, packageNamePlugins, rootDirectory, configDirectory) => {
 	for (const property of objectLiteral.properties) {
-		if (!ts.isPropertyAssignment(property)) continue;
+		if (!typescriptBinding.isPropertyAssignment(property)) continue;
 		const propertyName = getPropertyName$4(property.name);
-		if (propertyName === "plugins" && ts.isArrayLiteralExpression(property.initializer)) collectExpoPluginPathsFromArray(property.initializer, entries, packageNamePlugins, rootDirectory, configDirectory);
-		if (propertyName === "expo" && ts.isObjectLiteralExpression(property.initializer)) collectExpoPluginPathsFromConfigObject(property.initializer, entries, packageNamePlugins, rootDirectory, configDirectory);
+		if (propertyName === "plugins" && typescriptBinding.isArrayLiteralExpression(property.initializer)) collectExpoPluginPathsFromArray(property.initializer, entries, packageNamePlugins, rootDirectory, configDirectory);
+		if (propertyName === "expo" && typescriptBinding.isObjectLiteralExpression(property.initializer)) collectExpoPluginPathsFromConfigObject(property.initializer, entries, packageNamePlugins, rootDirectory, configDirectory);
 	}
 };
 const collectReturnedExpoConfigPluginPaths = (body, entries, packageNamePlugins, rootDirectory, configDirectory) => {
-	if (!ts.isBlock(body)) {
+	if (!typescriptBinding.isBlock(body)) {
 		const expression = unwrapTypescriptExpression(body);
-		if (ts.isObjectLiteralExpression(expression)) collectExpoPluginPathsFromConfigObject(expression, entries, packageNamePlugins, rootDirectory, configDirectory);
+		if (typescriptBinding.isObjectLiteralExpression(expression)) collectExpoPluginPathsFromConfigObject(expression, entries, packageNamePlugins, rootDirectory, configDirectory);
 		return;
 	}
 	const visit = (node) => {
-		if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node)) return;
-		if (ts.isReturnStatement(node) && node.expression) {
+		if (typescriptBinding.isFunctionDeclaration(node) || typescriptBinding.isFunctionExpression(node) || typescriptBinding.isArrowFunction(node)) return;
+		if (typescriptBinding.isReturnStatement(node) && node.expression) {
 			const expression = unwrapTypescriptExpression(node.expression);
-			if (ts.isObjectLiteralExpression(expression)) collectExpoPluginPathsFromConfigObject(expression, entries, packageNamePlugins, rootDirectory, configDirectory);
+			if (typescriptBinding.isObjectLiteralExpression(expression)) collectExpoPluginPathsFromConfigObject(expression, entries, packageNamePlugins, rootDirectory, configDirectory);
 			return;
 		}
-		ts.forEachChild(node, visit);
+		typescriptBinding.forEachChild(node, visit);
 	};
 	visit(body);
 };
 const collectExpoPluginPathsFromConfigExpression = (expression, entries, packageNamePlugins, rootDirectory, configDirectory, bindings, seenIdentifiers = /* @__PURE__ */ new Set()) => {
 	const configExpression = unwrapTypescriptExpression(expression);
-	if (ts.isObjectLiteralExpression(configExpression)) {
+	if (typescriptBinding.isObjectLiteralExpression(configExpression)) {
 		collectExpoPluginPathsFromConfigObject(configExpression, entries, packageNamePlugins, rootDirectory, configDirectory);
 		return;
 	}
-	if (ts.isIdentifier(configExpression)) {
+	if (typescriptBinding.isIdentifier(configExpression)) {
 		if (seenIdentifiers.has(configExpression.text)) return;
 		seenIdentifiers.add(configExpression.text);
 		const boundExpression = bindings.expressions.get(configExpression.text);
@@ -38164,23 +38160,23 @@ const collectExpoPluginPathsFromConfigExpression = (expression, entries, package
 		if (boundFunction?.body) collectReturnedExpoConfigPluginPaths(boundFunction.body, entries, packageNamePlugins, rootDirectory, configDirectory);
 		return;
 	}
-	if (ts.isArrowFunction(configExpression)) {
+	if (typescriptBinding.isArrowFunction(configExpression)) {
 		collectReturnedExpoConfigPluginPaths(configExpression.body, entries, packageNamePlugins, rootDirectory, configDirectory);
 		return;
 	}
-	if (ts.isFunctionExpression(configExpression) && configExpression.body) collectReturnedExpoConfigPluginPaths(configExpression.body, entries, packageNamePlugins, rootDirectory, configDirectory);
+	if (typescriptBinding.isFunctionExpression(configExpression) && configExpression.body) collectReturnedExpoConfigPluginPaths(configExpression.body, entries, packageNamePlugins, rootDirectory, configDirectory);
 };
-const hasDefaultExportModifier = (node) => Boolean(ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword));
-const isModuleExportsAssignmentTarget = (node) => ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "module" && node.name.text === "exports";
+const hasDefaultExportModifier = (node) => Boolean(typescriptBinding.canHaveModifiers(node) && typescriptBinding.getModifiers(node)?.some((modifier) => modifier.kind === typescriptBinding.SyntaxKind.DefaultKeyword));
+const isModuleExportsAssignmentTarget = (node) => typescriptBinding.isPropertyAccessExpression(node) && typescriptBinding.isIdentifier(node.expression) && node.expression.text === "module" && node.name.text === "exports";
 const collectStaticConfigBindings = (sourceFile) => {
 	const expressions = /* @__PURE__ */ new Map();
 	const functions = /* @__PURE__ */ new Map();
 	for (const statement of sourceFile.statements) {
-		if (ts.isVariableStatement(statement)) {
-			for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.initializer) expressions.set(declaration.name.text, declaration.initializer);
+		if (typescriptBinding.isVariableStatement(statement)) {
+			for (const declaration of statement.declarationList.declarations) if (typescriptBinding.isIdentifier(declaration.name) && declaration.initializer) expressions.set(declaration.name.text, declaration.initializer);
 			continue;
 		}
-		if (ts.isFunctionDeclaration(statement) && statement.name) functions.set(statement.name.text, statement);
+		if (typescriptBinding.isFunctionDeclaration(statement) && statement.name) functions.set(statement.name.text, statement);
 	}
 	return {
 		expressions,
@@ -38189,23 +38185,23 @@ const collectStaticConfigBindings = (sourceFile) => {
 };
 const collectExpoPluginPathsFromAppConfig = (configPath, entries, packageNamePlugins, rootDirectory) => {
 	const extension = extname(configPath);
-	const sourceFile = ts.createSourceFile(configPath, readFileSync(configPath, "utf8"), ts.ScriptTarget.Latest, true, extension === ".ts" || extension === ".mts" || extension === ".cts" ? ts.ScriptKind.TS : ts.ScriptKind.JS);
+	const sourceFile = typescriptBinding.createSourceFile(configPath, readFileSync(configPath, "utf8"), typescriptBinding.ScriptTarget.Latest, true, extension === ".ts" || extension === ".mts" || extension === ".cts" ? typescriptBinding.ScriptKind.TS : typescriptBinding.ScriptKind.JS);
 	const configDirectory = dirname(configPath);
 	const bindings = collectStaticConfigBindings(sourceFile);
 	const visit = (node) => {
-		if (ts.isExportAssignment(node)) {
+		if (typescriptBinding.isExportAssignment(node)) {
 			collectExpoPluginPathsFromConfigExpression(node.expression, entries, packageNamePlugins, rootDirectory, configDirectory, bindings);
 			return;
 		}
-		if (ts.isFunctionDeclaration(node) && hasDefaultExportModifier(node) && node.body) {
+		if (typescriptBinding.isFunctionDeclaration(node) && hasDefaultExportModifier(node) && node.body) {
 			collectReturnedExpoConfigPluginPaths(node.body, entries, packageNamePlugins, rootDirectory, configDirectory);
 			return;
 		}
-		if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && isModuleExportsAssignmentTarget(node.left)) {
+		if (typescriptBinding.isBinaryExpression(node) && node.operatorToken.kind === typescriptBinding.SyntaxKind.EqualsToken && isModuleExportsAssignmentTarget(node.left)) {
 			collectExpoPluginPathsFromConfigExpression(node.right, entries, packageNamePlugins, rootDirectory, configDirectory, bindings);
 			return;
 		}
-		ts.forEachChild(node, visit);
+		typescriptBinding.forEachChild(node, visit);
 	};
 	visit(sourceFile);
 };
@@ -38885,23 +38881,23 @@ const resolveGeneratedOutputs = (patterns, configDirectory) => {
 };
 const extractVitePluginConfigContents = (content) => {
 	const pluginConfigContents = [];
-	const sourceFile = ts.createSourceFile("vite.config.ts", content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-	const pluginName = sourceFile.statements.find((statement) => ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === "vite-plugin-graphql-codegen" && statement.importClause?.name !== void 0)?.importClause?.name?.text;
+	const sourceFile = typescriptBinding.createSourceFile("vite.config.ts", content, typescriptBinding.ScriptTarget.Latest, true, typescriptBinding.ScriptKind.TS);
+	const pluginName = sourceFile.statements.find((statement) => typescriptBinding.isImportDeclaration(statement) && typescriptBinding.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === "vite-plugin-graphql-codegen" && statement.importClause?.name !== void 0)?.importClause?.name?.text;
 	if (!pluginName) return [];
-	const exportAssignment = sourceFile.statements.find((statement) => ts.isExportAssignment(statement) && !statement.isExportEquals);
+	const exportAssignment = sourceFile.statements.find((statement) => typescriptBinding.isExportAssignment(statement) && !statement.isExportEquals);
 	if (!exportAssignment) return [];
 	const topLevelVariableInitializers = /* @__PURE__ */ new Map();
 	for (const statement of sourceFile.statements) {
-		if (!ts.isVariableStatement(statement)) continue;
-		for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.initializer) topLevelVariableInitializers.set(declaration.name.text, declaration.initializer);
+		if (!typescriptBinding.isVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) if (typescriptBinding.isIdentifier(declaration.name) && declaration.initializer) topLevelVariableInitializers.set(declaration.name.text, declaration.initializer);
 	}
 	const unwrapExpression = (expression) => {
-		if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isSatisfiesExpression(expression)) return unwrapExpression(expression.expression);
+		if (typescriptBinding.isParenthesizedExpression(expression) || typescriptBinding.isAsExpression(expression) || typescriptBinding.isSatisfiesExpression(expression)) return unwrapExpression(expression.expression);
 		return expression;
 	};
 	const collectPluginExpression = (expression, variableInitializers, isPluginNameShadowed, visitedIdentifiers = /* @__PURE__ */ new Set()) => {
 		const unwrappedExpression = unwrapExpression(expression);
-		if (ts.isCallExpression(unwrappedExpression) && ts.isIdentifier(unwrappedExpression.expression) && unwrappedExpression.expression.text === pluginName) {
+		if (typescriptBinding.isCallExpression(unwrappedExpression) && typescriptBinding.isIdentifier(unwrappedExpression.expression) && unwrappedExpression.expression.text === pluginName) {
 			const configArgument = unwrappedExpression.arguments[0];
 			if (configArgument && !isPluginNameShadowed) {
 				const bindingStatements = [...variableInitializers.entries()].map(([variableName, initializer]) => `const ${variableName} = (${initializer.getText(sourceFile)});`).join("\n");
@@ -38909,54 +38905,54 @@ const extractVitePluginConfigContents = (content) => {
 			}
 			return;
 		}
-		if (ts.isIdentifier(unwrappedExpression) && !visitedIdentifiers.has(unwrappedExpression.text)) {
+		if (typescriptBinding.isIdentifier(unwrappedExpression) && !visitedIdentifiers.has(unwrappedExpression.text)) {
 			const initializer = variableInitializers.get(unwrappedExpression.text);
 			if (!initializer) return;
 			collectPluginExpression(initializer, variableInitializers, isPluginNameShadowed, new Set(visitedIdentifiers).add(unwrappedExpression.text));
 			return;
 		}
-		if (ts.isArrayLiteralExpression(unwrappedExpression)) {
-			for (const element of unwrappedExpression.elements) collectPluginExpression(ts.isSpreadElement(element) ? element.expression : element, variableInitializers, isPluginNameShadowed, visitedIdentifiers);
+		if (typescriptBinding.isArrayLiteralExpression(unwrappedExpression)) {
+			for (const element of unwrappedExpression.elements) collectPluginExpression(typescriptBinding.isSpreadElement(element) ? element.expression : element, variableInitializers, isPluginNameShadowed, visitedIdentifiers);
 			return;
 		}
-		if (ts.isConditionalExpression(unwrappedExpression)) {
+		if (typescriptBinding.isConditionalExpression(unwrappedExpression)) {
 			collectPluginExpression(unwrappedExpression.whenTrue, variableInitializers, isPluginNameShadowed, visitedIdentifiers);
 			collectPluginExpression(unwrappedExpression.whenFalse, variableInitializers, isPluginNameShadowed, visitedIdentifiers);
 			return;
 		}
-		if (ts.isBinaryExpression(unwrappedExpression) && (unwrappedExpression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || unwrappedExpression.operatorToken.kind === ts.SyntaxKind.BarBarToken || unwrappedExpression.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken)) {
+		if (typescriptBinding.isBinaryExpression(unwrappedExpression) && (unwrappedExpression.operatorToken.kind === typescriptBinding.SyntaxKind.AmpersandAmpersandToken || unwrappedExpression.operatorToken.kind === typescriptBinding.SyntaxKind.BarBarToken || unwrappedExpression.operatorToken.kind === typescriptBinding.SyntaxKind.QuestionQuestionToken)) {
 			collectPluginExpression(unwrappedExpression.left, variableInitializers, isPluginNameShadowed, visitedIdentifiers);
 			collectPluginExpression(unwrappedExpression.right, variableInitializers, isPluginNameShadowed, visitedIdentifiers);
 		}
 	};
 	const collectConfigPlugins = (expression, variableInitializers, isPluginNameShadowed, visitedIdentifiers = /* @__PURE__ */ new Set()) => {
 		const unwrappedExpression = unwrapExpression(expression);
-		if (ts.isIdentifier(unwrappedExpression) && !visitedIdentifiers.has(unwrappedExpression.text)) {
+		if (typescriptBinding.isIdentifier(unwrappedExpression) && !visitedIdentifiers.has(unwrappedExpression.text)) {
 			const initializer = variableInitializers.get(unwrappedExpression.text);
 			if (!initializer) return;
 			collectConfigPlugins(initializer, variableInitializers, isPluginNameShadowed, new Set(visitedIdentifiers).add(unwrappedExpression.text));
 			return;
 		}
-		if (ts.isCallExpression(unwrappedExpression)) {
+		if (typescriptBinding.isCallExpression(unwrappedExpression)) {
 			const calledExpression = unwrapExpression(unwrappedExpression.expression);
-			if (!ts.isIdentifier(calledExpression) || calledExpression.text !== "defineConfig") return;
+			if (!typescriptBinding.isIdentifier(calledExpression) || calledExpression.text !== "defineConfig") return;
 			const configArgument = unwrappedExpression.arguments[0];
 			if (!configArgument) return;
 			const unwrappedArgument = unwrapExpression(configArgument);
-			if (ts.isArrowFunction(unwrappedArgument) || ts.isFunctionExpression(unwrappedArgument)) {
-				let callbackPluginNameShadowed = isPluginNameShadowed || unwrappedArgument.parameters.some((parameter) => ts.isIdentifier(parameter.name) && parameter.name.text === pluginName);
-				if (!ts.isBlock(unwrappedArgument.body)) {
+			if (typescriptBinding.isArrowFunction(unwrappedArgument) || typescriptBinding.isFunctionExpression(unwrappedArgument)) {
+				let callbackPluginNameShadowed = isPluginNameShadowed || unwrappedArgument.parameters.some((parameter) => typescriptBinding.isIdentifier(parameter.name) && parameter.name.text === pluginName);
+				if (!typescriptBinding.isBlock(unwrappedArgument.body)) {
 					collectConfigPlugins(unwrappedArgument.body, variableInitializers, callbackPluginNameShadowed);
 					return;
 				}
 				const callbackVariableInitializers = new Map(variableInitializers);
 				for (const statement of unwrappedArgument.body.statements) {
-					if (ts.isVariableStatement(statement)) for (const declaration of statement.declarationList.declarations) {
-						if (!ts.isIdentifier(declaration.name)) continue;
+					if (typescriptBinding.isVariableStatement(statement)) for (const declaration of statement.declarationList.declarations) {
+						if (!typescriptBinding.isIdentifier(declaration.name)) continue;
 						if (declaration.name.text === pluginName) callbackPluginNameShadowed = true;
 						if (declaration.initializer) callbackVariableInitializers.set(declaration.name.text, declaration.initializer);
 					}
-					if (ts.isReturnStatement(statement) && statement.expression) {
+					if (typescriptBinding.isReturnStatement(statement) && statement.expression) {
 						collectConfigPlugins(statement.expression, callbackVariableInitializers, callbackPluginNameShadowed);
 						return;
 					}
@@ -38966,10 +38962,10 @@ const extractVitePluginConfigContents = (content) => {
 			collectConfigPlugins(unwrappedArgument, variableInitializers, isPluginNameShadowed);
 			return;
 		}
-		if (!ts.isObjectLiteralExpression(unwrappedExpression)) return;
+		if (!typescriptBinding.isObjectLiteralExpression(unwrappedExpression)) return;
 		for (const property of unwrappedExpression.properties) {
-			if (ts.isPropertyAssignment(property) && (ts.isIdentifier(property.name) && property.name.text === "plugins" || ts.isStringLiteral(property.name) && property.name.text === "plugins")) collectPluginExpression(property.initializer, variableInitializers, isPluginNameShadowed);
-			if (ts.isShorthandPropertyAssignment(property) && property.name.text === "plugins") collectPluginExpression(property.name, variableInitializers, isPluginNameShadowed);
+			if (typescriptBinding.isPropertyAssignment(property) && (typescriptBinding.isIdentifier(property.name) && property.name.text === "plugins" || typescriptBinding.isStringLiteral(property.name) && property.name.text === "plugins")) collectPluginExpression(property.initializer, variableInitializers, isPluginNameShadowed);
+			if (typescriptBinding.isShorthandPropertyAssignment(property) && property.name.text === "plugins") collectPluginExpression(property.name, variableInitializers, isPluginNameShadowed);
 		}
 	};
 	collectConfigPlugins(exportAssignment.expression, topLevelVariableInitializers, false);
@@ -39093,24 +39089,24 @@ const TARO_ARRAY_SELECTION_METHODS = new Set([
 	"splice"
 ]);
 const getPropertyName$2 = (propertyName) => {
-	if (ts.isIdentifier(propertyName) || ts.isStringLiteral(propertyName) || ts.isNoSubstitutionTemplateLiteral(propertyName)) return propertyName.text;
+	if (typescriptBinding.isIdentifier(propertyName) || typescriptBinding.isStringLiteral(propertyName) || typescriptBinding.isNoSubstitutionTemplateLiteral(propertyName)) return propertyName.text;
 };
 const unwrapConfigExpression = (expression) => {
-	if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isSatisfiesExpression(expression)) return unwrapConfigExpression(expression.expression);
-	if (ts.isCallExpression(expression)) {
+	if (typescriptBinding.isParenthesizedExpression(expression) || typescriptBinding.isAsExpression(expression) || typescriptBinding.isSatisfiesExpression(expression)) return unwrapConfigExpression(expression.expression);
+	if (typescriptBinding.isCallExpression(expression)) {
 		const [configArgument] = expression.arguments;
 		return configArgument ? unwrapConfigExpression(configArgument) : expression;
 	}
 	return expression;
 };
 const unwrapArrayExpression = (expression) => {
-	if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isSatisfiesExpression(expression)) return unwrapArrayExpression(expression.expression);
+	if (typescriptBinding.isParenthesizedExpression(expression) || typescriptBinding.isAsExpression(expression) || typescriptBinding.isSatisfiesExpression(expression)) return unwrapArrayExpression(expression.expression);
 	return expression;
 };
 const getPropertyInitializer = (objectLiteral, propertyNames) => {
 	for (const property of objectLiteral.properties) {
-		if (ts.isShorthandPropertyAssignment(property) && propertyNames.has(property.name.text)) return property.name;
-		if (!ts.isPropertyAssignment(property)) continue;
+		if (typescriptBinding.isShorthandPropertyAssignment(property) && propertyNames.has(property.name.text)) return property.name;
+		if (!typescriptBinding.isPropertyAssignment(property)) continue;
 		const propertyName = getPropertyName$2(property.name);
 		if (propertyName && propertyNames.has(propertyName)) return property.initializer;
 	}
@@ -39118,16 +39114,16 @@ const getPropertyInitializer = (objectLiteral, propertyNames) => {
 const collectArrayElements = (expression, variableInitializers, pushedElements, visitedIdentifiers = /* @__PURE__ */ new Set()) => {
 	if (!expression) return [];
 	const unwrappedExpression = unwrapArrayExpression(expression);
-	if (ts.isArrayLiteralExpression(unwrappedExpression)) return [...unwrappedExpression.elements];
-	if (ts.isConditionalExpression(unwrappedExpression)) return [...collectArrayElements(unwrappedExpression.whenTrue, variableInitializers, pushedElements, visitedIdentifiers), ...collectArrayElements(unwrappedExpression.whenFalse, variableInitializers, pushedElements, visitedIdentifiers)];
-	if (ts.isCallExpression(unwrappedExpression) && ts.isPropertyAccessExpression(unwrappedExpression.expression) && TARO_ARRAY_SELECTION_METHODS.has(unwrappedExpression.expression.name.text)) return collectArrayElements(unwrappedExpression.expression.expression, variableInitializers, pushedElements, visitedIdentifiers);
-	if (ts.isIdentifier(unwrappedExpression) && !visitedIdentifiers.has(unwrappedExpression.text)) {
+	if (typescriptBinding.isArrayLiteralExpression(unwrappedExpression)) return [...unwrappedExpression.elements];
+	if (typescriptBinding.isConditionalExpression(unwrappedExpression)) return [...collectArrayElements(unwrappedExpression.whenTrue, variableInitializers, pushedElements, visitedIdentifiers), ...collectArrayElements(unwrappedExpression.whenFalse, variableInitializers, pushedElements, visitedIdentifiers)];
+	if (typescriptBinding.isCallExpression(unwrappedExpression) && typescriptBinding.isPropertyAccessExpression(unwrappedExpression.expression) && TARO_ARRAY_SELECTION_METHODS.has(unwrappedExpression.expression.name.text)) return collectArrayElements(unwrappedExpression.expression.expression, variableInitializers, pushedElements, visitedIdentifiers);
+	if (typescriptBinding.isIdentifier(unwrappedExpression) && !visitedIdentifiers.has(unwrappedExpression.text)) {
 		const nextVisitedIdentifiers = new Set(visitedIdentifiers).add(unwrappedExpression.text);
 		return [...collectArrayElements(variableInitializers.get(unwrappedExpression.text), variableInitializers, pushedElements, nextVisitedIdentifiers), ...pushedElements.get(unwrappedExpression.text) ?? []];
 	}
 	return [];
 };
-const collectPagePaths = (expression, variableInitializers, pushedElements) => collectArrayElements(expression, variableInitializers, pushedElements).flatMap((element) => ts.isStringLiteral(element) || ts.isNoSubstitutionTemplateLiteral(element) ? [element.text] : []);
+const collectPagePaths = (expression, variableInitializers, pushedElements) => collectArrayElements(expression, variableInitializers, pushedElements).flatMap((element) => typescriptBinding.isStringLiteral(element) || typescriptBinding.isNoSubstitutionTemplateLiteral(element) ? [element.text] : []);
 const resolvePageEntries = (configDirectory, pagePaths) => pagePaths.flatMap((pagePath) => {
 	const resolvedEntry = resolveEntryWithExtensions(resolve(configDirectory, pagePath));
 	return resolvedEntry ? [resolvedEntry] : [];
@@ -39136,9 +39132,9 @@ const collectConfigPageEntries = (configDirectory, configObject, variableInitial
 	const entries = resolvePageEntries(configDirectory, collectPagePaths(getPropertyInitializer(configObject, new Set(["pages"])), variableInitializers, pushedElements));
 	const subPackagesExpression = getPropertyInitializer(configObject, new Set(["subPackages", "subpackages"]));
 	for (const subPackageElement of collectArrayElements(subPackagesExpression, variableInitializers, pushedElements)) {
-		if (!ts.isObjectLiteralExpression(subPackageElement)) continue;
+		if (!typescriptBinding.isObjectLiteralExpression(subPackageElement)) continue;
 		const rootExpression = getPropertyInitializer(subPackageElement, new Set(["root"]));
-		if (!rootExpression || !ts.isStringLiteral(rootExpression) && !ts.isNoSubstitutionTemplateLiteral(rootExpression)) continue;
+		if (!rootExpression || !typescriptBinding.isStringLiteral(rootExpression) && !typescriptBinding.isNoSubstitutionTemplateLiteral(rootExpression)) continue;
 		const subPackagePages = collectPagePaths(getPropertyInitializer(subPackageElement, new Set(["pages"])), variableInitializers, pushedElements).map((pagePath) => `${rootExpression.text}/${pagePath}`);
 		entries.push(...resolvePageEntries(configDirectory, subPackagePages));
 	}
@@ -39147,56 +39143,56 @@ const collectConfigPageEntries = (configDirectory, configObject, variableInitial
 const collectVariableInitializers = (sourceFile) => {
 	const variableInitializers = /* @__PURE__ */ new Map();
 	for (const statement of sourceFile.statements) {
-		if (!ts.isVariableStatement(statement)) continue;
-		for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.initializer) variableInitializers.set(declaration.name.text, declaration.initializer);
+		if (!typescriptBinding.isVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) if (typescriptBinding.isIdentifier(declaration.name) && declaration.initializer) variableInitializers.set(declaration.name.text, declaration.initializer);
 	}
 	return variableInitializers;
 };
 const collectShadowedBindingNames = (bindingName, topLevelVariableNames) => {
-	if (ts.isIdentifier(bindingName)) return topLevelVariableNames.has(bindingName.text) ? [bindingName.text] : [];
-	return bindingName.elements.flatMap((bindingElement) => ts.isBindingElement(bindingElement) ? collectShadowedBindingNames(bindingElement.name, topLevelVariableNames) : []);
+	if (typescriptBinding.isIdentifier(bindingName)) return topLevelVariableNames.has(bindingName.text) ? [bindingName.text] : [];
+	return bindingName.elements.flatMap((bindingElement) => typescriptBinding.isBindingElement(bindingElement) ? collectShadowedBindingNames(bindingElement.name, topLevelVariableNames) : []);
 };
 const collectPushedElements = (sourceFile, topLevelVariableNames) => {
 	const pushedElements = /* @__PURE__ */ new Map();
 	const visitNode = (node, shadowedNames) => {
-		if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node) || ts.isConstructorDeclaration(node)) return;
+		if (typescriptBinding.isFunctionDeclaration(node) || typescriptBinding.isFunctionExpression(node) || typescriptBinding.isArrowFunction(node) || typescriptBinding.isMethodDeclaration(node) || typescriptBinding.isGetAccessorDeclaration(node) || typescriptBinding.isSetAccessorDeclaration(node) || typescriptBinding.isConstructorDeclaration(node)) return;
 		let nextShadowedNames = shadowedNames;
 		const shadowBindingNames = (bindingNames) => {
 			const newlyShadowedNames = bindingNames.flatMap((bindingName) => collectShadowedBindingNames(bindingName, topLevelVariableNames));
 			if (newlyShadowedNames.length > 0) nextShadowedNames = new Set([...nextShadowedNames, ...newlyShadowedNames]);
 		};
-		if (ts.isBlock(node)) shadowBindingNames(node.statements.flatMap((statement) => {
-			if (!ts.isVariableStatement(statement) || !(statement.declarationList.flags & ts.NodeFlags.BlockScoped)) return [];
+		if (typescriptBinding.isBlock(node)) shadowBindingNames(node.statements.flatMap((statement) => {
+			if (!typescriptBinding.isVariableStatement(statement) || !(statement.declarationList.flags & typescriptBinding.NodeFlags.BlockScoped)) return [];
 			return statement.declarationList.declarations.map((declaration) => declaration.name);
 		}));
-		if (ts.isCatchClause(node) && node.variableDeclaration) shadowBindingNames([node.variableDeclaration.name]);
-		if (ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node)) {
+		if (typescriptBinding.isCatchClause(node) && node.variableDeclaration) shadowBindingNames([node.variableDeclaration.name]);
+		if (typescriptBinding.isForStatement(node) || typescriptBinding.isForInStatement(node) || typescriptBinding.isForOfStatement(node)) {
 			const initializer = node.initializer;
-			if (initializer && ts.isVariableDeclarationList(initializer) && initializer.flags & ts.NodeFlags.BlockScoped) shadowBindingNames(initializer.declarations.map((declaration) => declaration.name));
+			if (initializer && typescriptBinding.isVariableDeclarationList(initializer) && initializer.flags & typescriptBinding.NodeFlags.BlockScoped) shadowBindingNames(initializer.declarations.map((declaration) => declaration.name));
 		}
-		if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "push" && ts.isIdentifier(node.expression.expression) && topLevelVariableNames.has(node.expression.expression.text) && !nextShadowedNames.has(node.expression.expression.text)) {
+		if (typescriptBinding.isCallExpression(node) && typescriptBinding.isPropertyAccessExpression(node.expression) && node.expression.name.text === "push" && typescriptBinding.isIdentifier(node.expression.expression) && topLevelVariableNames.has(node.expression.expression.text) && !nextShadowedNames.has(node.expression.expression.text)) {
 			const identifier = node.expression.expression.text;
 			const existingElements = pushedElements.get(identifier) ?? [];
 			existingElements.push(...node.arguments);
 			pushedElements.set(identifier, existingElements);
 		}
-		ts.forEachChild(node, (childNode) => visitNode(childNode, nextShadowedNames));
+		typescriptBinding.forEachChild(node, (childNode) => visitNode(childNode, nextShadowedNames));
 	};
 	visitNode(sourceFile, /* @__PURE__ */ new Set());
 	return pushedElements;
 };
 const extractConfigObject = (sourceFile, variableInitializers) => {
 	for (const statement of sourceFile.statements) {
-		if (!ts.isExportAssignment(statement) || statement.isExportEquals) continue;
+		if (!typescriptBinding.isExportAssignment(statement) || statement.isExportEquals) continue;
 		let expression = unwrapConfigExpression(statement.expression);
 		const visitedIdentifiers = /* @__PURE__ */ new Set();
-		while (ts.isIdentifier(expression) && !visitedIdentifiers.has(expression.text)) {
+		while (typescriptBinding.isIdentifier(expression) && !visitedIdentifiers.has(expression.text)) {
 			visitedIdentifiers.add(expression.text);
 			const initializer = variableInitializers.get(expression.text);
 			if (!initializer) break;
 			expression = unwrapConfigExpression(initializer);
 		}
-		if (ts.isObjectLiteralExpression(expression)) return expression;
+		if (typescriptBinding.isObjectLiteralExpression(expression)) return expression;
 	}
 };
 const extractTaroPageEntries = (directory, dependencies) => {
@@ -39209,7 +39205,7 @@ const extractTaroPageEntries = (directory, dependencies) => {
 	});
 	for (const configPath of configPaths) try {
 		const sourceText = readFileSync(configPath, "utf8");
-		const sourceFile = ts.createSourceFile(configPath, sourceText, ts.ScriptTarget.Latest, true);
+		const sourceFile = typescriptBinding.createSourceFile(configPath, sourceText, typescriptBinding.ScriptTarget.Latest, true);
 		const variableInitializers = collectVariableInitializers(sourceFile);
 		const pushedElements = collectPushedElements(sourceFile, new Set(variableInitializers.keys()));
 		const configObject = extractConfigObject(sourceFile, variableInitializers);
@@ -39680,20 +39676,20 @@ const extractJestModuleNameMapperAliases = (content, configDirectory) => {
 const extractWebpackModuleDirectories = (content, configDirectory) => {
 	const moduleDirectories = [];
 	const moduleDirectoryNames = [];
-	const sourceFile = ts.createSourceFile("webpack.config.ts", content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const sourceFile = typescriptBinding.createSourceFile("webpack.config.ts", content, typescriptBinding.ScriptTarget.Latest, true, typescriptBinding.ScriptKind.TS);
 	const variableInitializers = /* @__PURE__ */ new Map();
 	for (const statement of sourceFile.statements) {
-		if (!ts.isVariableStatement(statement)) continue;
-		for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.initializer) variableInitializers.set(declaration.name.text, declaration.initializer);
+		if (!typescriptBinding.isVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) if (typescriptBinding.isIdentifier(declaration.name) && declaration.initializer) variableInitializers.set(declaration.name.text, declaration.initializer);
 	}
 	const unwrapExpression = (expression) => {
-		if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isSatisfiesExpression(expression)) return unwrapExpression(expression.expression);
+		if (typescriptBinding.isParenthesizedExpression(expression) || typescriptBinding.isAsExpression(expression) || typescriptBinding.isSatisfiesExpression(expression)) return unwrapExpression(expression.expression);
 		return expression;
 	};
 	const resolveObjectExpression = (expression, visitedIdentifiers = /* @__PURE__ */ new Set()) => {
 		const unwrappedExpression = unwrapExpression(expression);
-		if (ts.isObjectLiteralExpression(unwrappedExpression)) return unwrappedExpression;
-		if (ts.isIdentifier(unwrappedExpression) && !visitedIdentifiers.has(unwrappedExpression.text)) {
+		if (typescriptBinding.isObjectLiteralExpression(unwrappedExpression)) return unwrappedExpression;
+		if (typescriptBinding.isIdentifier(unwrappedExpression) && !visitedIdentifiers.has(unwrappedExpression.text)) {
 			const initializer = variableInitializers.get(unwrappedExpression.text);
 			if (!initializer) return void 0;
 			return resolveObjectExpression(initializer, new Set(visitedIdentifiers).add(unwrappedExpression.text));
@@ -39701,82 +39697,82 @@ const extractWebpackModuleDirectories = (content, configDirectory) => {
 	};
 	const collectModules = (resolveObject) => {
 		for (const property of resolveObject.properties) {
-			if (!ts.isPropertyAssignment(property)) continue;
-			const propertyName = ts.isIdentifier(property.name) || ts.isStringLiteral(property.name) ? property.name.text : void 0;
+			if (!typescriptBinding.isPropertyAssignment(property)) continue;
+			const propertyName = typescriptBinding.isIdentifier(property.name) || typescriptBinding.isStringLiteral(property.name) ? property.name.text : void 0;
 			if (propertyName !== "modules" && propertyName !== "modulesDirectories") continue;
-			if (!ts.isArrayLiteralExpression(property.initializer)) continue;
+			if (!typescriptBinding.isArrayLiteralExpression(property.initializer)) continue;
 			for (const element of property.initializer.elements) {
-				if (ts.isStringLiteral(element) || ts.isNoSubstitutionTemplateLiteral(element)) {
+				if (typescriptBinding.isStringLiteral(element) || typescriptBinding.isNoSubstitutionTemplateLiteral(element)) {
 					if (element.text === "node_modules") continue;
 					if (element.text.startsWith(".") || element.text.includes("/")) moduleDirectories.push(resolveConfigPathValue(element.text, configDirectory));
 					else moduleDirectoryNames.push(element.text);
 					continue;
 				}
-				if (!ts.isCallExpression(element)) continue;
+				if (!typescriptBinding.isCallExpression(element)) continue;
 				const calledExpression = element.expression;
-				if (!ts.isPropertyAccessExpression(calledExpression) || !ts.isIdentifier(calledExpression.expression) || calledExpression.expression.text !== "path" || calledExpression.name.text !== "resolve" && calledExpression.name.text !== "join") continue;
-				const pathSegments = element.arguments.slice(1).flatMap((argument) => ts.isStringLiteral(argument) || ts.isNoSubstitutionTemplateLiteral(argument) ? [argument.text] : []);
+				if (!typescriptBinding.isPropertyAccessExpression(calledExpression) || !typescriptBinding.isIdentifier(calledExpression.expression) || calledExpression.expression.text !== "path" || calledExpression.name.text !== "resolve" && calledExpression.name.text !== "join") continue;
+				const pathSegments = element.arguments.slice(1).flatMap((argument) => typescriptBinding.isStringLiteral(argument) || typescriptBinding.isNoSubstitutionTemplateLiteral(argument) ? [argument.text] : []);
 				if (pathSegments.length > 0) moduleDirectories.push(resolve(configDirectory, ...pathSegments));
 			}
 		}
 	};
 	const collectConfigExpression = (expression, visitedIdentifiers = /* @__PURE__ */ new Set()) => {
 		const unwrappedExpression = unwrapExpression(expression);
-		if (ts.isBinaryExpression(unwrappedExpression) && unwrappedExpression.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+		if (typescriptBinding.isBinaryExpression(unwrappedExpression) && unwrappedExpression.operatorToken.kind === typescriptBinding.SyntaxKind.EqualsToken) {
 			collectConfigExpression(unwrappedExpression.right, visitedIdentifiers);
 			return;
 		}
-		if (ts.isIdentifier(unwrappedExpression)) {
+		if (typescriptBinding.isIdentifier(unwrappedExpression)) {
 			if (visitedIdentifiers.has(unwrappedExpression.text)) return;
 			const initializer = variableInitializers.get(unwrappedExpression.text);
 			if (!initializer) return;
 			collectConfigExpression(initializer, new Set(visitedIdentifiers).add(unwrappedExpression.text));
 			return;
 		}
-		if (ts.isArrayLiteralExpression(unwrappedExpression)) {
-			for (const element of unwrappedExpression.elements) if (ts.isSpreadElement(element)) collectConfigExpression(element.expression, visitedIdentifiers);
+		if (typescriptBinding.isArrayLiteralExpression(unwrappedExpression)) {
+			for (const element of unwrappedExpression.elements) if (typescriptBinding.isSpreadElement(element)) collectConfigExpression(element.expression, visitedIdentifiers);
 			else collectConfigExpression(element, visitedIdentifiers);
 			return;
 		}
-		if (ts.isConditionalExpression(unwrappedExpression)) {
+		if (typescriptBinding.isConditionalExpression(unwrappedExpression)) {
 			collectConfigExpression(unwrappedExpression.whenTrue, visitedIdentifiers);
 			collectConfigExpression(unwrappedExpression.whenFalse, visitedIdentifiers);
 			return;
 		}
-		if (ts.isArrowFunction(unwrappedExpression) || ts.isFunctionExpression(unwrappedExpression)) {
-			if (!ts.isBlock(unwrappedExpression.body)) {
+		if (typescriptBinding.isArrowFunction(unwrappedExpression) || typescriptBinding.isFunctionExpression(unwrappedExpression)) {
+			if (!typescriptBinding.isBlock(unwrappedExpression.body)) {
 				collectConfigExpression(unwrappedExpression.body, visitedIdentifiers);
 				return;
 			}
-			for (const statement of unwrappedExpression.body.statements) if (ts.isReturnStatement(statement) && statement.expression) collectConfigExpression(statement.expression, visitedIdentifiers);
+			for (const statement of unwrappedExpression.body.statements) if (typescriptBinding.isReturnStatement(statement) && statement.expression) collectConfigExpression(statement.expression, visitedIdentifiers);
 			return;
 		}
-		if (!ts.isObjectLiteralExpression(unwrappedExpression)) return;
+		if (!typescriptBinding.isObjectLiteralExpression(unwrappedExpression)) return;
 		for (const property of unwrappedExpression.properties) {
-			if (ts.isSpreadAssignment(property)) {
+			if (typescriptBinding.isSpreadAssignment(property)) {
 				collectConfigExpression(property.expression, visitedIdentifiers);
 				continue;
 			}
-			if (ts.isShorthandPropertyAssignment(property) && property.name.text === "resolve") {
+			if (typescriptBinding.isShorthandPropertyAssignment(property) && property.name.text === "resolve") {
 				const resolveObject = resolveObjectExpression(property.name);
 				if (resolveObject) collectModules(resolveObject);
 				continue;
 			}
-			if (!ts.isPropertyAssignment(property)) continue;
-			if ((ts.isIdentifier(property.name) || ts.isStringLiteral(property.name) ? property.name.text : void 0) !== "resolve") continue;
+			if (!typescriptBinding.isPropertyAssignment(property)) continue;
+			if ((typescriptBinding.isIdentifier(property.name) || typescriptBinding.isStringLiteral(property.name) ? property.name.text : void 0) !== "resolve") continue;
 			const resolveObject = resolveObjectExpression(property.initializer);
 			if (resolveObject) collectModules(resolveObject);
 		}
 	};
-	const isModuleExports = (expression) => ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "module" && expression.name.text === "exports";
+	const isModuleExports = (expression) => typescriptBinding.isPropertyAccessExpression(expression) && typescriptBinding.isIdentifier(expression.expression) && expression.expression.text === "module" && expression.name.text === "exports";
 	const collectModuleExportsAssignment = (expression) => {
-		if (ts.isBinaryExpression(expression) && expression.operatorToken.kind === ts.SyntaxKind.EqualsToken) if (isModuleExports(expression.left)) collectConfigExpression(expression.right);
+		if (typescriptBinding.isBinaryExpression(expression) && expression.operatorToken.kind === typescriptBinding.SyntaxKind.EqualsToken) if (isModuleExports(expression.left)) collectConfigExpression(expression.right);
 		else collectModuleExportsAssignment(expression.right);
 	};
 	for (const statement of sourceFile.statements) {
-		if (ts.isExportAssignment(statement) && !statement.isExportEquals) collectConfigExpression(statement.expression);
-		if (ts.isExpressionStatement(statement)) collectModuleExportsAssignment(statement.expression);
-		if (ts.isVariableStatement(statement)) {
+		if (typescriptBinding.isExportAssignment(statement) && !statement.isExportEquals) collectConfigExpression(statement.expression);
+		if (typescriptBinding.isExpressionStatement(statement)) collectModuleExportsAssignment(statement.expression);
+		if (typescriptBinding.isVariableStatement(statement)) {
 			for (const declaration of statement.declarationList.declarations) if (declaration.initializer) collectModuleExportsAssignment(declaration.initializer);
 		}
 	}
@@ -40540,20 +40536,20 @@ const extractImportSpecifiers = (sourceText) => {
 };
 const extractStylelintPluginSpecifiers = (sourceText) => {
 	const specifiers = [];
-	const sourceFile = ts.createSourceFile("stylelint.config.mjs", sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const sourceFile = typescriptBinding.createSourceFile("stylelint.config.mjs", sourceText, typescriptBinding.ScriptTarget.Latest, true, typescriptBinding.ScriptKind.TS);
 	const collectStringLiterals = (node) => {
-		if (ts.isStringLiteralLike(node)) {
+		if (typescriptBinding.isStringLiteralLike(node)) {
 			specifiers.push(node.text);
 			return;
 		}
-		ts.forEachChild(node, collectStringLiterals);
+		typescriptBinding.forEachChild(node, collectStringLiterals);
 	};
 	const visitNode = (node) => {
-		if (ts.isPropertyAssignment(node) && (ts.isIdentifier(node.name) || ts.isStringLiteralLike(node.name)) && node.name.text === "plugins") {
+		if (typescriptBinding.isPropertyAssignment(node) && (typescriptBinding.isIdentifier(node.name) || typescriptBinding.isStringLiteralLike(node.name)) && node.name.text === "plugins") {
 			collectStringLiterals(node.initializer);
 			return;
 		}
-		ts.forEachChild(node, visitNode);
+		typescriptBinding.forEachChild(node, visitNode);
 	};
 	visitNode(sourceFile);
 	return specifiers;
@@ -41012,17 +41008,17 @@ const isPathInsideDirectoryOrEqual = (candidatePath, directoryPath) => {
 //#region ../core/src/project-analysis/collect/static-globby-entries.ts
 const getCalledName = (expression) => {
 	const unwrappedExpression = unwrapTypescriptExpression(expression);
-	if (ts.isIdentifier(unwrappedExpression)) return unwrappedExpression.text;
-	if (ts.isPropertyAccessExpression(unwrappedExpression)) return unwrappedExpression.name.text;
+	if (typescriptBinding.isIdentifier(unwrappedExpression)) return unwrappedExpression.text;
+	if (typescriptBinding.isPropertyAccessExpression(unwrappedExpression)) return unwrappedExpression.name.text;
 };
 const isImportMetaUrl = (expression) => {
 	const unwrappedExpression = unwrapTypescriptExpression(expression);
-	return ts.isPropertyAccessExpression(unwrappedExpression) && unwrappedExpression.name.text === "url" && ts.isMetaProperty(unwrappedExpression.expression) && unwrappedExpression.expression.keywordToken === ts.SyntaxKind.ImportKeyword;
+	return typescriptBinding.isPropertyAccessExpression(unwrappedExpression) && unwrappedExpression.name.text === "url" && typescriptBinding.isMetaProperty(unwrappedExpression.expression) && unwrappedExpression.expression.keywordToken === typescriptBinding.SyntaxKind.ImportKeyword;
 };
 const evaluateDirectoryExpression = (expression, context, seenIdentifiers = /* @__PURE__ */ new Set()) => {
 	const unwrappedExpression = unwrapTypescriptExpression(expression);
-	if (ts.isStringLiteralLike(unwrappedExpression)) return resolve(dirname(context.entryFilePath), unwrappedExpression.text);
-	if (ts.isIdentifier(unwrappedExpression)) {
+	if (typescriptBinding.isStringLiteralLike(unwrappedExpression)) return resolve(dirname(context.entryFilePath), unwrappedExpression.text);
+	if (typescriptBinding.isIdentifier(unwrappedExpression)) {
 		if (unwrappedExpression.text === "__dirname") return dirname(context.entryFilePath);
 		if (seenIdentifiers.has(unwrappedExpression.text)) return void 0;
 		const initializer = context.variableDeclarations.get(unwrappedExpression.text);
@@ -41031,10 +41027,10 @@ const evaluateDirectoryExpression = (expression, context, seenIdentifiers = /* @
 		nextSeenIdentifiers.add(unwrappedExpression.text);
 		return evaluateDirectoryExpression(initializer, context, nextSeenIdentifiers);
 	}
-	if (ts.isPropertyAccessExpression(unwrappedExpression) && unwrappedExpression.name.text === "dirname" && ts.isMetaProperty(unwrappedExpression.expression) && unwrappedExpression.expression.keywordToken === ts.SyntaxKind.ImportKeyword) return dirname(context.entryFilePath);
-	if (!ts.isCallExpression(unwrappedExpression)) return void 0;
+	if (typescriptBinding.isPropertyAccessExpression(unwrappedExpression) && unwrappedExpression.name.text === "dirname" && typescriptBinding.isMetaProperty(unwrappedExpression.expression) && unwrappedExpression.expression.keywordToken === typescriptBinding.SyntaxKind.ImportKeyword) return dirname(context.entryFilePath);
+	if (!typescriptBinding.isCallExpression(unwrappedExpression)) return void 0;
 	const calledName = getCalledName(unwrappedExpression.expression);
-	if (calledName === "cwd" && ts.isPropertyAccessExpression(unwrappedExpression.expression) && ts.isIdentifier(unwrappedExpression.expression.expression) && unwrappedExpression.expression.expression.text === "process") return context.projectRoot;
+	if (calledName === "cwd" && typescriptBinding.isPropertyAccessExpression(unwrappedExpression.expression) && typescriptBinding.isIdentifier(unwrappedExpression.expression.expression) && unwrappedExpression.expression.expression.text === "process") return context.projectRoot;
 	if (calledName === "fileURLToPath" && unwrappedExpression.arguments[0] && isImportMetaUrl(unwrappedExpression.arguments[0])) return context.entryFilePath;
 	if (calledName === "dirname" && unwrappedExpression.arguments[0]) {
 		const evaluatedPath = evaluateDirectoryExpression(unwrappedExpression.arguments[0], context, seenIdentifiers);
@@ -41048,19 +41044,19 @@ const evaluateDirectoryExpression = (expression, context, seenIdentifiers = /* @
 	const pathSegments = [];
 	for (const segmentExpression of segmentExpressions) {
 		const unwrappedSegment = unwrapTypescriptExpression(segmentExpression);
-		if (!ts.isStringLiteralLike(unwrappedSegment)) return void 0;
+		if (!typescriptBinding.isStringLiteralLike(unwrappedSegment)) return void 0;
 		pathSegments.push(unwrappedSegment.text);
 	}
 	return calledName === "join" ? join(baseDirectory, ...pathSegments) : resolve(baseDirectory, ...pathSegments);
 };
 const collectStaticPatterns = (expression) => {
 	const unwrappedExpression = unwrapTypescriptExpression(expression);
-	if (ts.isStringLiteralLike(unwrappedExpression)) return [unwrappedExpression.text];
-	if (!ts.isArrayLiteralExpression(unwrappedExpression)) return [];
+	if (typescriptBinding.isStringLiteralLike(unwrappedExpression)) return [unwrappedExpression.text];
+	if (!typescriptBinding.isArrayLiteralExpression(unwrappedExpression)) return [];
 	const patterns = [];
 	for (const element of unwrappedExpression.elements) {
 		const unwrappedElement = unwrapTypescriptExpression(element);
-		if (!ts.isStringLiteralLike(unwrappedElement)) return [];
+		if (!typescriptBinding.isStringLiteralLike(unwrappedElement)) return [];
 		patterns.push(unwrappedElement.text);
 	}
 	return patterns;
@@ -41068,16 +41064,16 @@ const collectStaticPatterns = (expression) => {
 const findCwdExpression = (expression) => {
 	if (!expression) return void 0;
 	const unwrappedExpression = unwrapTypescriptExpression(expression);
-	if (!ts.isObjectLiteralExpression(unwrappedExpression)) return void 0;
+	if (!typescriptBinding.isObjectLiteralExpression(unwrappedExpression)) return void 0;
 	for (const property of unwrappedExpression.properties) {
-		if (!ts.isPropertyAssignment(property)) continue;
-		if ((ts.isIdentifier(property.name) || ts.isStringLiteralLike(property.name) ? property.name.text : void 0) === "cwd") return property.initializer;
+		if (!typescriptBinding.isPropertyAssignment(property)) continue;
+		if ((typescriptBinding.isIdentifier(property.name) || typescriptBinding.isStringLiteralLike(property.name) ? property.name.text : void 0) === "cwd") return property.initializer;
 	}
 };
 const collectGlobbyLocalNames = (sourceFile) => {
 	const localNames = /* @__PURE__ */ new Set();
 	for (const statement of sourceFile.statements) {
-		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "globby" || !statement.importClause?.namedBindings || !ts.isNamedImports(statement.importClause.namedBindings)) continue;
+		if (!typescriptBinding.isImportDeclaration(statement) || !typescriptBinding.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "globby" || !statement.importClause?.namedBindings || !typescriptBinding.isNamedImports(statement.importClause.namedBindings)) continue;
 		for (const element of statement.importClause.namedBindings.elements) {
 			const importedName = element.propertyName?.text ?? element.name.text;
 			if (importedName === "globby" || importedName === "globbySync") localNames.add(element.name.text);
@@ -41088,8 +41084,8 @@ const collectGlobbyLocalNames = (sourceFile) => {
 const collectVariableDeclarations = (sourceFile) => {
 	const declarations = /* @__PURE__ */ new Map();
 	const visitNode = (node) => {
-		if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) declarations.set(node.name.text, node.initializer);
-		ts.forEachChild(node, visitNode);
+		if (typescriptBinding.isVariableDeclaration(node) && typescriptBinding.isIdentifier(node.name) && node.initializer) declarations.set(node.name.text, node.initializer);
+		typescriptBinding.forEachChild(node, visitNode);
 	};
 	visitNode(sourceFile);
 	return declarations;
@@ -41103,7 +41099,7 @@ const extractGlobbyEntriesFromFile = (entryFilePath, projectRoot) => {
 		return [];
 	}
 	if (!sourceText.includes("globby")) return [];
-	const sourceFile = ts.createSourceFile(entryFilePath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+	const sourceFile = typescriptBinding.createSourceFile(entryFilePath, sourceText, typescriptBinding.ScriptTarget.Latest, true, typescriptBinding.ScriptKind.TSX);
 	const globbyLocalNames = collectGlobbyLocalNames(sourceFile);
 	if (globbyLocalNames.size === 0) return [];
 	const context = {
@@ -41114,7 +41110,7 @@ const extractGlobbyEntriesFromFile = (entryFilePath, projectRoot) => {
 	};
 	const entries = /* @__PURE__ */ new Set();
 	const visitNode = (node) => {
-		if (ts.isCallExpression(node) && ts.isIdentifier(unwrapTypescriptExpression(node.expression)) && globbyLocalNames.has(unwrapTypescriptExpression(node.expression).getText()) && node.arguments[0]) {
+		if (typescriptBinding.isCallExpression(node) && typescriptBinding.isIdentifier(unwrapTypescriptExpression(node.expression)) && globbyLocalNames.has(unwrapTypescriptExpression(node.expression).getText()) && node.arguments[0]) {
 			const patterns = collectStaticPatterns(node.arguments[0]);
 			const cwdExpression = findCwdExpression(node.arguments[1]);
 			const workingDirectory = cwdExpression ? evaluateDirectoryExpression(cwdExpression, context) : dirname(entryFilePath);
@@ -41127,7 +41123,7 @@ const extractGlobbyEntriesFromFile = (entryFilePath, projectRoot) => {
 				})) if (isPathInsideDirectoryOrEqual(filePath, projectRoot) && DEFAULT_EXTENSIONS.some((extension) => filePath.endsWith(extension))) entries.add(filePath);
 			}
 		}
-		ts.forEachChild(node, visitNode);
+		typescriptBinding.forEachChild(node, visitNode);
 	};
 	visitNode(sourceFile);
 	return [...entries];
@@ -41635,7 +41631,7 @@ const extractReactEmailTemplateEntries = (directory) => {
 //#endregion
 //#region ../core/src/project-analysis/utils/parse-typescript-config.ts
 const parseTypeScriptConfig = (configPath, source) => {
-	const parsedConfig = ts.parseConfigFileTextToJson(configPath, source);
+	const parsedConfig = typescriptBinding.parseConfigFileTextToJson(configPath, source);
 	return parsedConfig.error ? void 0 : parsedConfig.config;
 };
 //#endregion
@@ -42693,9 +42689,9 @@ const collectWebpackConfigModules = (configPath) => {
 		if (visitedModulePaths.has(modulePath)) continue;
 		visitedModulePaths.add(modulePath);
 		configModulePaths.push(modulePath);
-		const sourceFile = ts.createSourceFile(modulePath, readFileSync(modulePath, "utf-8"), ts.ScriptTarget.Latest, true);
+		const sourceFile = typescriptBinding.createSourceFile(modulePath, readFileSync(modulePath, "utf-8"), typescriptBinding.ScriptTarget.Latest, true);
 		for (const statement of sourceFile.statements) {
-			if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+			if (!typescriptBinding.isImportDeclaration(statement) || !typescriptBinding.isStringLiteral(statement.moduleSpecifier)) continue;
 			const specifier = statement.moduleSpecifier.text;
 			if (!specifier.startsWith(".")) continue;
 			const importedModulePath = resolveEntryWithExtensions(resolve(dirname(modulePath), specifier));
@@ -42708,7 +42704,7 @@ const extractComputedWebpackEntries = (configPath, projectDirectory) => {
 	const entries = [];
 	for (const modulePath of collectWebpackConfigModules(configPath)) {
 		const sourceText = readFileSync(modulePath, "utf-8");
-		const sourceFile = ts.createSourceFile(modulePath, sourceText, ts.ScriptTarget.Latest, true);
+		const sourceFile = typescriptBinding.createSourceFile(modulePath, sourceText, typescriptBinding.ScriptTarget.Latest, true);
 		const program = parseOxcProgram(modulePath, sourceText);
 		if (program) visitOxcAstWithBindings(program, (node, bindingNames) => {
 			if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") return false;
@@ -42720,30 +42716,30 @@ const extractComputedWebpackEntries = (configPath, projectDirectory) => {
 		});
 		const objectInitializers = /* @__PURE__ */ new Map();
 		for (const statement of sourceFile.statements) {
-			if (!ts.isVariableStatement(statement)) continue;
-			for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.initializer && ts.isObjectLiteralExpression(declaration.initializer)) objectInitializers.set(declaration.name.text, declaration.initializer);
+			if (!typescriptBinding.isVariableStatement(statement)) continue;
+			for (const declaration of statement.declarationList.declarations) if (typescriptBinding.isIdentifier(declaration.name) && declaration.initializer && typescriptBinding.isObjectLiteralExpression(declaration.initializer)) objectInitializers.set(declaration.name.text, declaration.initializer);
 		}
 		const exportedObjects = sourceFile.statements.flatMap((statement) => {
 			let exportedExpression;
-			if (ts.isExportAssignment(statement)) exportedExpression = statement.expression;
-			else if (ts.isExpressionStatement(statement) && ts.isBinaryExpression(statement.expression) && statement.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(statement.expression.left) && ts.isIdentifier(statement.expression.left.expression) && statement.expression.left.expression.text === "module" && statement.expression.left.name.text === "exports") exportedExpression = statement.expression.right;
+			if (typescriptBinding.isExportAssignment(statement)) exportedExpression = statement.expression;
+			else if (typescriptBinding.isExpressionStatement(statement) && typescriptBinding.isBinaryExpression(statement.expression) && statement.expression.operatorToken.kind === typescriptBinding.SyntaxKind.EqualsToken && typescriptBinding.isPropertyAccessExpression(statement.expression.left) && typescriptBinding.isIdentifier(statement.expression.left.expression) && statement.expression.left.expression.text === "module" && statement.expression.left.name.text === "exports") exportedExpression = statement.expression.right;
 			if (!exportedExpression) return [];
-			if (ts.isObjectLiteralExpression(exportedExpression)) return [exportedExpression];
-			if (ts.isIdentifier(exportedExpression)) {
+			if (typescriptBinding.isObjectLiteralExpression(exportedExpression)) return [exportedExpression];
+			if (typescriptBinding.isIdentifier(exportedExpression)) {
 				const objectInitializer = objectInitializers.get(exportedExpression.text);
 				return objectInitializer ? [objectInitializer] : [];
 			}
 			return [];
 		});
 		for (const exportedObject of exportedObjects) {
-			const entryProperty = exportedObject.properties.find((property) => ts.isPropertyAssignment(property) && (ts.isIdentifier(property.name) && property.name.text === "entry" || ts.isStringLiteral(property.name) && property.name.text === "entry"));
+			const entryProperty = exportedObject.properties.find((property) => typescriptBinding.isPropertyAssignment(property) && (typescriptBinding.isIdentifier(property.name) && property.name.text === "entry" || typescriptBinding.isStringLiteral(property.name) && property.name.text === "entry"));
 			const pathSegments = [];
-			if (entryProperty && ts.isCallExpression(entryProperty.initializer)) {
-				for (const argument of entryProperty.initializer.arguments) if (ts.isStringLiteral(argument) || ts.isNoSubstitutionTemplateLiteral(argument)) pathSegments.push(argument.text);
+			if (entryProperty && typescriptBinding.isCallExpression(entryProperty.initializer)) {
+				for (const argument of entryProperty.initializer.arguments) if (typescriptBinding.isStringLiteral(argument) || typescriptBinding.isNoSubstitutionTemplateLiteral(argument)) pathSegments.push(argument.text);
 			}
-			const entryCallExpression = entryProperty && ts.isCallExpression(entryProperty.initializer) ? entryProperty.initializer : void 0;
-			const entryPathObjectName = entryCallExpression && ts.isPropertyAccessExpression(entryCallExpression.expression) && ts.isIdentifier(entryCallExpression.expression.expression) ? entryCallExpression.expression.expression.text : void 0;
-			const entryPathMethodName = entryCallExpression && ts.isPropertyAccessExpression(entryCallExpression.expression) ? entryCallExpression.expression.name.text : void 0;
+			const entryCallExpression = entryProperty && typescriptBinding.isCallExpression(entryProperty.initializer) ? entryProperty.initializer : void 0;
+			const entryPathObjectName = entryCallExpression && typescriptBinding.isPropertyAccessExpression(entryCallExpression.expression) && typescriptBinding.isIdentifier(entryCallExpression.expression.expression) ? entryCallExpression.expression.expression.text : void 0;
+			const entryPathMethodName = entryCallExpression && typescriptBinding.isPropertyAccessExpression(entryCallExpression.expression) ? entryCallExpression.expression.name.text : void 0;
 			if (!entryProperty || !entryCallExpression || !entryPathObjectName || !entryPathMethodName || !/path/i.test(entryPathObjectName) || pathSegments.length !== entryCallExpression.arguments.length) continue;
 			const candidatePaths = entryPathObjectName === "path" && (entryPathMethodName === "join" || entryPathMethodName === "resolve") ? [resolve(dirname(modulePath), ...pathSegments)] : [resolve(projectDirectory, entryPathMethodName, ...pathSegments), resolve(projectDirectory, "src", entryPathMethodName, ...pathSegments)];
 			for (const candidatePath of candidatePaths) {
@@ -44538,20 +44534,8 @@ const isConfigFile = (filePath) => {
 	return KNOWN_CONFIG_PREFIXES.some((prefix) => fileName.startsWith(prefix));
 };
 //#endregion
-//#region ../core/src/project-info/constants.ts
-var import_picomatch = /* @__PURE__ */ __toESM(require_picomatch$2(), 1);
-const GIT_CHECK_ATTR_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
-new Map(Object.entries({
-	Security: "An attacker can read user data, act as your users, or run code you never shipped.",
-	Bugs: "Real users hit crashes, wrong output, or state that silently corrupts.",
-	Performance: "Users feel extra latency and wasted renders on every interaction.",
-	Accessibility: "Users on screen readers, keyboards, or assistive tech get locked out.",
-	Maintainability: "Every future change gets slower and riskier to make."
-}));
-const MAX_GLOB_PATTERN_LENGTH_CHARS = 1024;
-process.env.REACT_DOCTOR_CORE_VERSION;
-//#endregion
 //#region ../core/src/utils/message-from-unknown.ts
+var import_picomatch = /* @__PURE__ */ __toESM(require_picomatch$2(), 1);
 const messageFromUnknown = (error) => error instanceof Error ? error.message : String(error);
 //#endregion
 //#region ../core/src/utils/match-glob-pattern.ts
@@ -45449,18 +45433,18 @@ const collectDynamicBuildImports = (sourceFile, typeChecker) => {
 	const globNamespaceSymbols = /* @__PURE__ */ new Set();
 	const pathNamespaceSymbols = /* @__PURE__ */ new Set();
 	for (const statement of sourceFile.statements) {
-		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || !statement.importClause) continue;
+		if (!typescriptBinding.isImportDeclaration(statement) || !typescriptBinding.isStringLiteral(statement.moduleSpecifier) || !statement.importClause) continue;
 		const moduleName = statement.moduleSpecifier.text;
 		const namedBindings = statement.importClause.namedBindings;
-		if (moduleName === "glob" && namedBindings && ts.isNamespaceImport(namedBindings)) {
+		if (moduleName === "glob" && namedBindings && typescriptBinding.isNamespaceImport(namedBindings)) {
 			const globNamespaceSymbol = typeChecker.getSymbolAtLocation(namedBindings.name);
 			if (globNamespaceSymbol) globNamespaceSymbols.add(globNamespaceSymbol);
 		}
-		if (moduleName === "path" && namedBindings && ts.isNamespaceImport(namedBindings)) {
+		if (moduleName === "path" && namedBindings && typescriptBinding.isNamespaceImport(namedBindings)) {
 			const pathNamespaceSymbol = typeChecker.getSymbolAtLocation(namedBindings.name);
 			if (pathNamespaceSymbol) pathNamespaceSymbols.add(pathNamespaceSymbol);
 		}
-		if (moduleName !== "tsup" || !namedBindings || !ts.isNamedImports(namedBindings)) continue;
+		if (moduleName !== "tsup" || !namedBindings || !typescriptBinding.isNamedImports(namedBindings)) continue;
 		for (const importSpecifier of namedBindings.elements) if ((importSpecifier.propertyName ?? importSpecifier.name).text === "build") {
 			const buildSymbol = typeChecker.getSymbolAtLocation(importSpecifier.name);
 			if (buildSymbol) buildSymbols.add(buildSymbol);
@@ -45473,18 +45457,18 @@ const collectDynamicBuildImports = (sourceFile, typeChecker) => {
 	};
 };
 const extractGlobPattern = (expression, imports, scriptDirectory, typeChecker) => {
-	if (!ts.isCallExpression(expression) || !ts.isPropertyAccessExpression(expression.expression) || expression.expression.name.text !== "sync" || !ts.isIdentifier(expression.expression.expression) || !hasMatchingSymbol(expression.expression.expression, imports.globNamespaceSymbols, typeChecker) || expression.arguments.length !== 1) return;
+	if (!typescriptBinding.isCallExpression(expression) || !typescriptBinding.isPropertyAccessExpression(expression.expression) || expression.expression.name.text !== "sync" || !typescriptBinding.isIdentifier(expression.expression.expression) || !hasMatchingSymbol(expression.expression.expression, imports.globNamespaceSymbols, typeChecker) || expression.arguments.length !== 1) return;
 	const patternExpression = expression.arguments[0];
-	if (!ts.isCallExpression(patternExpression) || !ts.isPropertyAccessExpression(patternExpression.expression) || patternExpression.expression.name.text !== "join" || !ts.isIdentifier(patternExpression.expression.expression) || !hasMatchingSymbol(patternExpression.expression.expression, imports.pathNamespaceSymbols, typeChecker) || patternExpression.arguments.length !== 2 || !ts.isIdentifier(patternExpression.arguments[0]) || patternExpression.arguments[0].text !== "__dirname" || !ts.isStringLiteral(patternExpression.arguments[1]) && !ts.isNoSubstitutionTemplateLiteral(patternExpression.arguments[1])) return;
+	if (!typescriptBinding.isCallExpression(patternExpression) || !typescriptBinding.isPropertyAccessExpression(patternExpression.expression) || patternExpression.expression.name.text !== "join" || !typescriptBinding.isIdentifier(patternExpression.expression.expression) || !hasMatchingSymbol(patternExpression.expression.expression, imports.pathNamespaceSymbols, typeChecker) || patternExpression.arguments.length !== 2 || !typescriptBinding.isIdentifier(patternExpression.arguments[0]) || patternExpression.arguments[0].text !== "__dirname" || !typescriptBinding.isStringLiteral(patternExpression.arguments[1]) && !typescriptBinding.isNoSubstitutionTemplateLiteral(patternExpression.arguments[1])) return;
 	const relativeGlobPattern = patternExpression.arguments[1].text;
 	if (!relativeGlobPattern.includes("*")) return void 0;
 	return toPosixPath(resolve(scriptDirectory, relativeGlobPattern));
 };
 const extractExcludedPathSubstring = (callback) => {
-	if (callback.parameters.length !== 1 || !ts.isIdentifier(callback.parameters[0].name)) return;
+	if (callback.parameters.length !== 1 || !typescriptBinding.isIdentifier(callback.parameters[0].name)) return;
 	const filePathName = callback.parameters[0].name.text;
-	const returnedExpression = ts.isBlock(callback.body) ? callback.body.statements.length === 1 && ts.isReturnStatement(callback.body.statements[0]) ? callback.body.statements[0].expression : void 0 : callback.body;
-	if (!returnedExpression || !ts.isPrefixUnaryExpression(returnedExpression) || returnedExpression.operator !== ts.SyntaxKind.ExclamationToken || !ts.isCallExpression(returnedExpression.operand) || !ts.isPropertyAccessExpression(returnedExpression.operand.expression) || returnedExpression.operand.expression.name.text !== "includes" || !ts.isIdentifier(returnedExpression.operand.expression.expression) || returnedExpression.operand.expression.expression.text !== filePathName || returnedExpression.operand.arguments.length !== 1 || !ts.isStringLiteral(returnedExpression.operand.arguments[0]) && !ts.isNoSubstitutionTemplateLiteral(returnedExpression.operand.arguments[0])) return;
+	const returnedExpression = typescriptBinding.isBlock(callback.body) ? callback.body.statements.length === 1 && typescriptBinding.isReturnStatement(callback.body.statements[0]) ? callback.body.statements[0].expression : void 0 : callback.body;
+	if (!returnedExpression || !typescriptBinding.isPrefixUnaryExpression(returnedExpression) || returnedExpression.operator !== typescriptBinding.SyntaxKind.ExclamationToken || !typescriptBinding.isCallExpression(returnedExpression.operand) || !typescriptBinding.isPropertyAccessExpression(returnedExpression.operand.expression) || returnedExpression.operand.expression.name.text !== "includes" || !typescriptBinding.isIdentifier(returnedExpression.operand.expression.expression) || returnedExpression.operand.expression.expression.text !== filePathName || returnedExpression.operand.arguments.length !== 1 || !typescriptBinding.isStringLiteral(returnedExpression.operand.arguments[0]) && !typescriptBinding.isNoSubstitutionTemplateLiteral(returnedExpression.operand.arguments[0])) return;
 	return toPosixPath(returnedExpression.operand.arguments[0].text);
 };
 const extractFileCollection = (initializer, imports, scriptDirectory, typeChecker) => {
@@ -45493,7 +45477,7 @@ const extractFileCollection = (initializer, imports, scriptDirectory, typeChecke
 		excludedPathSubstrings: [],
 		globPattern: directGlobPattern
 	};
-	if (!ts.isCallExpression(initializer) || !ts.isPropertyAccessExpression(initializer.expression) || initializer.expression.name.text !== "filter" || initializer.arguments.length !== 1 || !ts.isArrowFunction(initializer.arguments[0]) && !ts.isFunctionExpression(initializer.arguments[0])) return;
+	if (!typescriptBinding.isCallExpression(initializer) || !typescriptBinding.isPropertyAccessExpression(initializer.expression) || initializer.expression.name.text !== "filter" || initializer.arguments.length !== 1 || !typescriptBinding.isArrowFunction(initializer.arguments[0]) && !typescriptBinding.isFunctionExpression(initializer.arguments[0])) return;
 	const globPattern = extractGlobPattern(initializer.expression.expression, imports, scriptDirectory, typeChecker);
 	const excludedPathSubstring = extractExcludedPathSubstring(initializer.arguments[0]);
 	if (!globPattern || excludedPathSubstring === void 0) return void 0;
@@ -45502,36 +45486,36 @@ const extractFileCollection = (initializer, imports, scriptDirectory, typeChecke
 		globPattern
 	};
 };
-const isPathNamespaceCall = (expression, methodName, imports, typeChecker) => ts.isCallExpression(expression) && ts.isPropertyAccessExpression(expression.expression) && expression.expression.name.text === methodName && ts.isIdentifier(expression.expression.expression) && hasMatchingSymbol(expression.expression.expression, imports.pathNamespaceSymbols, typeChecker);
+const isPathNamespaceCall = (expression, methodName, imports, typeChecker) => typescriptBinding.isCallExpression(expression) && typescriptBinding.isPropertyAccessExpression(expression.expression) && expression.expression.name.text === methodName && typescriptBinding.isIdentifier(expression.expression.expression) && hasMatchingSymbol(expression.expression.expression, imports.pathNamespaceSymbols, typeChecker);
 const hasMatchingOutputEntryPath = (callback, filePathName, outputEntryName, imports, typeChecker) => {
-	if (!ts.isBlock(callback.body)) return false;
+	if (!typescriptBinding.isBlock(callback.body)) return false;
 	const initializersByName = /* @__PURE__ */ new Map();
 	for (const statement of callback.body.statements) {
-		if (!ts.isVariableStatement(statement)) continue;
-		for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.initializer) initializersByName.set(declaration.name.text, declaration.initializer);
+		if (!typescriptBinding.isVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) if (typescriptBinding.isIdentifier(declaration.name) && declaration.initializer) initializersByName.set(declaration.name.text, declaration.initializer);
 	}
 	const outputEntryInitializer = initializersByName.get(outputEntryName);
 	if (!outputEntryInitializer || !isPathNamespaceCall(outputEntryInitializer, "join", imports, typeChecker)) return false;
 	const outputFilenameExpression = outputEntryInitializer.arguments.at(-1);
-	if (!outputFilenameExpression || !ts.isBinaryExpression(outputFilenameExpression) || outputFilenameExpression.operatorToken.kind !== ts.SyntaxKind.PlusToken || !ts.isStringLiteralLike(outputFilenameExpression.right) || outputFilenameExpression.right.text !== ".js" || !isPathNamespaceCall(outputFilenameExpression.left, "basename", imports, typeChecker) || outputFilenameExpression.left.arguments.length !== 2 || !ts.isIdentifier(outputFilenameExpression.left.arguments[0]) || !ts.isStringLiteralLike(outputFilenameExpression.left.arguments[1]) || outputFilenameExpression.left.arguments[1].text !== ".tsx") return false;
+	if (!outputFilenameExpression || !typescriptBinding.isBinaryExpression(outputFilenameExpression) || outputFilenameExpression.operatorToken.kind !== typescriptBinding.SyntaxKind.PlusToken || !typescriptBinding.isStringLiteralLike(outputFilenameExpression.right) || outputFilenameExpression.right.text !== ".js" || !isPathNamespaceCall(outputFilenameExpression.left, "basename", imports, typeChecker) || outputFilenameExpression.left.arguments.length !== 2 || !typescriptBinding.isIdentifier(outputFilenameExpression.left.arguments[0]) || !typescriptBinding.isStringLiteralLike(outputFilenameExpression.left.arguments[1]) || outputFilenameExpression.left.arguments[1].text !== ".tsx") return false;
 	const basenameSourceName = outputFilenameExpression.left.arguments[0].text;
 	if (basenameSourceName === filePathName) return true;
 	const basenameSourceInitializer = initializersByName.get(basenameSourceName);
-	return Boolean(basenameSourceInitializer && isPathNamespaceCall(basenameSourceInitializer, "relative", imports, typeChecker) && basenameSourceInitializer.arguments.length === 2 && ts.isIdentifier(basenameSourceInitializer.arguments[1]) && basenameSourceInitializer.arguments[1].text === filePathName);
+	return Boolean(basenameSourceInitializer && isPathNamespaceCall(basenameSourceInitializer, "relative", imports, typeChecker) && basenameSourceInitializer.arguments.length === 2 && typescriptBinding.isIdentifier(basenameSourceInitializer.arguments[1]) && basenameSourceInitializer.arguments[1].text === filePathName);
 };
 const findBuildInvocation = (callback, filePathName, imports, typeChecker) => {
 	let buildInvocation;
 	const visitNode = (node) => {
-		if (ts.isCallExpression(node) && ts.isAwaitExpression(node.parent) && ts.isIdentifier(node.expression) && hasMatchingSymbol(node.expression, imports.buildSymbols, typeChecker) && node.arguments.length === 1 && ts.isObjectLiteralExpression(node.arguments[0])) {
-			const hasMatchingEntry = node.arguments[0].properties.some((property) => ts.isPropertyAssignment(property) && (ts.isIdentifier(property.name) && property.name.text === "entry" || ts.isStringLiteral(property.name) && property.name.text === "entry") && ts.isArrayLiteralExpression(property.initializer) && property.initializer.elements.length === 1 && ts.isIdentifier(property.initializer.elements[0]) && property.initializer.elements[0].text === filePathName);
-			const outDirectoryProperty = node.arguments[0].properties.find((property) => ts.isPropertyAssignment(property) && (ts.isIdentifier(property.name) && property.name.text === "outDir" || ts.isStringLiteral(property.name) && property.name.text === "outDir"));
-			const hasCommonJsFormat = node.arguments[0].properties.some((property) => ts.isPropertyAssignment(property) && (ts.isIdentifier(property.name) && property.name.text === "format" || ts.isStringLiteral(property.name) && property.name.text === "format") && ts.isStringLiteralLike(property.initializer) && property.initializer.text === "cjs");
-			if (hasMatchingEntry && hasCommonJsFormat && outDirectoryProperty && ts.isPropertyAssignment(outDirectoryProperty) && ts.isCallExpression(outDirectoryProperty.initializer) && ts.isPropertyAccessExpression(outDirectoryProperty.initializer.expression) && outDirectoryProperty.initializer.expression.name.text === "dirname" && ts.isIdentifier(outDirectoryProperty.initializer.expression.expression) && hasMatchingSymbol(outDirectoryProperty.initializer.expression.expression, imports.pathNamespaceSymbols, typeChecker) && outDirectoryProperty.initializer.arguments.length === 1 && ts.isIdentifier(outDirectoryProperty.initializer.arguments[0]) && hasMatchingOutputEntryPath(callback, filePathName, outDirectoryProperty.initializer.arguments[0].text, imports, typeChecker)) buildInvocation = {
+		if (typescriptBinding.isCallExpression(node) && typescriptBinding.isAwaitExpression(node.parent) && typescriptBinding.isIdentifier(node.expression) && hasMatchingSymbol(node.expression, imports.buildSymbols, typeChecker) && node.arguments.length === 1 && typescriptBinding.isObjectLiteralExpression(node.arguments[0])) {
+			const hasMatchingEntry = node.arguments[0].properties.some((property) => typescriptBinding.isPropertyAssignment(property) && (typescriptBinding.isIdentifier(property.name) && property.name.text === "entry" || typescriptBinding.isStringLiteral(property.name) && property.name.text === "entry") && typescriptBinding.isArrayLiteralExpression(property.initializer) && property.initializer.elements.length === 1 && typescriptBinding.isIdentifier(property.initializer.elements[0]) && property.initializer.elements[0].text === filePathName);
+			const outDirectoryProperty = node.arguments[0].properties.find((property) => typescriptBinding.isPropertyAssignment(property) && (typescriptBinding.isIdentifier(property.name) && property.name.text === "outDir" || typescriptBinding.isStringLiteral(property.name) && property.name.text === "outDir"));
+			const hasCommonJsFormat = node.arguments[0].properties.some((property) => typescriptBinding.isPropertyAssignment(property) && (typescriptBinding.isIdentifier(property.name) && property.name.text === "format" || typescriptBinding.isStringLiteral(property.name) && property.name.text === "format") && typescriptBinding.isStringLiteralLike(property.initializer) && property.initializer.text === "cjs");
+			if (hasMatchingEntry && hasCommonJsFormat && outDirectoryProperty && typescriptBinding.isPropertyAssignment(outDirectoryProperty) && typescriptBinding.isCallExpression(outDirectoryProperty.initializer) && typescriptBinding.isPropertyAccessExpression(outDirectoryProperty.initializer.expression) && outDirectoryProperty.initializer.expression.name.text === "dirname" && typescriptBinding.isIdentifier(outDirectoryProperty.initializer.expression.expression) && hasMatchingSymbol(outDirectoryProperty.initializer.expression.expression, imports.pathNamespaceSymbols, typeChecker) && outDirectoryProperty.initializer.arguments.length === 1 && typescriptBinding.isIdentifier(outDirectoryProperty.initializer.arguments[0]) && hasMatchingOutputEntryPath(callback, filePathName, outDirectoryProperty.initializer.arguments[0].text, imports, typeChecker)) buildInvocation = {
 				end: node.parent.end,
 				outputEntryName: outDirectoryProperty.initializer.arguments[0].text
 			};
 		}
-		if (!buildInvocation) ts.forEachChild(node, visitNode);
+		if (!buildInvocation) typescriptBinding.forEachChild(node, visitNode);
 	};
 	visitNode(callback.body);
 	return buildInvocation;
@@ -45540,19 +45524,19 @@ const collectImportedNamespaceExportNames = (callback, buildInvocation, typeChec
 	const importedNamespaceDeclarationEndBySymbol = /* @__PURE__ */ new Map();
 	const exportNames = /* @__PURE__ */ new Set();
 	const collectNamespaceNames = (node) => {
-		if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && ts.isAwaitExpression(node.initializer) && node.initializer.pos >= buildInvocation.end && ts.isCallExpression(node.initializer.expression) && node.initializer.expression.expression.kind === ts.SyntaxKind.ImportKeyword && node.initializer.expression.arguments.length === 1 && ts.isIdentifier(node.initializer.expression.arguments[0]) && node.initializer.expression.arguments[0].text === buildInvocation.outputEntryName) {
+		if (typescriptBinding.isVariableDeclaration(node) && typescriptBinding.isIdentifier(node.name) && node.initializer && typescriptBinding.isAwaitExpression(node.initializer) && node.initializer.pos >= buildInvocation.end && typescriptBinding.isCallExpression(node.initializer.expression) && node.initializer.expression.expression.kind === typescriptBinding.SyntaxKind.ImportKeyword && node.initializer.expression.arguments.length === 1 && typescriptBinding.isIdentifier(node.initializer.expression.arguments[0]) && node.initializer.expression.arguments[0].text === buildInvocation.outputEntryName) {
 			const namespaceSymbol = typeChecker.getSymbolAtLocation(node.name);
 			if (namespaceSymbol) importedNamespaceDeclarationEndBySymbol.set(namespaceSymbol, node.end);
 		}
-		ts.forEachChild(node, collectNamespaceNames);
+		typescriptBinding.forEachChild(node, collectNamespaceNames);
 	};
 	collectNamespaceNames(callback.body);
 	const collectExportNames = (node) => {
-		const namespaceSymbol = (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) && ts.isIdentifier(node.expression) ? typeChecker.getSymbolAtLocation(node.expression) : void 0;
+		const namespaceSymbol = (typescriptBinding.isPropertyAccessExpression(node) || typescriptBinding.isElementAccessExpression(node)) && typescriptBinding.isIdentifier(node.expression) ? typeChecker.getSymbolAtLocation(node.expression) : void 0;
 		const namespaceDeclarationEnd = namespaceSymbol ? importedNamespaceDeclarationEndBySymbol.get(namespaceSymbol) : void 0;
-		if (ts.isPropertyAccessExpression(node) && namespaceDeclarationEnd !== void 0 && node.pos >= namespaceDeclarationEnd) exportNames.add(node.name.text);
-		else if (ts.isElementAccessExpression(node) && namespaceDeclarationEnd !== void 0 && node.pos >= namespaceDeclarationEnd && node.argumentExpression && ts.isStringLiteral(node.argumentExpression)) exportNames.add(node.argumentExpression.text);
-		ts.forEachChild(node, collectExportNames);
+		if (typescriptBinding.isPropertyAccessExpression(node) && namespaceDeclarationEnd !== void 0 && node.pos >= namespaceDeclarationEnd) exportNames.add(node.name.text);
+		else if (typescriptBinding.isElementAccessExpression(node) && namespaceDeclarationEnd !== void 0 && node.pos >= namespaceDeclarationEnd && node.argumentExpression && typescriptBinding.isStringLiteral(node.argumentExpression)) exportNames.add(node.argumentExpression.text);
+		typescriptBinding.forEachChild(node, collectExportNames);
 	};
 	collectExportNames(callback.body);
 	return exportNames;
@@ -45568,14 +45552,14 @@ const collectScriptConsumedExportKeys = (scriptPath, packageDirectory) => {
 		noLib: true,
 		noResolve: true
 	};
-	const sourceFile = ts.createSourceFile(scriptPath, source, ts.ScriptTarget.Latest, true);
-	const compilerHost = ts.createCompilerHost(compilerOptions);
+	const sourceFile = typescriptBinding.createSourceFile(scriptPath, source, typescriptBinding.ScriptTarget.Latest, true);
+	const compilerHost = typescriptBinding.createCompilerHost(compilerOptions);
 	const scriptIdentity = getFileIdentityKey(scriptPath);
 	const isScriptPath = (candidatePath) => getFileIdentityKey(candidatePath) === scriptIdentity;
 	compilerHost.fileExists = isScriptPath;
 	compilerHost.getSourceFile = (candidatePath) => isScriptPath(candidatePath) ? sourceFile : void 0;
 	compilerHost.readFile = (candidatePath) => isScriptPath(candidatePath) ? source : void 0;
-	const program = ts.createProgram({
+	const program = typescriptBinding.createProgram({
 		rootNames: [scriptPath],
 		options: compilerOptions,
 		host: compilerHost
@@ -45587,22 +45571,22 @@ const collectScriptConsumedExportKeys = (scriptPath, packageDirectory) => {
 	if (imports.buildSymbols.size === 0 || imports.globNamespaceSymbols.size === 0 || imports.pathNamespaceSymbols.size === 0) return /* @__PURE__ */ new Set();
 	const collectionsBySymbol = /* @__PURE__ */ new Map();
 	const visitCollection = (node) => {
-		if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+		if (typescriptBinding.isVariableDeclaration(node) && typescriptBinding.isIdentifier(node.name) && node.initializer) {
 			const collection = extractFileCollection(node.initializer, imports, dirname(scriptPath), typeChecker);
 			const collectionSymbol = typeChecker.getSymbolAtLocation(node.name);
 			if (collection && collectionSymbol) collectionsBySymbol.set(collectionSymbol, collection);
 		}
-		ts.forEachChild(node, visitCollection);
+		typescriptBinding.forEachChild(node, visitCollection);
 	};
 	visitCollection(boundSourceFile);
 	const consumedExportKeys = /* @__PURE__ */ new Set();
 	const packageManifestIdentity = getFileIdentityKey(resolve(packageDirectory, "package.json"));
 	const visitMapCall = (node) => {
-		if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map" && ts.isIdentifier(node.expression.expression) && node.arguments.length === 1 && (ts.isArrowFunction(node.arguments[0]) || ts.isFunctionExpression(node.arguments[0]))) {
+		if (typescriptBinding.isCallExpression(node) && typescriptBinding.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map" && typescriptBinding.isIdentifier(node.expression.expression) && node.arguments.length === 1 && (typescriptBinding.isArrowFunction(node.arguments[0]) || typescriptBinding.isFunctionExpression(node.arguments[0]))) {
 			const collectionSymbol = typeChecker.getSymbolAtLocation(node.expression.expression);
 			const collection = collectionSymbol ? collectionsBySymbol.get(collectionSymbol) : void 0;
 			const callback = node.arguments[0];
-			if (collection && callback.parameters.length === 1 && ts.isIdentifier(callback.parameters[0].name)) {
+			if (collection && callback.parameters.length === 1 && typescriptBinding.isIdentifier(callback.parameters[0].name)) {
 				const buildInvocation = findBuildInvocation(callback, callback.parameters[0].name.text, imports, typeChecker);
 				if (!buildInvocation) return;
 				const exportNames = collectImportedNamespaceExportNames(callback, buildInvocation, typeChecker);
@@ -45621,7 +45605,7 @@ const collectScriptConsumedExportKeys = (scriptPath, packageDirectory) => {
 				}
 			}
 		}
-		ts.forEachChild(node, visitMapCall);
+		typescriptBinding.forEachChild(node, visitMapCall);
 	};
 	visitMapCall(boundSourceFile);
 	return consumedExportKeys;
@@ -45665,7 +45649,7 @@ const readPackageMetadata = (packageDirectory) => {
 		return;
 	}
 };
-const hasNextraImport = (sourceFile) => sourceFile.statements.some((statement) => ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === "nextra");
+const hasNextraImport = (sourceFile) => sourceFile.statements.some((statement) => typescriptBinding.isImportDeclaration(statement) && typescriptBinding.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === "nextra");
 const collectReferencedNextraThemeConfigPaths = (packageDirectory) => {
 	const referencedPaths = /* @__PURE__ */ new Set();
 	for (const configFilename of NEXT_CONFIG_FILENAMES) {
@@ -45677,16 +45661,16 @@ const collectReferencedNextraThemeConfigPaths = (packageDirectory) => {
 		} catch {
 			continue;
 		}
-		const sourceFile = ts.createSourceFile(configPath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+		const sourceFile = typescriptBinding.createSourceFile(configPath, content, typescriptBinding.ScriptTarget.Latest, true, typescriptBinding.ScriptKind.TS);
 		if (!hasNextraImport(sourceFile)) continue;
 		const visitNode = (node) => {
-			if (ts.isPropertyAssignment(node)) {
-				if ((ts.isIdentifier(node.name) || ts.isStringLiteral(node.name) ? node.name.text : void 0) === "themeConfig" && (ts.isStringLiteral(node.initializer) || ts.isNoSubstitutionTemplateLiteral(node.initializer)) && node.initializer.text.startsWith(".")) {
+			if (typescriptBinding.isPropertyAssignment(node)) {
+				if ((typescriptBinding.isIdentifier(node.name) || typescriptBinding.isStringLiteral(node.name) ? node.name.text : void 0) === "themeConfig" && (typescriptBinding.isStringLiteral(node.initializer) || typescriptBinding.isNoSubstitutionTemplateLiteral(node.initializer)) && node.initializer.text.startsWith(".")) {
 					const resolvedThemeConfigPath = resolveEntryWithExtensions(resolve(dirname(configPath), node.initializer.text));
 					if (resolvedThemeConfigPath) referencedPaths.add(toPosixPath(toFilesystemIdentityPath(resolve(resolvedThemeConfigPath))));
 				}
 			}
-			ts.forEachChild(node, visitNode);
+			typescriptBinding.forEachChild(node, visitNode);
 		};
 		visitNode(sourceFile);
 	}
@@ -46139,7 +46123,7 @@ const collectStaticModulePackageNames = (sourceText) => {
 //#region ../core/src/project-analysis/utils/matches-package-import-reference.ts
 const collectPackageImportNames = (content) => {
 	const packageNames = collectStaticModulePackageNames(content);
-	const sourceFile = ts.createSourceFile("package-reference.ts", content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const sourceFile = typescriptBinding.createSourceFile("package-reference.ts", content, typescriptBinding.ScriptTarget.Latest, true, typescriptBinding.ScriptKind.TS);
 	for (const typeReferenceDirective of sourceFile.typeReferenceDirectives) {
 		const packageName = extractPackageName(typeReferenceDirective.fileName);
 		if (packageName) packageNames.add(packageName);
@@ -46149,8 +46133,8 @@ const collectPackageImportNames = (content) => {
 //#endregion
 //#region ../core/src/project-analysis/utils/get-object-literal-element-name.ts
 const getObjectLiteralElementName = (property) => {
-	if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) return;
-	return ts.isIdentifier(property.name) || ts.isStringLiteral(property.name) ? property.name.text : void 0;
+	if (!typescriptBinding.isPropertyAssignment(property) && !typescriptBinding.isShorthandPropertyAssignment(property)) return;
+	return typescriptBinding.isIdentifier(property.name) || typescriptBinding.isStringLiteral(property.name) ? property.name.text : void 0;
 };
 //#endregion
 //#region ../core/src/project-analysis/utils/collect-config-plugin-map-package-names.ts
@@ -46158,23 +46142,23 @@ const collectConfigPluginMapPackageNames = (expression) => {
 	const packageNames = /* @__PURE__ */ new Set();
 	const collectExpression = (currentExpression) => {
 		const unwrappedExpression = unwrapTypescriptExpression(currentExpression);
-		if (ts.isConditionalExpression(unwrappedExpression)) {
+		if (typescriptBinding.isConditionalExpression(unwrappedExpression)) {
 			collectExpression(unwrappedExpression.whenTrue);
 			collectExpression(unwrappedExpression.whenFalse);
 			return;
 		}
-		if (ts.isBinaryExpression(unwrappedExpression) && [
-			ts.SyntaxKind.AmpersandAmpersandToken,
-			ts.SyntaxKind.BarBarToken,
-			ts.SyntaxKind.QuestionQuestionToken
+		if (typescriptBinding.isBinaryExpression(unwrappedExpression) && [
+			typescriptBinding.SyntaxKind.AmpersandAmpersandToken,
+			typescriptBinding.SyntaxKind.BarBarToken,
+			typescriptBinding.SyntaxKind.QuestionQuestionToken
 		].includes(unwrappedExpression.operatorToken.kind)) {
 			collectExpression(unwrappedExpression.left);
 			collectExpression(unwrappedExpression.right);
 			return;
 		}
-		if (!ts.isObjectLiteralExpression(unwrappedExpression)) return;
+		if (!typescriptBinding.isObjectLiteralExpression(unwrappedExpression)) return;
 		for (const property of unwrappedExpression.properties) {
-			if (ts.isSpreadAssignment(property)) {
+			if (typescriptBinding.isSpreadAssignment(property)) {
 				collectExpression(property.expression);
 				continue;
 			}
@@ -46197,16 +46181,16 @@ const STRUCTURED_TEXT_EXTENSIONS = new Set([
 const BABEL_CONFIG_FILE_PATTERN = /(?:^|[/\\])(?:babel\.config\.[^/\\]+|\.babelrc(?:\.[^/\\]+)?)$/;
 const BABEL_MODULE_PREFIX = "module:";
 const isBabelPluginOrPresetSpecifier = (node) => {
-	const parent = ts.isArrayLiteralExpression(node.parent) ? node.parent : void 0;
+	const parent = typescriptBinding.isArrayLiteralExpression(node.parent) ? node.parent : void 0;
 	if (!parent) return false;
-	const property = (parent.elements[0] === node && ts.isArrayLiteralExpression(parent.parent) ? parent.parent : parent).parent;
+	const property = (parent.elements[0] === node && typescriptBinding.isArrayLiteralExpression(parent.parent) ? parent.parent : parent).parent;
 	let ancestor = property;
-	while (ancestor && !ts.isSourceFile(ancestor)) {
+	while (ancestor && !typescriptBinding.isSourceFile(ancestor)) {
 		const parentNode = ancestor.parent;
-		if (ts.isObjectLiteralExpression(ancestor) && ts.isArrayLiteralExpression(parentNode) && parentNode.elements[0] !== ancestor && ts.isStringLiteralLike(parentNode.elements[0])) return false;
+		if (typescriptBinding.isObjectLiteralExpression(ancestor) && typescriptBinding.isArrayLiteralExpression(parentNode) && parentNode.elements[0] !== ancestor && typescriptBinding.isStringLiteralLike(parentNode.elements[0])) return false;
 		ancestor = parentNode;
 	}
-	return ts.isPropertyAssignment(property) && (getObjectLiteralElementName(property) === "plugins" || getObjectLiteralElementName(property) === "presets");
+	return typescriptBinding.isPropertyAssignment(property) && (getObjectLiteralElementName(property) === "plugins" || getObjectLiteralElementName(property) === "presets");
 };
 const collectStructuredTextPackageReferences = (content) => {
 	const uncommentedContent = content.split("\n").map(stripCoffeeScriptComment).join("\n");
@@ -46219,16 +46203,16 @@ const collectStructuredTextPackageReferences = (content) => {
 };
 const collectPackageConfigReferences = (filePath, content) => {
 	if (STRUCTURED_TEXT_EXTENSIONS.has(extname(filePath))) return collectStructuredTextPackageReferences(content);
-	const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const sourceFile = typescriptBinding.createSourceFile(filePath, content, typescriptBinding.ScriptTarget.Latest, true, typescriptBinding.ScriptKind.TS);
 	const packageNames = /* @__PURE__ */ new Set();
 	const visit = (node) => {
-		if (ts.isPropertyAssignment(node) && getObjectLiteralElementName(node) === "plugins") for (const packageName of collectConfigPluginMapPackageNames(node.initializer)) packageNames.add(packageName);
-		if (ts.isStringLiteralLike(node)) {
+		if (typescriptBinding.isPropertyAssignment(node) && getObjectLiteralElementName(node) === "plugins") for (const packageName of collectConfigPluginMapPackageNames(node.initializer)) packageNames.add(packageName);
+		if (typescriptBinding.isStringLiteralLike(node)) {
 			const packageName = extractPackageName(BABEL_CONFIG_FILE_PATTERN.test(filePath) && node.text.startsWith(BABEL_MODULE_PREFIX) && isBabelPluginOrPresetSpecifier(node) ? node.text.slice(7) : node.text);
 			if (packageName) packageNames.add(packageName);
 			return;
 		}
-		ts.forEachChild(node, visit);
+		typescriptBinding.forEachChild(node, visit);
 	};
 	visit(sourceFile);
 	return packageNames;
@@ -48456,21 +48440,21 @@ const extractPreviewRegistryNamesFromMdx = (sourceText) => {
 //#endregion
 //#region ../core/src/project-analysis/utils/are-source-files-structurally-equivalent.ts
 const buildSourceStructure = (filePath, sourceText) => {
-	const sourceFile = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, filePath.endsWith("x") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+	const sourceFile = typescriptBinding.createSourceFile(filePath, sourceText, typescriptBinding.ScriptTarget.Latest, true, filePath.endsWith("x") ? typescriptBinding.ScriptKind.TSX : typescriptBinding.ScriptKind.TS);
 	const structure = [];
 	const visitNode = (node, normalizeClassNames = false) => {
 		structure.push(String(node.kind));
-		if (ts.isIdentifier(node)) structure.push(node.text);
-		else if (ts.isStringLiteralLike(node)) structure.push(normalizeClassNames ? node.text.trim().split(/\s+/).sort().join(" ") : node.text);
-		else if (ts.isNumericLiteral(node)) structure.push(node.text);
-		else if (ts.isTemplateLiteralToken(node) || ts.isRegularExpressionLiteral(node) || ts.isBigIntLiteral(node)) structure.push(node.text);
-		else if (ts.isJsxText(node)) structure.push(node.text.replace(/\s+/g, " ").trim());
-		if (ts.isJsxAttribute(node) && ts.isIdentifier(node.name) && node.name.text === "className" && node.initializer && ts.isStringLiteral(node.initializer)) {
+		if (typescriptBinding.isIdentifier(node)) structure.push(node.text);
+		else if (typescriptBinding.isStringLiteralLike(node)) structure.push(normalizeClassNames ? node.text.trim().split(/\s+/).sort().join(" ") : node.text);
+		else if (typescriptBinding.isNumericLiteral(node)) structure.push(node.text);
+		else if (typescriptBinding.isTemplateLiteralToken(node) || typescriptBinding.isRegularExpressionLiteral(node) || typescriptBinding.isBigIntLiteral(node)) structure.push(node.text);
+		else if (typescriptBinding.isJsxText(node)) structure.push(node.text.replace(/\s+/g, " ").trim());
+		if (typescriptBinding.isJsxAttribute(node) && typescriptBinding.isIdentifier(node.name) && node.name.text === "className" && node.initializer && typescriptBinding.isStringLiteral(node.initializer)) {
 			visitNode(node.name);
 			visitNode(node.initializer, true);
 			return;
 		}
-		ts.forEachChild(node, (childNode) => visitNode(childNode));
+		typescriptBinding.forEachChild(node, (childNode) => visitNode(childNode));
 	};
 	visitNode(sourceFile);
 	return structure.join("\0");
@@ -48484,8 +48468,8 @@ const buildScriptAnalysisKey = (scriptFile) => `${scriptFile.workingDirectory}\0
 const resolveBuildReference = (reference, workingDirectory, projectRoot) => reference.startsWith("/") ? resolve(projectRoot, reference.replace(/^\/+/, "")) : resolve(workingDirectory, reference);
 const getPropertyName$1 = (expression) => {
 	const unwrappedExpression = unwrapTypescriptExpression(expression);
-	if (ts.isPropertyAccessExpression(unwrappedExpression)) return unwrappedExpression.name.text;
-	if (ts.isElementAccessExpression(unwrappedExpression) && unwrappedExpression.argumentExpression && ts.isStringLiteralLike(unwrappedExpression.argumentExpression)) return unwrappedExpression.argumentExpression.text;
+	if (typescriptBinding.isPropertyAccessExpression(unwrappedExpression)) return unwrappedExpression.name.text;
+	if (typescriptBinding.isElementAccessExpression(unwrappedExpression) && unwrappedExpression.argumentExpression && typescriptBinding.isStringLiteralLike(unwrappedExpression.argumentExpression)) return unwrappedExpression.argumentExpression.text;
 };
 const resolveImportedScriptPath = (specifier, scriptFile, projectRoot) => {
 	const importedPath = specifier.startsWith(".") ? resolve(dirname(scriptFile.filePath), specifier) : specifier.startsWith("@/registry/") ? resolve(scriptFile.workingDirectory, "src/registry", specifier.slice(11)) : void 0;
@@ -48502,20 +48486,20 @@ const collectWebpackEntrySpecifiers = (filePath) => {
 	} catch {
 		return [];
 	}
-	const sourceFile = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const sourceFile = typescriptBinding.createSourceFile(filePath, sourceText, typescriptBinding.ScriptTarget.Latest, true, typescriptBinding.ScriptKind.TS);
 	const specifiers = /* @__PURE__ */ new Set();
 	const collectStringLiterals = (node) => {
-		if (ts.isStringLiteralLike(node) && node.text.startsWith(".")) {
+		if (typescriptBinding.isStringLiteralLike(node) && node.text.startsWith(".")) {
 			specifiers.add(node.text);
 			return;
 		}
-		ts.forEachChild(node, collectStringLiterals);
+		typescriptBinding.forEachChild(node, collectStringLiterals);
 	};
 	const visitNode = (node) => {
-		if (ts.isPropertyAssignment(node) && (ts.isIdentifier(node.name) && node.name.text === "entry" || ts.isStringLiteralLike(node.name) && node.name.text === "entry")) collectStringLiterals(node.initializer);
-		if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(node.left) && node.left.name.text === "entry") collectStringLiterals(node.right);
-		if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "concat" && node.getText(sourceFile).includes(".entry")) collectStringLiterals(node);
-		ts.forEachChild(node, visitNode);
+		if (typescriptBinding.isPropertyAssignment(node) && (typescriptBinding.isIdentifier(node.name) && node.name.text === "entry" || typescriptBinding.isStringLiteralLike(node.name) && node.name.text === "entry")) collectStringLiterals(node.initializer);
+		if (typescriptBinding.isBinaryExpression(node) && node.operatorToken.kind === typescriptBinding.SyntaxKind.EqualsToken && typescriptBinding.isPropertyAccessExpression(node.left) && node.left.name.text === "entry") collectStringLiterals(node.right);
+		if (typescriptBinding.isCallExpression(node) && typescriptBinding.isPropertyAccessExpression(node.expression) && node.expression.name.text === "concat" && node.getText(sourceFile).includes(".entry")) collectStringLiterals(node);
+		typescriptBinding.forEachChild(node, visitNode);
 	};
 	visitNode(sourceFile);
 	return [...specifiers];
@@ -48682,23 +48666,23 @@ const buildScriptAnalyses = (invokedScriptFiles, projectRoot) => {
 		} catch {
 			continue;
 		}
-		const sourceFile = ts.createSourceFile(scriptFile.filePath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+		const sourceFile = typescriptBinding.createSourceFile(scriptFile.filePath, content, typescriptBinding.ScriptTarget.Latest, true, typescriptBinding.ScriptKind.TS);
 		const localFunctions = /* @__PURE__ */ new Map();
 		const defaultExportExpressions = [];
 		for (const statement of sourceFile.statements) {
-			if (ts.isFunctionDeclaration(statement) && statement.body) {
+			if (typescriptBinding.isFunctionDeclaration(statement) && statement.body) {
 				if (statement.name) localFunctions.set(statement.name.text, statement.body);
-				if (statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword)) localFunctions.set("default", statement.body);
+				if (statement.modifiers?.some((modifier) => modifier.kind === typescriptBinding.SyntaxKind.DefaultKeyword)) localFunctions.set("default", statement.body);
 			}
-			if (ts.isVariableStatement(statement)) {
-				for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) localFunctions.set(declaration.name.text, declaration.initializer.body);
+			if (typescriptBinding.isVariableStatement(statement)) {
+				for (const declaration of statement.declarationList.declarations) if (typescriptBinding.isIdentifier(declaration.name) && declaration.initializer && (typescriptBinding.isArrowFunction(declaration.initializer) || typescriptBinding.isFunctionExpression(declaration.initializer))) localFunctions.set(declaration.name.text, declaration.initializer.body);
 			}
-			if (ts.isExportAssignment(statement) && !statement.isExportEquals) defaultExportExpressions.push(statement.expression);
+			if (typescriptBinding.isExportAssignment(statement) && !statement.isExportEquals) defaultExportExpressions.push(statement.expression);
 		}
 		for (const defaultExportExpression of defaultExportExpressions) {
 			const unwrappedDefaultExport = unwrapTypescriptExpression(defaultExportExpression);
-			if (ts.isArrowFunction(unwrappedDefaultExport) || ts.isFunctionExpression(unwrappedDefaultExport)) localFunctions.set("default", unwrappedDefaultExport.body);
-			else if (ts.isIdentifier(unwrappedDefaultExport)) {
+			if (typescriptBinding.isArrowFunction(unwrappedDefaultExport) || typescriptBinding.isFunctionExpression(unwrappedDefaultExport)) localFunctions.set("default", unwrappedDefaultExport.body);
+			else if (typescriptBinding.isIdentifier(unwrappedDefaultExport)) {
 				const defaultFunctionBody = localFunctions.get(unwrappedDefaultExport.text);
 				if (defaultFunctionBody) localFunctions.set("default", defaultFunctionBody);
 			}
@@ -48712,7 +48696,7 @@ const buildScriptAnalyses = (invokedScriptFiles, projectRoot) => {
 		});
 	}
 	for (const analysis of analyses.values()) for (const statement of analysis.sourceFile.statements) {
-		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		if (!typescriptBinding.isImportDeclaration(statement) || !typescriptBinding.isStringLiteral(statement.moduleSpecifier)) continue;
 		const importClause = statement.importClause;
 		if (!importClause || importClause.isTypeOnly) continue;
 		const importedFilePath = resolveImportedScriptPath(statement.moduleSpecifier.text, analysis.scriptFile, projectRoot);
@@ -48726,7 +48710,7 @@ const buildScriptAnalyses = (invokedScriptFiles, projectRoot) => {
 			analysisKey: importedAnalysisKey,
 			exportName: "default"
 		});
-		if (!importClause.namedBindings || !ts.isNamedImports(importClause.namedBindings)) continue;
+		if (!importClause.namedBindings || !typescriptBinding.isNamedImports(importClause.namedBindings)) continue;
 		for (const element of importClause.namedBindings.elements) {
 			if (element.isTypeOnly) continue;
 			analysis.importedFunctions.set(element.name.text, {
@@ -48748,11 +48732,11 @@ const buildScriptAnalyses = (invokedScriptFiles, projectRoot) => {
 	const visitLiveNode = (analysis, rootNode) => {
 		const visitNode = (node) => {
 			analysis.liveNodes.add(node);
-			if (node !== rootNode && (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node))) return;
-			if (ts.isCallExpression(node)) {
+			if (node !== rootNode && (typescriptBinding.isFunctionDeclaration(node) || typescriptBinding.isFunctionExpression(node) || typescriptBinding.isArrowFunction(node) || typescriptBinding.isMethodDeclaration(node))) return;
+			if (typescriptBinding.isCallExpression(node)) {
 				const calledExpression = unwrapTypescriptExpression(node.expression);
-				if (ts.isFunctionExpression(calledExpression) || ts.isArrowFunction(calledExpression)) queueFunctionBody(analysis, calledExpression.body);
-				if (ts.isIdentifier(calledExpression)) {
+				if (typescriptBinding.isFunctionExpression(calledExpression) || typescriptBinding.isArrowFunction(calledExpression)) queueFunctionBody(analysis, calledExpression.body);
+				if (typescriptBinding.isIdentifier(calledExpression)) {
 					const localFunctionBody = analysis.localFunctions.get(calledExpression.text);
 					if (localFunctionBody) queueFunctionBody(analysis, localFunctionBody);
 					const importedFunction = analysis.importedFunctions.get(calledExpression.text);
@@ -48762,10 +48746,10 @@ const buildScriptAnalyses = (invokedScriptFiles, projectRoot) => {
 				}
 				for (const argument of node.arguments) {
 					const unwrappedArgument = unwrapTypescriptExpression(argument);
-					if (ts.isFunctionExpression(unwrappedArgument) || ts.isArrowFunction(unwrappedArgument)) queueFunctionBody(analysis, unwrappedArgument.body);
+					if (typescriptBinding.isFunctionExpression(unwrappedArgument) || typescriptBinding.isArrowFunction(unwrappedArgument)) queueFunctionBody(analysis, unwrappedArgument.body);
 				}
 			}
-			ts.forEachChild(node, visitNode);
+			typescriptBinding.forEachChild(node, visitNode);
 		};
 		visitNode(rootNode);
 	};
@@ -48790,18 +48774,18 @@ const findVariableDeclaration = (sourceFile, identifierName, usePosition) => {
 	let closestDeclaration;
 	const visitNode = (node) => {
 		if (node.getStart(sourceFile) >= usePosition) return;
-		if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+		if (typescriptBinding.isVariableDeclaration(node) && typescriptBinding.isIdentifier(node.name)) {
 			if (node.name.text === identifierName) closestDeclaration = node;
 		}
-		ts.forEachChild(node, visitNode);
+		typescriptBinding.forEachChild(node, visitNode);
 	};
 	visitNode(sourceFile);
 	return closestDeclaration;
 };
 const evaluatePathExpression = (expression, analysis, projectRoot, seenIdentifiers = /* @__PURE__ */ new Set()) => {
 	const unwrappedExpression = unwrapTypescriptExpression(expression);
-	if (ts.isStringLiteralLike(unwrappedExpression)) return resolveBuildReference(unwrappedExpression.text, analysis.scriptFile.workingDirectory, projectRoot);
-	if (ts.isIdentifier(unwrappedExpression)) {
+	if (typescriptBinding.isStringLiteralLike(unwrappedExpression)) return resolveBuildReference(unwrappedExpression.text, analysis.scriptFile.workingDirectory, projectRoot);
+	if (typescriptBinding.isIdentifier(unwrappedExpression)) {
 		if (unwrappedExpression.text === "__dirname") return dirname(analysis.scriptFile.filePath);
 		if (seenIdentifiers.has(unwrappedExpression.text)) return void 0;
 		const declaration = findVariableDeclaration(analysis.sourceFile, unwrappedExpression.text, unwrappedExpression.getStart(analysis.sourceFile));
@@ -48810,8 +48794,8 @@ const evaluatePathExpression = (expression, analysis, projectRoot, seenIdentifie
 		nextSeenIdentifiers.add(unwrappedExpression.text);
 		return evaluatePathExpression(declaration.initializer, analysis, projectRoot, nextSeenIdentifiers);
 	}
-	if (!ts.isCallExpression(unwrappedExpression)) return void 0;
-	if (ts.isPropertyAccessExpression(unwrappedExpression.expression) && ts.isIdentifier(unwrappedExpression.expression.expression) && unwrappedExpression.expression.expression.text === "process" && unwrappedExpression.expression.name.text === "cwd") return analysis.scriptFile.workingDirectory;
+	if (!typescriptBinding.isCallExpression(unwrappedExpression)) return void 0;
+	if (typescriptBinding.isPropertyAccessExpression(unwrappedExpression.expression) && typescriptBinding.isIdentifier(unwrappedExpression.expression.expression) && unwrappedExpression.expression.expression.text === "process" && unwrappedExpression.expression.name.text === "cwd") return analysis.scriptFile.workingDirectory;
 	const pathMethodName = getPropertyName$1(unwrappedExpression.expression);
 	if (pathMethodName !== "join" && pathMethodName !== "resolve") return void 0;
 	const [baseExpression, ...segmentExpressions] = unwrappedExpression.arguments;
@@ -48821,7 +48805,7 @@ const evaluatePathExpression = (expression, analysis, projectRoot, seenIdentifie
 	const pathSegments = [];
 	for (const segmentExpression of segmentExpressions) {
 		const unwrappedSegment = unwrapTypescriptExpression(segmentExpression);
-		if (!ts.isStringLiteralLike(unwrappedSegment)) return void 0;
+		if (!typescriptBinding.isStringLiteralLike(unwrappedSegment)) return void 0;
 		pathSegments.push(unwrappedSegment.text);
 	}
 	const rootRelativeSegment = pathSegments.find((pathSegment) => pathSegment.startsWith("/"));
@@ -48835,48 +48819,48 @@ const evaluatePathExpression = (expression, analysis, projectRoot, seenIdentifie
 const expressionContainsIdentifier = (expression, identifierName) => {
 	let containsIdentifier = false;
 	const visitNode = (node) => {
-		if (ts.isIdentifier(node) && node.text === identifierName) {
+		if (typescriptBinding.isIdentifier(node) && node.text === identifierName) {
 			containsIdentifier = true;
 			return;
 		}
-		if (!containsIdentifier) ts.forEachChild(node, visitNode);
+		if (!containsIdentifier) typescriptBinding.forEachChild(node, visitNode);
 	};
 	visitNode(expression);
 	return containsIdentifier;
 };
 const isConditionallyExecuted = (node, boundary) => {
-	for (let ancestor = node.parent; ancestor && ancestor !== boundary; ancestor = ancestor.parent) if (ts.isIfStatement(ancestor) || ts.isConditionalExpression(ancestor) || ts.isSwitchStatement(ancestor)) return true;
+	for (let ancestor = node.parent; ancestor && ancestor !== boundary; ancestor = ancestor.parent) if (typescriptBinding.isIfStatement(ancestor) || typescriptBinding.isConditionalExpression(ancestor) || typescriptBinding.isSwitchStatement(ancestor)) return true;
 	return false;
 };
 const analyzeDirectoryConsumer = (body, helperName, parameterName) => {
 	const directoryEntryCollectionNames = /* @__PURE__ */ new Set();
 	let unconditionallyConsumesEntries = false;
 	let recursivelyTraverses = false;
-	const isDirectoryRead = (node) => ts.isCallExpression(node) && getPropertyName$1(node.expression) === "readdirSync" && node.arguments[0] !== void 0 && ts.isIdentifier(unwrapTypescriptExpression(node.arguments[0])) && unwrapTypescriptExpression(node.arguments[0]).getText() === parameterName;
+	const isDirectoryRead = (node) => typescriptBinding.isCallExpression(node) && getPropertyName$1(node.expression) === "readdirSync" && node.arguments[0] !== void 0 && typescriptBinding.isIdentifier(unwrapTypescriptExpression(node.arguments[0])) && unwrapTypescriptExpression(node.arguments[0]).getText() === parameterName;
 	const visitNode = (node) => {
-		if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && isDirectoryRead(unwrapTypescriptExpression(node.initializer))) directoryEntryCollectionNames.add(node.name.text);
-		if (ts.isForOfStatement(node) && ts.isVariableDeclarationList(node.initializer)) {
+		if (typescriptBinding.isVariableDeclaration(node) && typescriptBinding.isIdentifier(node.name) && node.initializer && isDirectoryRead(unwrapTypescriptExpression(node.initializer))) directoryEntryCollectionNames.add(node.name.text);
+		if (typescriptBinding.isForOfStatement(node) && typescriptBinding.isVariableDeclarationList(node.initializer)) {
 			const collectionExpression = unwrapTypescriptExpression(node.expression);
-			if (isDirectoryRead(collectionExpression) || ts.isIdentifier(collectionExpression) && directoryEntryCollectionNames.has(collectionExpression.text)) {
+			if (isDirectoryRead(collectionExpression) || typescriptBinding.isIdentifier(collectionExpression) && directoryEntryCollectionNames.has(collectionExpression.text)) {
 				const loopVariable = node.initializer.declarations[0]?.name;
-				if (loopVariable && ts.isIdentifier(loopVariable)) {
+				if (loopVariable && typescriptBinding.isIdentifier(loopVariable)) {
 					const entryDependentNames = new Set([loopVariable.text]);
 					const visitLoop = (loopNode) => {
-						if (ts.isVariableDeclaration(loopNode) && ts.isIdentifier(loopNode.name) && loopNode.initializer && [...entryDependentNames].some((identifierName) => expressionContainsIdentifier(loopNode.initializer, identifierName))) entryDependentNames.add(loopNode.name.text);
-						if (ts.isCallExpression(loopNode)) {
+						if (typescriptBinding.isVariableDeclaration(loopNode) && typescriptBinding.isIdentifier(loopNode.name) && loopNode.initializer && [...entryDependentNames].some((identifierName) => expressionContainsIdentifier(loopNode.initializer, identifierName))) entryDependentNames.add(loopNode.name.text);
+						if (typescriptBinding.isCallExpression(loopNode)) {
 							if (getPropertyName$1(loopNode.expression)?.match(/^(?:copyFile|readFile)(?:Sync)?$/) && loopNode.arguments.some((argument) => [...entryDependentNames].some((identifierName) => expressionContainsIdentifier(argument, identifierName)))) {
 								if (!isConditionallyExecuted(loopNode, node.statement)) unconditionallyConsumesEntries = true;
 							}
 							const calledExpression = unwrapTypescriptExpression(loopNode.expression);
-							if (ts.isIdentifier(calledExpression) && calledExpression.text === helperName && loopNode.arguments.some((argument) => [...entryDependentNames].some((identifierName) => expressionContainsIdentifier(argument, identifierName)))) recursivelyTraverses = true;
+							if (typescriptBinding.isIdentifier(calledExpression) && calledExpression.text === helperName && loopNode.arguments.some((argument) => [...entryDependentNames].some((identifierName) => expressionContainsIdentifier(argument, identifierName)))) recursivelyTraverses = true;
 						}
-						ts.forEachChild(loopNode, visitLoop);
+						typescriptBinding.forEachChild(loopNode, visitLoop);
 					};
 					visitLoop(node.statement);
 				}
 			}
 		}
-		ts.forEachChild(node, visitNode);
+		typescriptBinding.forEachChild(node, visitNode);
 	};
 	visitNode(body);
 	return {
@@ -48886,11 +48870,11 @@ const analyzeDirectoryConsumer = (body, helperName, parameterName) => {
 };
 const collectRecursiveInputDirectories = (analysis, projectRoot, consumedFiles) => {
 	for (const node of analysis.liveNodes) {
-		if (!ts.isCallExpression(node) || !ts.isIdentifier(unwrapTypescriptExpression(node.expression))) continue;
+		if (!typescriptBinding.isCallExpression(node) || !typescriptBinding.isIdentifier(unwrapTypescriptExpression(node.expression))) continue;
 		const helperName = unwrapTypescriptExpression(node.expression).getText();
 		const helperBody = analysis.localFunctions.get(helperName);
-		const helperDeclaration = [...analysis.sourceFile.statements].find((statement) => ts.isFunctionDeclaration(statement) && statement.name?.text === helperName);
-		if (!helperBody || !helperDeclaration || !ts.isFunctionDeclaration(helperDeclaration) || !helperDeclaration.parameters[0] || !ts.isIdentifier(helperDeclaration.parameters[0].name)) continue;
+		const helperDeclaration = [...analysis.sourceFile.statements].find((statement) => typescriptBinding.isFunctionDeclaration(statement) && statement.name?.text === helperName);
+		if (!helperBody || !helperDeclaration || !typescriptBinding.isFunctionDeclaration(helperDeclaration) || !helperDeclaration.parameters[0] || !typescriptBinding.isIdentifier(helperDeclaration.parameters[0].name)) continue;
 		const directoryConsumption = analyzeDirectoryConsumer(helperBody, helperName, helperDeclaration.parameters[0].name.text);
 		if (!directoryConsumption.consumesAllEntries) continue;
 		const directoryArgument = node.arguments[0];
@@ -48901,9 +48885,9 @@ const collectRecursiveInputDirectories = (analysis, projectRoot, consumedFiles)
 };
 const evaluateCopySourceExpression = (expression, loopVariableName, loopVariableValue) => {
 	const unwrappedExpression = unwrapTypescriptExpression(expression);
-	if (ts.isIdentifier(unwrappedExpression)) return unwrappedExpression.text === loopVariableName ? loopVariableValue : void 0;
-	if (ts.isStringLiteralLike(unwrappedExpression)) return unwrappedExpression.text;
-	if (ts.isTemplateExpression(unwrappedExpression)) {
+	if (typescriptBinding.isIdentifier(unwrappedExpression)) return unwrappedExpression.text === loopVariableName ? loopVariableValue : void 0;
+	if (typescriptBinding.isStringLiteralLike(unwrappedExpression)) return unwrappedExpression.text;
+	if (typescriptBinding.isTemplateExpression(unwrappedExpression)) {
 		let resolvedTemplate = unwrappedExpression.head.text;
 		for (const templateSpan of unwrappedExpression.templateSpans) {
 			const resolvedExpression = evaluateCopySourceExpression(templateSpan.expression, loopVariableName, loopVariableValue);
@@ -48912,7 +48896,7 @@ const evaluateCopySourceExpression = (expression, loopVariableName, loopVariable
 		}
 		return resolvedTemplate;
 	}
-	if (ts.isBinaryExpression(unwrappedExpression) && unwrappedExpression.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+	if (typescriptBinding.isBinaryExpression(unwrappedExpression) && unwrappedExpression.operatorToken.kind === typescriptBinding.SyntaxKind.PlusToken) {
 		const leftValue = evaluateCopySourceExpression(unwrappedExpression.left, loopVariableName, loopVariableValue);
 		const rightValue = evaluateCopySourceExpression(unwrappedExpression.right, loopVariableName, loopVariableValue);
 		return leftValue === void 0 || rightValue === void 0 ? void 0 : `${leftValue}${rightValue}`;
@@ -48920,25 +48904,25 @@ const evaluateCopySourceExpression = (expression, loopVariableName, loopVariable
 };
 const collectCopiedSourceFiles = (analysis, projectRoot, consumedFiles) => {
 	for (const node of analysis.liveNodes) {
-		if (!ts.isForOfStatement(node) || !analysis.liveNodes.has(node.statement)) continue;
-		if (!ts.isVariableDeclarationList(node.initializer) || node.initializer.declarations.length !== 1 || !ts.isIdentifier(node.initializer.declarations[0].name) || !ts.isIdentifier(unwrapTypescriptExpression(node.expression))) continue;
+		if (!typescriptBinding.isForOfStatement(node) || !analysis.liveNodes.has(node.statement)) continue;
+		if (!typescriptBinding.isVariableDeclarationList(node.initializer) || node.initializer.declarations.length !== 1 || !typescriptBinding.isIdentifier(node.initializer.declarations[0].name) || !typescriptBinding.isIdentifier(unwrapTypescriptExpression(node.expression))) continue;
 		const loopVariableName = node.initializer.declarations[0].name.text;
 		const arrayIdentifier = unwrapTypescriptExpression(node.expression);
-		if (!ts.isIdentifier(arrayIdentifier)) continue;
+		if (!typescriptBinding.isIdentifier(arrayIdentifier)) continue;
 		const arrayDeclaration = findVariableDeclaration(analysis.sourceFile, arrayIdentifier.text, node.getStart(analysis.sourceFile));
-		if (!arrayDeclaration?.initializer || !ts.isArrayLiteralExpression(arrayDeclaration.initializer)) continue;
+		if (!arrayDeclaration?.initializer || !typescriptBinding.isArrayLiteralExpression(arrayDeclaration.initializer)) continue;
 		const values = arrayDeclaration.initializer.elements.flatMap((element) => {
 			const unwrappedElement = unwrapTypescriptExpression(element);
-			return ts.isStringLiteralLike(unwrappedElement) ? [unwrappedElement.text] : [];
+			return typescriptBinding.isStringLiteralLike(unwrappedElement) ? [unwrappedElement.text] : [];
 		});
 		const visitLoopBody = (loopNode) => {
-			if (ts.isCallExpression(loopNode) && getPropertyName$1(loopNode.expression)?.match(/^copyFile(?:Sync)?$/) && loopNode.arguments[0]) for (const value of values) {
+			if (typescriptBinding.isCallExpression(loopNode) && getPropertyName$1(loopNode.expression)?.match(/^copyFile(?:Sync)?$/) && loopNode.arguments[0]) for (const value of values) {
 				const sourceReference = evaluateCopySourceExpression(loopNode.arguments[0], loopVariableName, value);
 				if (!sourceReference) continue;
 				const sourcePath = resolveBuildReference(sourceReference, analysis.scriptFile.workingDirectory, projectRoot);
 				if (isPathInsideDirectoryOrEqual(sourcePath, projectRoot) && existsSync(sourcePath) && statSync(sourcePath).isFile() && SOURCE_FILE_EXTENSION_PATTERN.test(sourcePath)) consumedFiles.add(sourcePath);
 			}
-			ts.forEachChild(loopNode, visitLoopBody);
+			typescriptBinding.forEachChild(loopNode, visitLoopBody);
 		};
 		visitLoopBody(node.statement);
 	}
@@ -48947,56 +48931,56 @@ const expressionContainsString = (expression, value) => {
 	let containsString = false;
 	const visitNode = (node) => {
 		if (containsString) return;
-		if (ts.isStringLiteralLike(node) && node.text === value) {
+		if (typescriptBinding.isStringLiteralLike(node) && node.text === value) {
 			containsString = true;
 			return;
 		}
-		ts.forEachChild(node, visitNode);
+		typescriptBinding.forEachChild(node, visitNode);
 	};
 	visitNode(expression);
 	return containsString;
 };
 const collectObjectPathReferences = (expression, fileReferences) => {
 	const unwrappedExpression = unwrapTypescriptExpression(expression);
-	if (ts.isStringLiteralLike(unwrappedExpression)) {
+	if (typescriptBinding.isStringLiteralLike(unwrappedExpression)) {
 		fileReferences.add(unwrappedExpression.text);
 		return;
 	}
-	if (ts.isArrayLiteralExpression(unwrappedExpression)) {
+	if (typescriptBinding.isArrayLiteralExpression(unwrappedExpression)) {
 		for (const element of unwrappedExpression.elements) collectObjectPathReferences(element, fileReferences);
 		return;
 	}
-	if (!ts.isObjectLiteralExpression(unwrappedExpression)) return;
+	if (!typescriptBinding.isObjectLiteralExpression(unwrappedExpression)) return;
 	for (const property of unwrappedExpression.properties) {
-		if (!ts.isPropertyAssignment(property)) continue;
-		if ((ts.isIdentifier(property.name) || ts.isStringLiteralLike(property.name) ? property.name.text : void 0) === "path") collectObjectPathReferences(property.initializer, fileReferences);
+		if (!typescriptBinding.isPropertyAssignment(property)) continue;
+		if ((typescriptBinding.isIdentifier(property.name) || typescriptBinding.isStringLiteralLike(property.name) ? property.name.text : void 0) === "path") collectObjectPathReferences(property.initializer, fileReferences);
 	}
 };
 const findStyleRegistryFanoutSources = (analysis, analyses) => {
 	for (const node of analysis.liveNodes) {
-		if (!ts.isForOfStatement(node) || !ts.isVariableDeclarationList(node.initializer) || node.initializer.declarations.length !== 1 || !ts.isIdentifier(node.initializer.declarations[0].name) || !ts.isIdentifier(unwrapTypescriptExpression(node.expression))) continue;
+		if (!typescriptBinding.isForOfStatement(node) || !typescriptBinding.isVariableDeclarationList(node.initializer) || node.initializer.declarations.length !== 1 || !typescriptBinding.isIdentifier(node.initializer.declarations[0].name) || !typescriptBinding.isIdentifier(unwrapTypescriptExpression(node.expression))) continue;
 		const styleVariableName = node.initializer.declarations[0].name.text;
 		const styleCollectionExpression = unwrapTypescriptExpression(node.expression);
-		if (!ts.isIdentifier(styleCollectionExpression)) continue;
+		if (!typescriptBinding.isIdentifier(styleCollectionExpression)) continue;
 		const stylesImport = analysis.importedFunctions.get(styleCollectionExpression.text);
 		const stylesAnalysis = stylesImport ? analyses.get(stylesImport.analysisKey) : void 0;
 		if (!stylesAnalysis) continue;
 		let registryAnalysis;
 		const visitStyleLoop = (loopNode) => {
-			if (registryAnalysis || !ts.isForOfStatement(loopNode)) {
-				if (!registryAnalysis) ts.forEachChild(loopNode, visitStyleLoop);
+			if (registryAnalysis || !typescriptBinding.isForOfStatement(loopNode)) {
+				if (!registryAnalysis) typescriptBinding.forEachChild(loopNode, visitStyleLoop);
 				return;
 			}
-			if (!ts.isVariableDeclarationList(loopNode.initializer) || loopNode.initializer.declarations.length !== 1 || !ts.isIdentifier(loopNode.initializer.declarations[0].name) || !ts.isIdentifier(unwrapTypescriptExpression(loopNode.expression))) {
-				ts.forEachChild(loopNode, visitStyleLoop);
+			if (!typescriptBinding.isVariableDeclarationList(loopNode.initializer) || loopNode.initializer.declarations.length !== 1 || !typescriptBinding.isIdentifier(loopNode.initializer.declarations[0].name) || !typescriptBinding.isIdentifier(unwrapTypescriptExpression(loopNode.expression))) {
+				typescriptBinding.forEachChild(loopNode, visitStyleLoop);
 				return;
 			}
 			const registryItemName = loopNode.initializer.declarations[0].name.text;
 			const registryCollectionExpression = unwrapTypescriptExpression(loopNode.expression);
-			if (!ts.isIdentifier(registryCollectionExpression)) return;
+			if (!typescriptBinding.isIdentifier(registryCollectionExpression)) return;
 			const normalizedLoopBodyText = loopNode.statement.getText(analysis.sourceFile).replace(/\s/g, "");
 			if (!normalizedLoopBodyText.includes(`src/registry/\${${styleVariableName}.name}/`) || !normalizedLoopBodyText.includes(`${registryItemName}.files`) || !/\$\{[A-Za-z_$][\w$]*\.path\}/.test(normalizedLoopBodyText)) {
-				ts.forEachChild(loopNode, visitStyleLoop);
+				typescriptBinding.forEachChild(loopNode, visitStyleLoop);
 				return;
 			}
 			const registryImport = analysis.importedFunctions.get(registryCollectionExpression.text);
@@ -49013,10 +48997,10 @@ const collectRegistryFileReferences = (registryAnalysis, analyses) => {
 	const registryFileReferences = /* @__PURE__ */ new Set();
 	const collectRegistryModule = (moduleAnalysis) => {
 		const visitNode = (node) => {
-			if (ts.isPropertyAssignment(node)) {
-				if ((ts.isIdentifier(node.name) || ts.isStringLiteralLike(node.name) ? node.name.text : void 0) === "files") collectObjectPathReferences(node.initializer, registryFileReferences);
+			if (typescriptBinding.isPropertyAssignment(node)) {
+				if ((typescriptBinding.isIdentifier(node.name) || typescriptBinding.isStringLiteralLike(node.name) ? node.name.text : void 0) === "files") collectObjectPathReferences(node.initializer, registryFileReferences);
 			}
-			ts.forEachChild(node, visitNode);
+			typescriptBinding.forEachChild(node, visitNode);
 		};
 		visitNode(moduleAnalysis.sourceFile);
 	};
@@ -49030,11 +49014,11 @@ const collectRegistryFileReferences = (registryAnalysis, analyses) => {
 const collectRegistryStyleNames = (stylesAnalysis) => {
 	const styleNames = /* @__PURE__ */ new Set();
 	const visitNode = (node) => {
-		if (ts.isPropertyAssignment(node) && (ts.isIdentifier(node.name) || ts.isStringLiteralLike(node.name)) && node.name.text === "name") {
+		if (typescriptBinding.isPropertyAssignment(node) && (typescriptBinding.isIdentifier(node.name) || typescriptBinding.isStringLiteralLike(node.name)) && node.name.text === "name") {
 			const styleNameExpression = unwrapTypescriptExpression(node.initializer);
-			if (ts.isStringLiteralLike(styleNameExpression)) styleNames.add(styleNameExpression.text);
+			if (typescriptBinding.isStringLiteralLike(styleNameExpression)) styleNames.add(styleNameExpression.text);
 		}
-		ts.forEachChild(node, visitNode);
+		typescriptBinding.forEachChild(node, visitNode);
 	};
 	visitNode(stylesAnalysis.sourceFile);
 	return styleNames;
@@ -49048,7 +49032,7 @@ const collectResolvedRegistryFiles = (registryFileReferences, styleNames, regist
 const collectRegistryMetadataConsumedFiles = (analyses, projectRoot, consumedFiles) => {
 	for (const analysis of analyses.values()) {
 		if (!basename(analysis.scriptFile.filePath).includes("registry")) continue;
-		if (![...analysis.liveNodes].some((node) => ts.isCallExpression(node) && getPropertyName$1(node.expression)?.match(/^readFile(?:Sync)?$/) && node.arguments[0] !== void 0 && expressionContainsString(node.arguments[0], "src/registry"))) continue;
+		if (![...analysis.liveNodes].some((node) => typescriptBinding.isCallExpression(node) && getPropertyName$1(node.expression)?.match(/^readFile(?:Sync)?$/) && node.arguments[0] !== void 0 && expressionContainsString(node.arguments[0], "src/registry"))) continue;
 		const registryImport = analysis.importedFunctions.get("registry");
 		const stylesImport = analysis.importedFunctions.get("styles");
 		const registryAnalysis = registryImport ? analyses.get(registryImport.analysisKey) : void 0;
@@ -49069,7 +49053,7 @@ const nodeContainsNode = (rootNode, targetNode) => {
 			containsNode = true;
 			return;
 		}
-		if (!containsNode) ts.forEachChild(node, visitNode);
+		if (!containsNode) typescriptBinding.forEachChild(node, visitNode);
 	};
 	visitNode(rootNode);
 	return containsNode;
@@ -49078,11 +49062,11 @@ const findAssignedVariableName = (analysis, targetNode) => {
 	let variableName;
 	let smallestInitializerWidth = Number.POSITIVE_INFINITY;
 	const visitNode = (node) => {
-		if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && nodeContainsNode(node.initializer, targetNode) && node.initializer.end - node.initializer.pos < smallestInitializerWidth) {
+		if (typescriptBinding.isVariableDeclaration(node) && typescriptBinding.isIdentifier(node.name) && node.initializer && nodeContainsNode(node.initializer, targetNode) && node.initializer.end - node.initializer.pos < smallestInitializerWidth) {
 			variableName = node.name.text;
 			smallestInitializerWidth = node.initializer.end - node.initializer.pos;
 		}
-		ts.forEachChild(node, visitNode);
+		typescriptBinding.forEachChild(node, visitNode);
 	};
 	visitNode(analysis.sourceFile);
 	return variableName;
@@ -49090,29 +49074,29 @@ const findAssignedVariableName = (analysis, targetNode) => {
 const recursivelyReadsManifestWildcards = (analysis, readCall) => {
 	const registryVariableName = findAssignedVariableName(analysis, readCall);
 	if (!registryVariableName) return false;
-	const hasDirectRecursiveRead = [...analysis.liveNodes].some((node) => ts.isCallExpression(node) && ts.isIdentifier(unwrapTypescriptExpression(node.expression)) && unwrapTypescriptExpression(node.expression).getText() === "walk" && node.arguments.length >= 1 && ts.isIdentifier(unwrapTypescriptExpression(node.arguments[0])) && unwrapTypescriptExpression(node.arguments[0]).getText() === "sourceBase");
+	const hasDirectRecursiveRead = [...analysis.liveNodes].some((node) => typescriptBinding.isCallExpression(node) && typescriptBinding.isIdentifier(unwrapTypescriptExpression(node.expression)) && unwrapTypescriptExpression(node.expression).getText() === "walk" && node.arguments.length >= 1 && typescriptBinding.isIdentifier(unwrapTypescriptExpression(node.arguments[0])) && unwrapTypescriptExpression(node.arguments[0]).getText() === "sourceBase");
 	const sourceBaseDeclaration = findVariableDeclaration(analysis.sourceFile, "sourceBase", analysis.sourceFile.end);
 	if (hasDirectRecursiveRead && sourceBaseDeclaration?.initializer && sourceBaseDeclaration.initializer.getText(analysis.sourceFile).includes(registryVariableName) && sourceBaseDeclaration.initializer.getText(analysis.sourceFile).includes("split")) return true;
 	const collectionNames = new Set([registryVariableName]);
-	for (const node of analysis.liveNodes) if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && ts.isPropertyAccessExpression(unwrapTypescriptExpression(node.initializer))) {
+	for (const node of analysis.liveNodes) if (typescriptBinding.isVariableDeclaration(node) && typescriptBinding.isIdentifier(node.name) && node.initializer && typescriptBinding.isPropertyAccessExpression(unwrapTypescriptExpression(node.initializer))) {
 		const propertyAccess = unwrapTypescriptExpression(node.initializer);
-		if (ts.isPropertyAccessExpression(propertyAccess) && ts.isIdentifier(propertyAccess.expression) && collectionNames.has(propertyAccess.expression.text)) collectionNames.add(node.name.text);
+		if (typescriptBinding.isPropertyAccessExpression(propertyAccess) && typescriptBinding.isIdentifier(propertyAccess.expression) && collectionNames.has(propertyAccess.expression.text)) collectionNames.add(node.name.text);
 	}
 	for (const node of analysis.liveNodes) {
-		if (!ts.isForOfStatement(node) || !ts.isVariableDeclarationList(node.initializer) || node.initializer.declarations.length !== 1 || !ts.isIdentifier(node.initializer.declarations[0].name) || !ts.isIdentifier(unwrapTypescriptExpression(node.expression))) continue;
+		if (!typescriptBinding.isForOfStatement(node) || !typescriptBinding.isVariableDeclarationList(node.initializer) || node.initializer.declarations.length !== 1 || !typescriptBinding.isIdentifier(node.initializer.declarations[0].name) || !typescriptBinding.isIdentifier(unwrapTypescriptExpression(node.expression))) continue;
 		const collectionExpression = unwrapTypescriptExpression(node.expression);
-		if (!ts.isIdentifier(collectionExpression) || !collectionNames.has(collectionExpression.text)) continue;
+		if (!typescriptBinding.isIdentifier(collectionExpression) || !collectionNames.has(collectionExpression.text)) continue;
 		const componentName = node.initializer.declarations[0].name.text;
 		let hasRecursiveFileLoop = false;
 		const visitOuterLoop = (outerNode) => {
-			if (ts.isForOfStatement(outerNode) && ts.isPropertyAccessExpression(unwrapTypescriptExpression(outerNode.expression))) {
+			if (typescriptBinding.isForOfStatement(outerNode) && typescriptBinding.isPropertyAccessExpression(unwrapTypescriptExpression(outerNode.expression))) {
 				const filesExpression = unwrapTypescriptExpression(outerNode.expression);
-				if (ts.isPropertyAccessExpression(filesExpression) && ts.isIdentifier(filesExpression.expression) && filesExpression.expression.text === componentName && filesExpression.name.text === "files") {
+				if (typescriptBinding.isPropertyAccessExpression(filesExpression) && typescriptBinding.isIdentifier(filesExpression.expression) && filesExpression.expression.text === componentName && filesExpression.name.text === "files") {
 					const innerLoopText = outerNode.statement.getText(analysis.sourceFile);
 					if (/\.includes\(\s*["']\*["']\s*\)/.test(innerLoopText) && /\.split\(\s*["']\*["']\s*\)/.test(innerLoopText) && /\bwalk\s*\(\s*sourceBase\s*,\s*sourceBase\s*\)/.test(innerLoopText)) hasRecursiveFileLoop = true;
 				}
 			}
-			if (!hasRecursiveFileLoop) ts.forEachChild(outerNode, visitOuterLoop);
+			if (!hasRecursiveFileLoop) typescriptBinding.forEachChild(outerNode, visitOuterLoop);
 		};
 		visitOuterLoop(node.statement);
 		if (hasRecursiveFileLoop) return true;
@@ -49121,7 +49105,7 @@ const recursivelyReadsManifestWildcards = (analysis, readCall) => {
 };
 const collectReferencedManifestFiles = (analysis, projectRoot, consumedFiles) => {
 	for (const node of analysis.liveNodes) {
-		if (!ts.isCallExpression(node) || !getPropertyName$1(node.expression)?.match(/^readFile(?:Sync)?$/) || !node.arguments[0]) continue;
+		if (!typescriptBinding.isCallExpression(node) || !getPropertyName$1(node.expression)?.match(/^readFile(?:Sync)?$/) || !node.arguments[0]) continue;
 		const manifestPath = evaluatePathExpression(node.arguments[0], analysis, projectRoot);
 		if (!manifestPath || basename(manifestPath) !== "registry.json") continue;
 		if (!isPathInsideDirectoryOrEqual(manifestPath, projectRoot)) continue;
@@ -49312,46 +49296,46 @@ const collectParcelHtmlEntryPaths = (rootDirectory) => {
 		} catch {
 			continue;
 		}
-		const sourceFile = ts.createSourceFile(scriptPath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+		const sourceFile = typescriptBinding.createSourceFile(scriptPath, sourceText, typescriptBinding.ScriptTarget.Latest, true, typescriptBinding.ScriptKind.TS);
 		const parcelConstructorNames = /* @__PURE__ */ new Set();
 		const variableInitializers = /* @__PURE__ */ new Map();
 		for (const statement of sourceFile.statements) {
-			if (ts.isImportDeclaration(statement) && ts.isStringLiteralLike(statement.moduleSpecifier) && statement.moduleSpecifier.text === "parcel-bundler") {
+			if (typescriptBinding.isImportDeclaration(statement) && typescriptBinding.isStringLiteralLike(statement.moduleSpecifier) && statement.moduleSpecifier.text === "parcel-bundler") {
 				const importClause = statement.importClause;
 				if (importClause?.name) parcelConstructorNames.add(importClause.name.text);
 			}
-			if (!ts.isVariableStatement(statement)) continue;
+			if (!typescriptBinding.isVariableStatement(statement)) continue;
 			for (const declaration of statement.declarationList.declarations) {
-				if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
+				if (!typescriptBinding.isIdentifier(declaration.name) || !declaration.initializer) continue;
 				variableInitializers.set(declaration.name.text, declaration.initializer);
-				if (ts.isCallExpression(declaration.initializer) && ts.isIdentifier(declaration.initializer.expression) && declaration.initializer.expression.text === "require" && declaration.initializer.arguments.length === 1 && ts.isStringLiteralLike(declaration.initializer.arguments[0]) && declaration.initializer.arguments[0].text === "parcel-bundler") parcelConstructorNames.add(declaration.name.text);
+				if (typescriptBinding.isCallExpression(declaration.initializer) && typescriptBinding.isIdentifier(declaration.initializer.expression) && declaration.initializer.expression.text === "require" && declaration.initializer.arguments.length === 1 && typescriptBinding.isStringLiteralLike(declaration.initializer.arguments[0]) && declaration.initializer.arguments[0].text === "parcel-bundler") parcelConstructorNames.add(declaration.name.text);
 			}
 		}
 		if (parcelConstructorNames.size === 0) continue;
 		const evaluateEntryExpression = (expression, visitedIdentifiers = /* @__PURE__ */ new Set()) => {
-			if (ts.isStringLiteralLike(expression)) return [expression.text];
-			if (ts.isArrayLiteralExpression(expression)) return expression.elements.flatMap((element) => ts.isExpression(element) ? evaluateEntryExpression(element, visitedIdentifiers) : []);
-			if (ts.isIdentifier(expression)) {
+			if (typescriptBinding.isStringLiteralLike(expression)) return [expression.text];
+			if (typescriptBinding.isArrayLiteralExpression(expression)) return expression.elements.flatMap((element) => typescriptBinding.isExpression(element) ? evaluateEntryExpression(element, visitedIdentifiers) : []);
+			if (typescriptBinding.isIdentifier(expression)) {
 				if (visitedIdentifiers.has(expression.text)) return [];
 				const initializer = variableInitializers.get(expression.text);
 				if (!initializer) return [];
 				return evaluateEntryExpression(initializer, new Set(visitedIdentifiers).add(expression.text));
 			}
-			if (ts.isCallExpression(expression) && ts.isPropertyAccessExpression(expression.expression) && (expression.expression.name.text === "join" || expression.expression.name.text === "resolve") && expression.arguments.length > 1 && ts.isIdentifier(expression.arguments[0]) && expression.arguments[0].text === "__dirname" && expression.arguments.slice(1).every(ts.isStringLiteralLike)) {
-				const pathSegments = expression.arguments.slice(1).flatMap((argument) => ts.isStringLiteralLike(argument) ? [argument.text] : []);
+			if (typescriptBinding.isCallExpression(expression) && typescriptBinding.isPropertyAccessExpression(expression.expression) && (expression.expression.name.text === "join" || expression.expression.name.text === "resolve") && expression.arguments.length > 1 && typescriptBinding.isIdentifier(expression.arguments[0]) && expression.arguments[0].text === "__dirname" && expression.arguments.slice(1).every(typescriptBinding.isStringLiteralLike)) {
+				const pathSegments = expression.arguments.slice(1).flatMap((argument) => typescriptBinding.isStringLiteralLike(argument) ? [argument.text] : []);
 				return [resolve(dirname(scriptPath), ...pathSegments)];
 			}
 			return [];
 		};
 		const visitNode = (node) => {
-			if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && parcelConstructorNames.has(node.expression.text) && node.arguments?.[0]) for (const entrySpecifier of evaluateEntryExpression(node.arguments[0])) {
+			if (typescriptBinding.isNewExpression(node) && typescriptBinding.isIdentifier(node.expression) && parcelConstructorNames.has(node.expression.text) && node.arguments?.[0]) for (const entrySpecifier of evaluateEntryExpression(node.arguments[0])) {
 				const entryPattern = isAbsolute(entrySpecifier) ? entrySpecifier : resolve(dirname(scriptPath), entrySpecifier);
 				for (const htmlEntryPath of import_out.default.sync(entryPattern.replaceAll("\\", "/"), {
 					absolute: true,
 					onlyFiles: true
 				})) if (/\.html?$/i.test(htmlEntryPath)) htmlEntryPaths.add(htmlEntryPath);
 			}
-			ts.forEachChild(node, visitNode);
+			typescriptBinding.forEachChild(node, visitNode);
 		};
 		visitNode(sourceFile);
 	}
@@ -49397,22 +49381,22 @@ const isConsumedStringLiteral = (node) => {
 	let currentNode = node;
 	while (currentNode.parent) {
 		const parentNode = currentNode.parent;
-		if (ts.isCallExpression(parentNode) || ts.isNewExpression(parentNode) || ts.isPropertyAssignment(parentNode) || ts.isExportAssignment(parentNode) || ts.isReturnStatement(parentNode)) return true;
-		if (ts.isVariableDeclaration(parentNode) || ts.isExpressionStatement(parentNode) || ts.isSourceFile(parentNode)) return false;
+		if (typescriptBinding.isCallExpression(parentNode) || typescriptBinding.isNewExpression(parentNode) || typescriptBinding.isPropertyAssignment(parentNode) || typescriptBinding.isExportAssignment(parentNode) || typescriptBinding.isReturnStatement(parentNode)) return true;
+		if (typescriptBinding.isVariableDeclaration(parentNode) || typescriptBinding.isExpressionStatement(parentNode) || typescriptBinding.isSourceFile(parentNode)) return false;
 		currentNode = parentNode;
 	}
 	return false;
 };
 const matchesExecutableNodeModulesPackageReference = (content, packageName) => {
-	const sourceFile = ts.createSourceFile("node-modules-reference.ts", content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const sourceFile = typescriptBinding.createSourceFile("node-modules-reference.ts", content, typescriptBinding.ScriptTarget.Latest, true, typescriptBinding.ScriptKind.TS);
 	let isMatched = false;
 	const visit = (node) => {
 		if (isMatched) return;
-		if (ts.isStringLiteralLike(node) && isConsumedStringLiteral(node) && matchesNodeModulesPackageReference(node.text, packageName)) {
+		if (typescriptBinding.isStringLiteralLike(node) && isConsumedStringLiteral(node) && matchesNodeModulesPackageReference(node.text, packageName)) {
 			isMatched = true;
 			return;
 		}
-		ts.forEachChild(node, visit);
+		typescriptBinding.forEachChild(node, visit);
 	};
 	visit(sourceFile);
 	return isMatched;
@@ -49472,14 +49456,14 @@ const collectTwoslashPackageNames = (sourceText) => {
 	const packageNames = /* @__PURE__ */ new Set();
 	for (const source of sources) try {
 		for (const packageName of collectStaticModulePackageNames(source)) packageNames.add(packageName);
-		const sourceFile = ts.createSourceFile("twoslash-source.js", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+		const sourceFile = typescriptBinding.createSourceFile("twoslash-source.js", source, typescriptBinding.ScriptTarget.Latest, true, typescriptBinding.ScriptKind.JS);
 		const visitNode = (node) => {
-			for (const tag of ts.getJSDocTags(node)) {
-				if (!ts.isJSDocImportTag(tag) || !ts.isStringLiteralLike(tag.moduleSpecifier)) continue;
+			for (const tag of typescriptBinding.getJSDocTags(node)) {
+				if (!typescriptBinding.isJSDocImportTag(tag) || !typescriptBinding.isStringLiteralLike(tag.moduleSpecifier)) continue;
 				const packageName = extractPackageName(tag.moduleSpecifier.text);
 				if (packageName) packageNames.add(packageName);
 			}
-			ts.forEachChild(node, visitNode);
+			typescriptBinding.forEachChild(node, visitNode);
 		};
 		visitNode(sourceFile);
 	} catch {
@@ -49533,27 +49517,27 @@ const KARMA_BROWSER_PACKAGES = new Map([
 	["Safari", ["karma-safari-launcher"]]
 ]);
 const collectExpressionStrings = (expression, identifierStrings, strings) => {
-	if (ts.isStringLiteralLike(expression)) {
+	if (typescriptBinding.isStringLiteralLike(expression)) {
 		strings.add(expression.text);
 		return;
 	}
-	if (ts.isIdentifier(expression)) {
+	if (typescriptBinding.isIdentifier(expression)) {
 		for (const value of identifierStrings.get(expression.text) ?? []) strings.add(value);
 		return;
 	}
-	if (ts.isArrayLiteralExpression(expression)) {
-		for (const element of expression.elements) if (ts.isSpreadElement(element)) collectExpressionStrings(element.expression, identifierStrings, strings);
+	if (typescriptBinding.isArrayLiteralExpression(expression)) {
+		for (const element of expression.elements) if (typescriptBinding.isSpreadElement(element)) collectExpressionStrings(element.expression, identifierStrings, strings);
 		else collectExpressionStrings(element, identifierStrings, strings);
 		return;
 	}
-	if (ts.isConditionalExpression(expression)) {
+	if (typescriptBinding.isConditionalExpression(expression)) {
 		collectExpressionStrings(expression.whenTrue, identifierStrings, strings);
 		collectExpressionStrings(expression.whenFalse, identifierStrings, strings);
 		return;
 	}
-	if (ts.isObjectLiteralExpression(expression)) {
-		for (const property of expression.properties) if (ts.isPropertyAssignment(property)) collectExpressionStrings(property.initializer, identifierStrings, strings);
-		else if (ts.isShorthandPropertyAssignment(property)) for (const value of identifierStrings.get(property.name.text) ?? []) strings.add(value);
+	if (typescriptBinding.isObjectLiteralExpression(expression)) {
+		for (const property of expression.properties) if (typescriptBinding.isPropertyAssignment(property)) collectExpressionStrings(property.initializer, identifierStrings, strings);
+		else if (typescriptBinding.isShorthandPropertyAssignment(property)) for (const value of identifierStrings.get(property.name.text) ?? []) strings.add(value);
 	}
 };
 const collectIdentifierStrings = (sourceFile) => {
@@ -49564,21 +49548,21 @@ const collectIdentifierStrings = (sourceFile) => {
 		identifierStrings.set(identifierName, strings);
 	};
 	const visit = (node) => {
-		if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) addExpression(node.name.text, node.initializer);
-		if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(node.left)) addExpression(node.left.text, node.right);
-		ts.forEachChild(node, visit);
+		if (typescriptBinding.isVariableDeclaration(node) && typescriptBinding.isIdentifier(node.name) && node.initializer) addExpression(node.name.text, node.initializer);
+		if (typescriptBinding.isBinaryExpression(node) && node.operatorToken.kind === typescriptBinding.SyntaxKind.EqualsToken && typescriptBinding.isIdentifier(node.left)) addExpression(node.left.text, node.right);
+		typescriptBinding.forEachChild(node, visit);
 	};
 	visit(sourceFile);
 	return identifierStrings;
 };
 const collectPropertyStrings = (property, identifierStrings) => {
 	const strings = /* @__PURE__ */ new Set();
-	if (ts.isPropertyAssignment(property)) collectExpressionStrings(property.initializer, identifierStrings, strings);
-	else if (ts.isShorthandPropertyAssignment(property)) for (const value of identifierStrings.get(property.name.text) ?? []) strings.add(value);
+	if (typescriptBinding.isPropertyAssignment(property)) collectExpressionStrings(property.initializer, identifierStrings, strings);
+	else if (typescriptBinding.isShorthandPropertyAssignment(property)) for (const value of identifierStrings.get(property.name.text) ?? []) strings.add(value);
 	return strings;
 };
 const extractKarmaConfigPackageReferences = (content, declaredPackageNames) => {
-	const sourceFile = ts.createSourceFile("karma.config.ts", content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const sourceFile = typescriptBinding.createSourceFile("karma.config.ts", content, typescriptBinding.ScriptTarget.Latest, true, typescriptBinding.ScriptKind.TS);
 	const identifierStrings = collectIdentifierStrings(sourceFile);
 	const referencedPackages = /* @__PURE__ */ new Set();
 	const propertyPackageMaps = new Map([
@@ -49588,12 +49572,12 @@ const extractKarmaConfigPackageReferences = (content, declaredPackageNames) => {
 		["browsers", KARMA_BROWSER_PACKAGES]
 	]);
 	const visit = (node) => {
-		if (ts.isObjectLiteralExpression(node)) for (const property of node.properties) {
+		if (typescriptBinding.isObjectLiteralExpression(node)) for (const property of node.properties) {
 			const packageMap = propertyPackageMaps.get(getObjectLiteralElementName(property) ?? "");
 			if (!packageMap) continue;
 			for (const token of collectPropertyStrings(property, identifierStrings)) for (const packageName of packageMap.get(token) ?? []) if (declaredPackageNames.has(packageName)) referencedPackages.add(packageName);
 		}
-		ts.forEachChild(node, visit);
+		typescriptBinding.forEachChild(node, visit);
 	};
 	visit(sourceFile);
 	return [...referencedPackages];
@@ -49610,23 +49594,23 @@ const hasExpoReactServerFunctions = (rootDirectory) => {
 //#endregion
 //#region ../core/src/project-analysis/utils/has-antfu-eslint-react-config.ts
 const hasReactEnabled = (expression) => {
-	if (!ts.isObjectLiteralExpression(expression)) return false;
-	return expression.properties.some((property) => ts.isPropertyAssignment(property) && (ts.isIdentifier(property.name) && property.name.text === "react" || ts.isStringLiteralLike(property.name) && property.name.text === "react") && (property.initializer.kind === ts.SyntaxKind.TrueKeyword || ts.isObjectLiteralExpression(property.initializer)));
+	if (!typescriptBinding.isObjectLiteralExpression(expression)) return false;
+	return expression.properties.some((property) => typescriptBinding.isPropertyAssignment(property) && (typescriptBinding.isIdentifier(property.name) && property.name.text === "react" || typescriptBinding.isStringLiteralLike(property.name) && property.name.text === "react") && (property.initializer.kind === typescriptBinding.SyntaxKind.TrueKeyword || typescriptBinding.isObjectLiteralExpression(property.initializer)));
 };
 const hasAntfuEslintReactConfig = (content) => {
 	const virtualFilePath = "eslint.config.ts";
-	const sourceFile = ts.createSourceFile(virtualFilePath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const sourceFile = typescriptBinding.createSourceFile(virtualFilePath, content, typescriptBinding.ScriptTarget.Latest, true, typescriptBinding.ScriptKind.TS);
 	const compilerOptions = {
 		allowJs: true,
 		noLib: true,
 		noResolve: true,
-		target: ts.ScriptTarget.Latest
+		target: typescriptBinding.ScriptTarget.Latest
 	};
-	const compilerHost = ts.createCompilerHost(compilerOptions);
+	const compilerHost = typescriptBinding.createCompilerHost(compilerOptions);
 	compilerHost.fileExists = (candidatePath) => candidatePath === virtualFilePath;
 	compilerHost.getSourceFile = (candidatePath) => candidatePath === virtualFilePath ? sourceFile : void 0;
 	compilerHost.readFile = (candidatePath) => candidatePath === virtualFilePath ? content : void 0;
-	const program = ts.createProgram({
+	const program = typescriptBinding.createProgram({
 		rootNames: [virtualFilePath],
 		options: compilerOptions,
 		host: compilerHost
@@ -49636,24 +49620,24 @@ const hasAntfuEslintReactConfig = (content) => {
 	const typeChecker = program.getTypeChecker();
 	const antfuFactorySymbols = /* @__PURE__ */ new Set();
 	for (const statement of boundSourceFile.statements) {
-		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteralLike(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "@antfu/eslint-config" || !statement.importClause?.name) continue;
+		if (!typescriptBinding.isImportDeclaration(statement) || !typescriptBinding.isStringLiteralLike(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "@antfu/eslint-config" || !statement.importClause?.name) continue;
 		const factorySymbol = typeChecker.getSymbolAtLocation(statement.importClause.name);
 		if (factorySymbol) antfuFactorySymbols.add(factorySymbol);
 	}
 	let isReactEnabled = false;
 	const visit = (node) => {
 		if (isReactEnabled) return;
-		if (ts.isFunctionLike(node)) return;
-		if (ts.isCallExpression(node) && node.arguments[0] && hasReactEnabled(node.arguments[0])) {
+		if (typescriptBinding.isFunctionLike(node)) return;
+		if (typescriptBinding.isCallExpression(node) && node.arguments[0] && hasReactEnabled(node.arguments[0])) {
 			const factorySymbol = typeChecker.getSymbolAtLocation(node.expression);
 			if (factorySymbol && antfuFactorySymbols.has(factorySymbol)) {
 				isReactEnabled = true;
 				return;
 			}
 		}
-		ts.forEachChild(node, visit);
+		typescriptBinding.forEachChild(node, visit);
 	};
-	for (const statement of boundSourceFile.statements) if (ts.isExportAssignment(statement)) visit(statement.expression);
+	for (const statement of boundSourceFile.statements) if (typescriptBinding.isExportAssignment(statement)) visit(statement.expression);
 	return isReactEnabled;
 };
 //#endregion
@@ -51060,13 +51044,6 @@ const buildPlatformSiblingIndex = (graph, additionalPlatformSuffixesForFile = ()
 	return siblingIndex;
 };
 //#endregion
-//#region ../core/src/project-info/fs-utils.ts
-const isPlainObject = (value) => {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || prototype === Object.prototype;
-};
-//#endregion
 //#region ../core/src/utils/fail-open-read-json.ts
 const failOpenReadJson = (filePath, fallback) => {
 	try {
@@ -51106,32 +51083,32 @@ const SUPPORTED_GLOBAL_VALUES = new Set([
 	"writeable"
 ]);
 const getStaticProperty = (objectExpression, propertyName) => objectExpression.properties.find((property) => {
-	if (ts.isSpreadAssignment(property)) return false;
-	const name = ts.isComputedPropertyName(property.name) ? unwrapTypescriptExpression(property.name.expression) : property.name;
-	return (ts.isIdentifier(name) || ts.isStringLiteralLike(name)) && name.text === propertyName;
+	if (typescriptBinding.isSpreadAssignment(property)) return false;
+	const name = typescriptBinding.isComputedPropertyName(property.name) ? unwrapTypescriptExpression(property.name.expression) : property.name;
+	return (typescriptBinding.isIdentifier(name) || typescriptBinding.isStringLiteralLike(name)) && name.text === propertyName;
 }) ?? null;
-const hasNonLiteralComputedProperty = (objectExpression) => objectExpression.properties.some((property) => !ts.isSpreadAssignment(property) && ts.isComputedPropertyName(property.name) && !ts.isStringLiteralLike(unwrapTypescriptExpression(property.name.expression)));
+const hasNonLiteralComputedProperty = (objectExpression) => objectExpression.properties.some((property) => !typescriptBinding.isSpreadAssignment(property) && typescriptBinding.isComputedPropertyName(property.name) && !typescriptBinding.isStringLiteralLike(unwrapTypescriptExpression(property.name.expression)));
 const getStaticPropertyAssignment = (objectExpression, propertyName) => {
 	const property = getStaticProperty(objectExpression, propertyName);
-	return property && ts.isPropertyAssignment(property) ? property : null;
+	return property && typescriptBinding.isPropertyAssignment(property) ? property : null;
 };
 const getRequireModuleSpecifier = (expression) => {
 	const unwrappedExpression = unwrapTypescriptExpression(expression);
-	if (ts.isPropertyAccessExpression(unwrappedExpression) && unwrappedExpression.name.text === "default") return getRequireModuleSpecifier(unwrappedExpression.expression);
-	if (!ts.isCallExpression(unwrappedExpression) || !ts.isIdentifier(unwrappedExpression.expression) || unwrappedExpression.expression.text !== "require" || unwrappedExpression.arguments.length !== 1) return null;
+	if (typescriptBinding.isPropertyAccessExpression(unwrappedExpression) && unwrappedExpression.name.text === "default") return getRequireModuleSpecifier(unwrappedExpression.expression);
+	if (!typescriptBinding.isCallExpression(unwrappedExpression) || !typescriptBinding.isIdentifier(unwrappedExpression.expression) || unwrappedExpression.expression.text !== "require" || unwrappedExpression.arguments.length !== 1) return null;
 	const moduleSpecifier = unwrappedExpression.arguments[0];
-	return moduleSpecifier && ts.isStringLiteralLike(moduleSpecifier) ? moduleSpecifier.text : null;
+	return moduleSpecifier && typescriptBinding.isStringLiteralLike(moduleSpecifier) ? moduleSpecifier.text : null;
 };
 const getRequiredPropertyModuleSpecifier = (expression, propertyName) => {
 	const unwrappedExpression = unwrapTypescriptExpression(expression);
-	return ts.isPropertyAccessExpression(unwrappedExpression) && unwrappedExpression.name.text === propertyName ? getRequireModuleSpecifier(unwrappedExpression.expression) : null;
+	return typescriptBinding.isPropertyAccessExpression(unwrappedExpression) && unwrappedExpression.name.text === propertyName ? getRequireModuleSpecifier(unwrappedExpression.expression) : null;
 };
-const isCommonJsExportAssignment = (node, sourceFile) => ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && (node.left.getText(sourceFile) === "module.exports" || node.left.getText(sourceFile) === "exports.default");
+const isCommonJsExportAssignment = (node, sourceFile) => typescriptBinding.isBinaryExpression(node) && node.operatorToken.kind === typescriptBinding.SyntaxKind.EqualsToken && (node.left.getText(sourceFile) === "module.exports" || node.left.getText(sourceFile) === "exports.default");
 const isTopLevelExpression = (node) => {
 	let ancestor = node.parent;
-	while (ancestor && !ts.isSourceFile(ancestor)) {
-		if (ts.isExpressionStatement(ancestor)) return ts.isSourceFile(ancestor.parent);
-		if (!ts.isParenthesizedExpression(ancestor) && !ts.isAsExpression(ancestor) && !ts.isSatisfiesExpression(ancestor) && !ts.isNonNullExpression(ancestor) && !ts.isTypeAssertionExpression(ancestor) && !ts.isAwaitExpression(ancestor)) return false;
+	while (ancestor && !typescriptBinding.isSourceFile(ancestor)) {
+		if (typescriptBinding.isExpressionStatement(ancestor)) return typescriptBinding.isSourceFile(ancestor.parent);
+		if (!typescriptBinding.isParenthesizedExpression(ancestor) && !typescriptBinding.isAsExpression(ancestor) && !typescriptBinding.isSatisfiesExpression(ancestor) && !typescriptBinding.isNonNullExpression(ancestor) && !typescriptBinding.isTypeAssertionExpression(ancestor) && !typescriptBinding.isAwaitExpression(ancestor)) return false;
 		ancestor = ancestor.parent;
 	}
 	return false;
@@ -51139,21 +51116,21 @@ const isTopLevelExpression = (node) => {
 const isInsideActiveConfigProperty = (node, propertyName, sourceFile, esbuildBindings, esbuildNamespaceBindings) => {
 	let ancestor = node.parent;
 	let didFindConfigProperty = false;
-	while (ancestor && !ts.isSourceFile(ancestor)) {
-		if (!didFindConfigProperty && !ts.isArrayLiteralExpression(ancestor) && !ts.isParenthesizedExpression(ancestor) && !ts.isAsExpression(ancestor) && !ts.isSatisfiesExpression(ancestor) && !ts.isNonNullExpression(ancestor) && !ts.isTypeAssertionExpression(ancestor) && !ts.isPropertyAssignment(ancestor)) return false;
-		if (ts.isPropertyAssignment(ancestor)) {
-			const isConfigProperty = (ts.isIdentifier(ancestor.name) || ts.isStringLiteralLike(ancestor.name)) && ancestor.name.text === propertyName;
+	while (ancestor && !typescriptBinding.isSourceFile(ancestor)) {
+		if (!didFindConfigProperty && !typescriptBinding.isArrayLiteralExpression(ancestor) && !typescriptBinding.isParenthesizedExpression(ancestor) && !typescriptBinding.isAsExpression(ancestor) && !typescriptBinding.isSatisfiesExpression(ancestor) && !typescriptBinding.isNonNullExpression(ancestor) && !typescriptBinding.isTypeAssertionExpression(ancestor) && !typescriptBinding.isPropertyAssignment(ancestor)) return false;
+		if (typescriptBinding.isPropertyAssignment(ancestor)) {
+			const isConfigProperty = (typescriptBinding.isIdentifier(ancestor.name) || typescriptBinding.isStringLiteralLike(ancestor.name)) && ancestor.name.text === propertyName;
 			if (didFindConfigProperty || !isConfigProperty) return false;
-			if (!ts.isObjectLiteralExpression(ancestor.parent) || ancestor.parent.properties.some(ts.isSpreadAssignment)) return false;
+			if (!typescriptBinding.isObjectLiteralExpression(ancestor.parent) || ancestor.parent.properties.some(typescriptBinding.isSpreadAssignment)) return false;
 			didFindConfigProperty = true;
 			ancestor = ancestor.parent;
 			continue;
 		}
 		if (didFindConfigProperty) {
-			if (ts.isExportAssignment(ancestor)) return true;
+			if (typescriptBinding.isExportAssignment(ancestor)) return true;
 			if (isCommonJsExportAssignment(ancestor, sourceFile)) return isTopLevelExpression(ancestor);
-			if (propertyName === "plugins" && ts.isCallExpression(ancestor) && (ts.isIdentifier(ancestor.expression) ? esbuildBindings.has(ancestor.expression.text) : ts.isPropertyAccessExpression(ancestor.expression) && ancestor.expression.name.text === "build" && (ts.isIdentifier(ancestor.expression.expression) && esbuildNamespaceBindings.has(ancestor.expression.expression.text) || getRequireModuleSpecifier(ancestor.expression.expression) === "esbuild"))) return isTopLevelExpression(ancestor);
-			if (!(ts.isObjectLiteralExpression(ancestor) || ts.isParenthesizedExpression(ancestor) || ts.isAsExpression(ancestor) || ts.isSatisfiesExpression(ancestor) || ts.isNonNullExpression(ancestor) || ts.isTypeAssertionExpression(ancestor) || ts.isCallExpression(ancestor) && ts.isIdentifier(ancestor.expression) && ancestor.expression.text === "defineConfig")) return false;
+			if (propertyName === "plugins" && typescriptBinding.isCallExpression(ancestor) && (typescriptBinding.isIdentifier(ancestor.expression) ? esbuildBindings.has(ancestor.expression.text) : typescriptBinding.isPropertyAccessExpression(ancestor.expression) && ancestor.expression.name.text === "build" && (typescriptBinding.isIdentifier(ancestor.expression.expression) && esbuildNamespaceBindings.has(ancestor.expression.expression.text) || getRequireModuleSpecifier(ancestor.expression.expression) === "esbuild"))) return isTopLevelExpression(ancestor);
+			if (!(typescriptBinding.isObjectLiteralExpression(ancestor) || typescriptBinding.isParenthesizedExpression(ancestor) || typescriptBinding.isAsExpression(ancestor) || typescriptBinding.isSatisfiesExpression(ancestor) || typescriptBinding.isNonNullExpression(ancestor) || typescriptBinding.isTypeAssertionExpression(ancestor) || typescriptBinding.isCallExpression(ancestor) && typescriptBinding.isIdentifier(ancestor.expression) && ancestor.expression.text === "defineConfig")) return false;
 		}
 		ancestor = ancestor.parent;
 	}
@@ -51163,21 +51140,21 @@ const getGlobalsPathFromActiveAutoImportCall = (callExpression, packageDirectory
 	const optionsExpression = callExpression.arguments[0];
 	if (!optionsExpression) return null;
 	const unwrappedOptions = unwrapTypescriptExpression(optionsExpression);
-	if (!ts.isObjectLiteralExpression(unwrappedOptions)) return null;
-	if (unwrappedOptions.properties.some(ts.isSpreadAssignment) || hasNonLiteralComputedProperty(unwrappedOptions)) return null;
+	if (!typescriptBinding.isObjectLiteralExpression(unwrappedOptions)) return null;
+	if (unwrappedOptions.properties.some(typescriptBinding.isSpreadAssignment) || hasNonLiteralComputedProperty(unwrappedOptions)) return null;
 	if (getStaticProperty(unwrappedOptions, "include") || getStaticProperty(unwrappedOptions, "exclude")) return null;
 	const eslintrcProperty = getStaticPropertyAssignment(unwrappedOptions, "eslintrc");
 	if (!eslintrcProperty) return null;
 	const eslintrcExpression = unwrapTypescriptExpression(eslintrcProperty.initializer);
-	if (!ts.isObjectLiteralExpression(eslintrcExpression)) return null;
-	if (eslintrcExpression.properties.some(ts.isSpreadAssignment) || hasNonLiteralComputedProperty(eslintrcExpression)) return null;
+	if (!typescriptBinding.isObjectLiteralExpression(eslintrcExpression)) return null;
+	if (eslintrcExpression.properties.some(typescriptBinding.isSpreadAssignment) || hasNonLiteralComputedProperty(eslintrcExpression)) return null;
 	const enabledProperty = getStaticPropertyAssignment(eslintrcExpression, "enabled");
-	if (!enabledProperty || unwrapTypescriptExpression(enabledProperty.initializer).kind !== ts.SyntaxKind.TrueKeyword) return null;
+	if (!enabledProperty || unwrapTypescriptExpression(enabledProperty.initializer).kind !== typescriptBinding.SyntaxKind.TrueKeyword) return null;
 	const filepathProperty = getStaticProperty(eslintrcExpression, "filepath");
 	if (!filepathProperty) return path$1.join(packageDirectory, DEFAULT_ESLINT_GLOBALS_PATH);
-	if (!ts.isPropertyAssignment(filepathProperty)) return null;
+	if (!typescriptBinding.isPropertyAssignment(filepathProperty)) return null;
 	const filepathExpression = unwrapTypescriptExpression(filepathProperty.initializer);
-	return ts.isStringLiteralLike(filepathExpression) ? path$1.resolve(packageDirectory, filepathExpression.text) : null;
+	return typescriptBinding.isStringLiteralLike(filepathExpression) ? path$1.resolve(packageDirectory, filepathExpression.text) : null;
 };
 const collectGlobalsPathsFromConfig = (configPath, packageDirectory) => {
 	let sourceText;
@@ -51189,12 +51166,16 @@ const collectGlobalsPathsFromConfig = (configPath, packageDirectory) => {
 			globalsPaths: []
 		};
 	}
-	const sourceFile = ts.createSourceFile(configPath, sourceText, ts.ScriptTarget.Latest, true);
+	if (!sourceText.includes("unplugin-auto-import") && !sourceText.includes("\\")) return {
+		didFindActiveAutoImport: false,
+		globalsPaths: []
+	};
+	const sourceFile = typescriptBinding.createSourceFile(configPath, sourceText, typescriptBinding.ScriptTarget.Latest, true);
 	const autoImportBindings = /* @__PURE__ */ new Map();
 	const esbuildBindings = /* @__PURE__ */ new Set();
 	const esbuildNamespaceBindings = /* @__PURE__ */ new Set();
 	for (const statement of sourceFile.statements) {
-		if (ts.isImportDeclaration(statement) && ts.isStringLiteralLike(statement.moduleSpecifier)) {
+		if (typescriptBinding.isImportDeclaration(statement) && typescriptBinding.isStringLiteralLike(statement.moduleSpecifier)) {
 			const moduleSpecifier = statement.moduleSpecifier.text;
 			if (AUTO_IMPORT_ADAPTER_PATTERN.test(moduleSpecifier)) {
 				const defaultBinding = statement.importClause?.name;
@@ -51204,23 +51185,23 @@ const collectGlobalsPathsFromConfig = (configPath, packageDirectory) => {
 				const defaultBinding = statement.importClause?.name;
 				if (defaultBinding) esbuildNamespaceBindings.add(defaultBinding.text);
 				const namedBindings = statement.importClause?.namedBindings;
-				if (namedBindings && ts.isNamedImports(namedBindings)) {
+				if (namedBindings && typescriptBinding.isNamedImports(namedBindings)) {
 					for (const importSpecifier of namedBindings.elements) if ((importSpecifier.propertyName ?? importSpecifier.name).text === "build") esbuildBindings.add(importSpecifier.name.text);
 				}
-				if (namedBindings && ts.isNamespaceImport(namedBindings)) esbuildNamespaceBindings.add(namedBindings.name.text);
+				if (namedBindings && typescriptBinding.isNamespaceImport(namedBindings)) esbuildNamespaceBindings.add(namedBindings.name.text);
 			}
 		}
-		if (!ts.isVariableStatement(statement)) continue;
+		if (!typescriptBinding.isVariableStatement(statement)) continue;
 		for (const declaration of statement.declarationList.declarations) {
 			if (!declaration.initializer) continue;
-			const declarationName = ts.isIdentifier(declaration.name) ? declaration.name.text : null;
+			const declarationName = typescriptBinding.isIdentifier(declaration.name) ? declaration.name.text : null;
 			const moduleSpecifier = getRequireModuleSpecifier(declaration.initializer);
 			if (declarationName && moduleSpecifier && AUTO_IMPORT_ADAPTER_PATTERN.test(moduleSpecifier)) autoImportBindings.set(declarationName, moduleSpecifier);
 			if (moduleSpecifier === "esbuild") {
 				if (declarationName) esbuildNamespaceBindings.add(declarationName);
-				if (ts.isObjectBindingPattern(declaration.name)) for (const bindingElement of declaration.name.elements) {
+				if (typescriptBinding.isObjectBindingPattern(declaration.name)) for (const bindingElement of declaration.name.elements) {
 					const importedName = bindingElement.propertyName ?? bindingElement.name;
-					if (ts.isIdentifier(importedName) && importedName.text === "build" && ts.isIdentifier(bindingElement.name)) esbuildBindings.add(bindingElement.name.text);
+					if (typescriptBinding.isIdentifier(importedName) && importedName.text === "build" && typescriptBinding.isIdentifier(bindingElement.name)) esbuildBindings.add(bindingElement.name.text);
 				}
 			}
 			if (declarationName && getRequiredPropertyModuleSpecifier(declaration.initializer, "build") === "esbuild") esbuildBindings.add(declarationName);
@@ -51230,8 +51211,8 @@ const collectGlobalsPathsFromConfig = (configPath, packageDirectory) => {
 	let didFindActiveAutoImport = false;
 	let didFindUnsafeActiveAutoImport = false;
 	const visit = (node) => {
-		if (ts.isCallExpression(node)) {
-			const moduleSpecifier = ts.isIdentifier(node.expression) ? autoImportBindings.get(node.expression.text) : getRequireModuleSpecifier(node.expression);
+		if (typescriptBinding.isCallExpression(node)) {
+			const moduleSpecifier = typescriptBinding.isIdentifier(node.expression) ? autoImportBindings.get(node.expression.text) : getRequireModuleSpecifier(node.expression);
 			if (moduleSpecifier && AUTO_IMPORT_ADAPTER_PATTERN.test(moduleSpecifier)) {
 				if (isInsideActiveConfigProperty(node, moduleSpecifier.endsWith("/astro") ? "integrations" : "plugins", sourceFile, esbuildBindings, esbuildNamespaceBindings)) {
 					didFindActiveAutoImport = true;
@@ -51241,7 +51222,7 @@ const collectGlobalsPathsFromConfig = (configPath, packageDirectory) => {
 				}
 			}
 		}
-		ts.forEachChild(node, visit);
+		typescriptBinding.forEachChild(node, visit);
 	};
 	visit(sourceFile);
 	return {
@@ -51322,7 +51303,7 @@ const GENERATED_AUTO_IMPORT_MARKER = "Generated by unplugin-auto-import";
 const AUTO_IMPORT_SOURCE_BINDING_PATTERN = /\bconst\s+([A-Za-z_$][\w$]*)\s*:\s*typeof\s+import\(["']([^"']+)["']\)\[["']([^"']+)["']\]/g;
 const isNonReferenceIdentifier = (identifier) => {
 	const parent = identifier.parent;
-	return (ts.isVariableDeclaration(parent) || ts.isParameter(parent) || ts.isFunctionDeclaration(parent) || ts.isFunctionExpression(parent) || ts.isClassDeclaration(parent) || ts.isClassExpression(parent) || ts.isImportClause(parent) || ts.isImportSpecifier(parent) || ts.isNamespaceImport(parent) || ts.isBindingElement(parent)) && parent.name === identifier || ts.isImportSpecifier(parent) && parent.propertyName === identifier || ts.isBindingElement(parent) && parent.propertyName === identifier || ts.isJsxAttribute(parent) && parent.name === identifier || (ts.isPropertyAccessExpression(parent) || ts.isPropertyAssignment(parent) || ts.isPropertyDeclaration(parent) || ts.isMethodDeclaration(parent) || ts.isMethodSignature(parent) || ts.isPropertySignature(parent)) && parent.name === identifier || ts.isQualifiedName(parent) && parent.right === identifier;
+	return (typescriptBinding.isVariableDeclaration(parent) || typescriptBinding.isParameter(parent) || typescriptBinding.isFunctionDeclaration(parent) || typescriptBinding.isFunctionExpression(parent) || typescriptBinding.isClassDeclaration(parent) || typescriptBinding.isClassExpression(parent) || typescriptBinding.isImportClause(parent) || typescriptBinding.isImportSpecifier(parent) || typescriptBinding.isNamespaceImport(parent) || typescriptBinding.isBindingElement(parent)) && parent.name === identifier || typescriptBinding.isImportSpecifier(parent) && parent.propertyName === identifier || typescriptBinding.isBindingElement(parent) && parent.propertyName === identifier || typescriptBinding.isJsxAttribute(parent) && parent.name === identifier || (typescriptBinding.isPropertyAccessExpression(parent) || typescriptBinding.isPropertyAssignment(parent) || typescriptBinding.isPropertyDeclaration(parent) || typescriptBinding.isMethodDeclaration(parent) || typescriptBinding.isMethodSignature(parent) || typescriptBinding.isPropertySignature(parent)) && parent.name === identifier || typescriptBinding.isQualifiedName(parent) && parent.right === identifier;
 };
 const collectUnboundGlobalNames = (filePath, candidateGlobalNames) => {
 	let source;
@@ -51331,19 +51312,19 @@ const collectUnboundGlobalNames = (filePath, candidateGlobalNames) => {
 	} catch {
 		return /* @__PURE__ */ new Set();
 	}
-	const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true);
+	const sourceFile = typescriptBinding.createSourceFile(filePath, source, typescriptBinding.ScriptTarget.Latest, true);
 	const compilerOptions = {
 		allowJs: true,
-		jsx: ts.JsxEmit.Preserve,
+		jsx: typescriptBinding.JsxEmit.Preserve,
 		noLib: true,
 		noResolve: true,
-		target: ts.ScriptTarget.Latest
+		target: typescriptBinding.ScriptTarget.Latest
 	};
-	const compilerHost = ts.createCompilerHost(compilerOptions);
+	const compilerHost = typescriptBinding.createCompilerHost(compilerOptions);
 	compilerHost.fileExists = (candidatePath) => candidatePath === filePath;
 	compilerHost.getSourceFile = (candidatePath) => candidatePath === filePath ? sourceFile : void 0;
 	compilerHost.readFile = (candidatePath) => candidatePath === filePath ? source : void 0;
-	const program = ts.createProgram({
+	const program = typescriptBinding.createProgram({
 		rootNames: [filePath],
 		options: compilerOptions,
 		host: compilerHost
@@ -51353,10 +51334,10 @@ const collectUnboundGlobalNames = (filePath, candidateGlobalNames) => {
 	if (!boundSourceFile) return /* @__PURE__ */ new Set();
 	const unboundGlobalNames = /* @__PURE__ */ new Set();
 	const visitNode = (node) => {
-		if (ts.isIdentifier(node) && candidateGlobalNames.has(node.text) && !isNonReferenceIdentifier(node)) {
-			if (!(ts.isShorthandPropertyAssignment(node.parent) ? typeChecker.getShorthandAssignmentValueSymbol(node.parent) : typeChecker.getSymbolAtLocation(node))) unboundGlobalNames.add(node.text);
+		if (typescriptBinding.isIdentifier(node) && candidateGlobalNames.has(node.text) && !isNonReferenceIdentifier(node)) {
+			if (!(typescriptBinding.isShorthandPropertyAssignment(node.parent) ? typeChecker.getShorthandAssignmentValueSymbol(node.parent) : typeChecker.getSymbolAtLocation(node))) unboundGlobalNames.add(node.text);
 		}
-		ts.forEachChild(node, visitNode);
+		typescriptBinding.forEachChild(node, visitNode);
 	};
 	visitNode(boundSourceFile);
 	return unboundGlobalNames;
@@ -51529,7 +51510,7 @@ const hasUnparseableCompilerConfig = (packageRootDirectory) => {
 	return configNames.some((configName) => {
 		const configPath = join(packageRootDirectory, configName);
 		try {
-			return ts.parseConfigFileTextToJson(configPath, readFileSync(configPath, "utf8")).error !== void 0;
+			return typescriptBinding.parseConfigFileTextToJson(configPath, readFileSync(configPath, "utf8")).error !== void 0;
 		} catch {
 			return true;
 		}
@@ -51902,4 +51883,4 @@ startProjectAnalysisWorker();
 export {};
 
 //# sourceMappingURL=project-analysis-worker.js.map
-//# debugId=d6e7f765-fd9c-5293-bba2-ca87773f3e5e
+//# debugId=81139e97-fbde-59ee-9b65-cb0499a5510a