@generaltranslation/vue-extractor 0.0.0

package/dist/internal/config/resolveVueCompilerOptions.js

@@ -0,0 +1,987 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse } from "@babel/parser";
+import traverseModule from "@babel/traverse";
+import { createDiagnosticMessage } from "generaltranslation/internal";
+//#region src/internal/config/resolveVueCompilerOptions.ts
+const traverse = traverseModule.default || traverseModule;
+const VITE_CONFIG_FILES = [
+	"vite.config.js",
+	"vite.config.mjs",
+	"vite.config.ts",
+	"vite.config.cjs",
+	"vite.config.mts",
+	"vite.config.cts"
+];
+const NUXT_CONFIG_FILES = [
+	"nuxt.config.js",
+	"nuxt.config.ts",
+	"nuxt.config.mjs",
+	"nuxt.config.cjs",
+	"nuxt.config.mts",
+	"nuxt.config.cts"
+];
+const CUSTOM_VITE_CONFIG_EXTENSIONS = new Set([
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".ts",
+	".tsx",
+	".mts",
+	".cts"
+]);
+/**
+* Resolves hash-affecting Vue template compiler options without executing
+* project configuration files.
+*
+* Explicit `gt.config.json` values are combined with statically analyzable
+* Vite and Nuxt configuration. Conflicting, dynamic, or unsupported relevant
+* options produce errors so extraction never publishes hashes calculated with
+* compiler behavior that the runtime does not share.
+*/
+function resolveVueCompilerOptions(cwd, explicitOptions, resolverOptions = {}) {
+	const state = {
+		options: {},
+		sources: {}
+	};
+	const errors = [];
+	readExplicitOptions(explicitOptions, state, errors);
+	if (resolverOptions.viteConfigPath !== void 0) {
+		const file = resolveCustomViteConfig(cwd, resolverOptions.viteConfigPath, errors);
+		if (file) readViteConfig(file, state, errors);
+		return {
+			compilerOptions: state.options,
+			errors
+		};
+	}
+	const nuxtConfig = findFirstConfig(cwd, NUXT_CONFIG_FILES);
+	const viteConfig = findFirstConfig(cwd, VITE_CONFIG_FILES);
+	if (nuxtConfig && viteConfig) {
+		errors.push(optionError("Found both Nuxt and Vite project config files", "For direct Vite builds, set files.gt.parsingFlags.viteConfigPath to the active Vite config. For Nuxt builds, remove or relocate the inactive Vite config so the compiler configuration is unambiguous"));
+		return {
+			compilerOptions: state.options,
+			errors
+		};
+	}
+	if (nuxtConfig) {
+		readNuxtConfig(nuxtConfig, state, errors);
+		return {
+			compilerOptions: state.options,
+			errors
+		};
+	}
+	if (viteConfig) readViteConfig(viteConfig, state, errors);
+	return {
+		compilerOptions: state.options,
+		errors
+	};
+}
+/** Selects the first config file in the framework's documented lookup order. */
+function findFirstConfig(cwd, filenames) {
+	for (const filename of filenames) {
+		const file = path.resolve(cwd, filename);
+		if (fs.existsSync(file)) return file;
+	}
+}
+/** Validates an explicit Vite config without searching or executing files. */
+function resolveCustomViteConfig(cwd, configuredPath, errors) {
+	if (typeof configuredPath !== "string" || !configuredPath.trim()) {
+		errors.push(optionError("Found an empty Vite config path", "Set files.gt.parsingFlags.viteConfigPath to one in-project Vite config file"));
+		return;
+	}
+	const root = path.resolve(cwd);
+	const candidate = path.resolve(root, configuredPath);
+	const relativeCandidate = path.relative(root, candidate);
+	if (relativeCandidate.startsWith(`..${path.sep}`) || relativeCandidate === ".." || path.isAbsolute(relativeCandidate) || relativeCandidate.split(path.sep).includes("node_modules")) {
+		errors.push(optionError("Found a Vite config path outside the project source boundary", "Choose a Vite config file inside the project root and outside node_modules"));
+		return;
+	}
+	if (!CUSTOM_VITE_CONFIG_EXTENSIONS.has(path.extname(candidate).toLowerCase())) {
+		errors.push(optionError("Found an unsupported Vite config file extension", "Use a JavaScript or TypeScript Vite config file"));
+		return;
+	}
+	if (!fs.existsSync(candidate) || !fs.statSync(candidate).isFile()) {
+		errors.push(optionError("Could not find the configured Vite config file", "Set files.gt.parsingFlags.viteConfigPath to an existing file inside the project root"));
+		return;
+	}
+	const realRoot = fs.realpathSync(root);
+	const realCandidate = fs.realpathSync(candidate);
+	const realRelative = path.relative(realRoot, realCandidate);
+	if (realRelative.startsWith(`..${path.sep}`) || realRelative === ".." || path.isAbsolute(realRelative) || realRelative.split(path.sep).includes("node_modules")) {
+		errors.push(optionError("Found a Vite config path outside the project source boundary", "Choose a Vite config file inside the project root and outside node_modules"));
+		return;
+	}
+	return realCandidate;
+}
+function readExplicitOptions(input, state, errors) {
+	if (input === void 0) return;
+	if (!isRecord(input)) {
+		errors.push(optionError("Found an invalid vueCompilerOptions parsing setting", "Set files.gt.parsingFlags.vueCompilerOptions to an object containing only whitespace and delimiters"));
+		return;
+	}
+	for (const key of Object.keys(input)) if (key !== "whitespace" && key !== "delimiters") errors.push(optionError(`Found unsupported Vue compiler option "${key}" in gt.config.json`, "Configure only whitespace and delimiters in files.gt.parsingFlags.vueCompilerOptions"));
+	if (input.whitespace !== void 0) if (input.whitespace !== "condense" && input.whitespace !== "preserve") errors.push(optionError("Found an invalid Vue whitespace compiler option in gt.config.json", "Set whitespace to either \"condense\" or \"preserve\""));
+	else mergeOption(state, "whitespace", input.whitespace, { file: "gt.config.json" }, errors);
+	if (input.delimiters !== void 0) if (!isDelimiterPair(input.delimiters)) errors.push(optionError("Found invalid Vue interpolation delimiters in gt.config.json", "Set delimiters to exactly two non-empty strings, such as [\"[[\", \"]]\"]"));
+	else mergeOption(state, "delimiters", input.delimiters, { file: "gt.config.json" }, errors);
+}
+function readViteConfig(file, state, errors) {
+	const ast = parseConfig(file, errors);
+	if (!ast) return;
+	const pluginBindings = /* @__PURE__ */ new Set();
+	const namespaceBindings = /* @__PURE__ */ new Set();
+	const jsxPluginBindings = /* @__PURE__ */ new Set();
+	const jsxNamespaceBindings = /* @__PURE__ */ new Set();
+	const defineConfigBindings = /* @__PURE__ */ new Set();
+	traverse(ast, {
+		ImportDeclaration(importPath) {
+			if (importPath.node.source.value === "vite") {
+				for (const specifierPath of importPath.get("specifiers")) {
+					const specifier = specifierPath.node;
+					if (specifier.type !== "ImportSpecifier" || (specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value) !== "defineConfig") continue;
+					const binding = specifierPath.scope.getBinding(specifier.local.name);
+					if (binding) defineConfigBindings.add(binding);
+				}
+				return;
+			}
+			const moduleSource = importPath.node.source.value;
+			if (moduleSource !== "@vitejs/plugin-vue" && moduleSource !== "@vitejs/plugin-vue-jsx") return;
+			const targetPluginBindings = moduleSource === "@vitejs/plugin-vue-jsx" ? jsxPluginBindings : pluginBindings;
+			const targetNamespaceBindings = moduleSource === "@vitejs/plugin-vue-jsx" ? jsxNamespaceBindings : namespaceBindings;
+			for (const specifierPath of importPath.get("specifiers")) {
+				const specifier = specifierPath.node;
+				const binding = specifierPath.scope.getBinding(specifier.local.name);
+				if (!binding) continue;
+				if (specifier.type === "ImportNamespaceSpecifier") targetNamespaceBindings.add(binding);
+				else if (specifier.type === "ImportDefaultSpecifier" || specifier.type === "ImportSpecifier" && (specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value) === "default") targetPluginBindings.add(binding);
+			}
+		},
+		TSImportEqualsDeclaration(importPath) {
+			const reference = importPath.node.moduleReference;
+			if (reference.type !== "TSExternalModuleReference" || reference.expression.type !== "StringLiteral" || reference.expression.value !== "@vitejs/plugin-vue" && reference.expression.value !== "@vitejs/plugin-vue-jsx") return;
+			const binding = importPath.scope.getBinding(importPath.node.id.name);
+			if (!binding) return;
+			if (reference.expression.value === "@vitejs/plugin-vue-jsx") jsxNamespaceBindings.add(binding);
+			else namespaceBindings.add(binding);
+		},
+		VariableDeclarator(variablePath) {
+			const vueRequireKind = getPluginVueRequireKind(variablePath.node.init, "@vitejs/plugin-vue");
+			const jsxRequireKind = getPluginVueRequireKind(variablePath.node.init, "@vitejs/plugin-vue-jsx");
+			const requireKind = vueRequireKind ?? jsxRequireKind;
+			if (!requireKind) return;
+			const targetPluginBindings = jsxRequireKind ? jsxPluginBindings : pluginBindings;
+			const targetNamespaceBindings = jsxRequireKind ? jsxNamespaceBindings : namespaceBindings;
+			if (variablePath.node.id.type === "Identifier") {
+				const binding = variablePath.scope.getBinding(variablePath.node.id.name);
+				if (!binding) return;
+				if (requireKind === "namespace") targetNamespaceBindings.add(binding);
+				else targetPluginBindings.add(binding);
+				return;
+			}
+			if (requireKind !== "namespace" || variablePath.node.id.type !== "ObjectPattern") return;
+			for (const property of variablePath.node.id.properties) {
+				if (property.type !== "ObjectProperty" || readPropertyKey(property) !== "default") continue;
+				const localName = readBindingIdentifier(property.value);
+				const binding = localName ? variablePath.scope.getBinding(localName) : void 0;
+				if (binding) targetPluginBindings.add(binding);
+			}
+		}
+	});
+	const activeExport = findActiveConfigExport(ast, file, errors);
+	if (!activeExport) return;
+	const functionReturns = collectFunctionReturns(ast);
+	const configRoot = resolveActiveConfigRoot(activeExport.node, activeExport.scope, functionReturns, (callee, scope) => resolveConfigHelperCall(callee, scope, defineConfigBindings, void 0), /* @__PURE__ */ new Set());
+	if (!configRoot.ok) {
+		errors.push(dynamicConfigError(file, configRoot.node));
+		return;
+	}
+	const configObject = resolveStaticObject(configRoot.value.node, configRoot.value.scope, /* @__PURE__ */ new Set());
+	if (!configObject.ok) {
+		errors.push(dynamicConfigError(file, configObject.node));
+		return;
+	}
+	const plugins = configObject.value.entries.get("plugins");
+	if (!plugins) return;
+	const pluginContext = {
+		moduleSource: "@vitejs/plugin-vue",
+		namespaceBindings,
+		pluginBindings,
+		referencePositions: [...pluginBindings, ...namespaceBindings].flatMap((binding) => binding.referencePaths.map((reference) => reference.node.start).filter((position) => position !== null))
+	};
+	const calls = [];
+	const unresolved = collectActiveVuePluginCalls(plugins.node, plugins.scope, pluginContext, calls, /* @__PURE__ */ new Set());
+	if (unresolved) {
+		errors.push(dynamicConfigError(file, unresolved));
+		return;
+	}
+	if (calls.length > 1) {
+		errors.push(dynamicConfigError(file, calls[1].node));
+		return;
+	}
+	const call = calls[0];
+	if (call) {
+		const argument = call.node.arguments[0];
+		if (argument?.type === "SpreadElement" || argument?.type === "ArgumentPlaceholder") {
+			errors.push(dynamicConfigError(file, argument));
+			return;
+		}
+		if (argument) {
+			rejectCustomVueCompiler(argument, call.scope, file, errors);
+			readNestedCompilerOptions(argument, call.scope, ["template", "compilerOptions"], file, true, state, errors);
+		}
+	}
+	const jsxPluginContext = {
+		moduleSource: "@vitejs/plugin-vue-jsx",
+		namespaceBindings: jsxNamespaceBindings,
+		pluginBindings: jsxPluginBindings,
+		referencePositions: [...jsxPluginBindings, ...jsxNamespaceBindings].flatMap((binding) => binding.referencePaths.map((reference) => reference.node.start).filter((position) => position !== null))
+	};
+	const jsxCalls = [];
+	const unresolvedJSX = collectActiveVuePluginCalls(plugins.node, plugins.scope, jsxPluginContext, jsxCalls, /* @__PURE__ */ new Set());
+	if (unresolvedJSX) {
+		errors.push(dynamicVueJSXConfigError(file, unresolvedJSX));
+		return;
+	}
+	if (jsxCalls.length > 1) {
+		errors.push(dynamicVueJSXConfigError(file, jsxCalls[1].node));
+		return;
+	}
+	if (jsxCalls[0]) readVueJSXPluginOptions(jsxCalls[0], file, errors);
+}
+/** Rejects Vite JSX options that can invalidate source-to-VNode parity. */
+function readVueJSXPluginOptions(call, file, errors) {
+	const argument = call.node.arguments[0];
+	if (!argument) return;
+	if (argument.type === "SpreadElement" || argument.type === "ArgumentPlaceholder") {
+		errors.push(dynamicVueJSXConfigError(file, argument));
+		return;
+	}
+	const options = resolveStaticObject(argument, call.scope, /* @__PURE__ */ new Set());
+	if (!options.ok) {
+		errors.push(dynamicVueJSXConfigError(file, options.node));
+		return;
+	}
+	for (const [name, entry] of options.value.entries) {
+		let supported = false;
+		if (name === "optimize") supported = resolveStaticBoolean(entry.node, entry.scope, /* @__PURE__ */ new Set()) !== void 0;
+		else if (name === "transformOn") supported = resolveStaticBoolean(entry.node, entry.scope, /* @__PURE__ */ new Set()) === false;
+		else if (name === "enableObjectSlots" || name === "mergeProps") supported = resolveStaticBoolean(entry.node, entry.scope, /* @__PURE__ */ new Set()) === true;
+		else if (name === "resolveType") supported = resolveStaticBoolean(entry.node, entry.scope, /* @__PURE__ */ new Set()) === false;
+		else if (name === "pragma") supported = resolveStaticString(entry.node, entry.scope, /* @__PURE__ */ new Set()) === "";
+		else if (name === "defineComponentName") supported = isDefaultDefineComponentNames(entry.node, entry.scope, /* @__PURE__ */ new Set());
+		else if (name === "babelPlugins") supported = isDefinitelyEmptyArray(entry.node, entry.scope, /* @__PURE__ */ new Set());
+		else if (name === "tsPluginOptions") {
+			const resolved = resolveStaticObject(entry.node, entry.scope, /* @__PURE__ */ new Set());
+			supported = resolved.ok && resolved.value.entries.size === 0;
+		}
+		if (supported) continue;
+		errors.push(locatedOptionError(file, entry.node, `Found unsupported @vitejs/plugin-vue-jsx option "${name}"`, "Use default-equivalent Vue JSX options; only a static optimize value may differ in files containing gt-vue translations"));
+	}
+}
+/** Resolves an immutable boolean option without coercing another type. */
+function resolveStaticBoolean(input, scope, seen) {
+	const node = unwrapExpression(input);
+	if (node.type === "BooleanLiteral") return node.value;
+	if (node.type !== "Identifier") return void 0;
+	const binding = scope.getBinding(node.name);
+	if (!binding?.constant || bindingHasMutation(binding) || seen.has(binding)) return;
+	const declaration = binding.path.node;
+	if (declaration.type !== "VariableDeclarator" || !declaration.init) return;
+	const nextSeen = new Set(seen);
+	nextSeen.add(binding);
+	return resolveStaticBoolean(declaration.init, binding.path.scope, nextSeen);
+}
+/** Proves the explicit component-name option equals the plugin default. */
+function isDefaultDefineComponentNames(input, scope, seen) {
+	const node = unwrapExpression(input);
+	if (node.type === "ArrayExpression") return node.elements.length === 1 && node.elements[0]?.type === "StringLiteral" && node.elements[0].value === "defineComponent";
+	if (node.type !== "Identifier") return false;
+	const binding = scope.getBinding(node.name);
+	if (!binding?.constant || bindingHasMutation(binding) || seen.has(binding)) return false;
+	const declaration = binding.path.node;
+	if (declaration.type !== "VariableDeclarator" || !declaration.init) return false;
+	const nextSeen = new Set(seen);
+	nextSeen.add(binding);
+	return isDefaultDefineComponentNames(declaration.init, binding.path.scope, nextSeen);
+}
+/** Proves an immutable config value is an empty array. */
+function isDefinitelyEmptyArray(input, scope, seen) {
+	const node = unwrapExpression(input);
+	if (node.type === "ArrayExpression") return node.elements.length === 0;
+	if (node.type !== "Identifier") return false;
+	const binding = scope.getBinding(node.name);
+	if (!binding?.constant || bindingHasMutation(binding) || seen.has(binding)) return false;
+	const declaration = binding.path.node;
+	if (declaration.type !== "VariableDeclarator" || !declaration.init) return false;
+	const nextSeen = new Set(seen);
+	nextSeen.add(binding);
+	return isDefinitelyEmptyArray(declaration.init, binding.path.scope, nextSeen);
+}
+/**
+* Rejects Vite's custom compiler override because source-file resolution can
+* only prove parity with that app's `vue/compiler-sfc` export.
+*/
+function rejectCustomVueCompiler(root, scope, file, errors) {
+	const rootObject = resolveStaticObject(root, scope, /* @__PURE__ */ new Set());
+	if (!rootObject.ok) return;
+	const compiler = rootObject.value.entries.get("compiler");
+	if (!compiler) return;
+	errors.push(locatedOptionError(file, compiler.node, "Found a custom Vue compiler instance in the Vite plugin", "Remove the compiler override so extraction and Vite both use the app's vue/compiler-sfc version"));
+}
+function readNuxtConfig(file, state, errors) {
+	const ast = parseConfig(file, errors);
+	if (!ast) return;
+	const defineNuxtConfigBindings = /* @__PURE__ */ new Set();
+	traverse(ast, { ImportDeclaration(importPath) {
+		if (importPath.node.source.value !== "nuxt/config" && importPath.node.source.value !== "nuxt" && importPath.node.source.value !== "#imports") return;
+		for (const specifierPath of importPath.get("specifiers")) {
+			const specifier = specifierPath.node;
+			if (specifier.type !== "ImportSpecifier" || (specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value) !== "defineNuxtConfig") continue;
+			const binding = specifierPath.scope.getBinding(specifier.local.name);
+			if (binding) defineNuxtConfigBindings.add(binding);
+		}
+	} });
+	const activeExport = findActiveConfigExport(ast, file, errors);
+	if (!activeExport) return;
+	const configRoot = resolveActiveConfigRoot(activeExport.node, activeExport.scope, collectFunctionReturns(ast), (callee, scope) => resolveConfigHelperCall(callee, scope, defineNuxtConfigBindings, "defineNuxtConfig"), /* @__PURE__ */ new Set());
+	if (!configRoot.ok) {
+		errors.push(dynamicConfigError(file, configRoot.node));
+		return;
+	}
+	const configObject = resolveStaticObject(configRoot.value.node, configRoot.value.scope, /* @__PURE__ */ new Set());
+	if (!configObject.ok) {
+		errors.push(dynamicConfigError(file, configObject.node));
+		return;
+	}
+	const extendsEntry = configObject.value.entries.get("extends");
+	if (extendsEntry && !isDefinitelyEmptyNuxtExtends(extendsEntry.node, extendsEntry.scope)) {
+		errors.push(locatedOptionError(file, extendsEntry.node, "Found Nuxt layer inheritance that could change Vue compiler options", "Run extraction from a Nuxt configuration without inherited layers until gt-vue can resolve the complete layer chain safely"));
+		return;
+	}
+	const unsupportedSourceLayout = findUnsupportedNuxtSourceLayout(configObject.value);
+	if (unsupportedSourceLayout) {
+		errors.push(locatedOptionError(file, unsupportedSourceLayout, "Found custom Nuxt source directories that default Vue discovery cannot scan safely", "Use Nuxt source directories covered by the default app, src, pages, layouts, plugins, and related globs until custom directory discovery is supported"));
+		return;
+	}
+	readNestedCompilerOptions(configRoot.value.node, configRoot.value.scope, ["vue", "compilerOptions"], file, true, state, errors);
+}
+/** Finds a Nuxt source-layout override not covered by default CLI globs. */
+function findUnsupportedNuxtSourceLayout(config) {
+	const srcDir = config.entries.get("srcDir");
+	if (srcDir) {
+		const value = resolveStaticString(srcDir.node, srcDir.scope, /* @__PURE__ */ new Set());
+		const normalized = value ? path.posix.normalize(value.replaceAll("\\", "/")).replace(/\/+$/, "") || "." : void 0;
+		if (!normalized || ![
+			".",
+			"app",
+			"src"
+		].includes(normalized)) return srcDir.node;
+	}
+	const directoryOptions = config.entries.get("dir");
+	if (directoryOptions) {
+		const resolved = resolveStaticObject(directoryOptions.node, directoryOptions.scope, /* @__PURE__ */ new Set());
+		if (!resolved.ok || resolved.value.entries.size > 0) return directoryOptions.node;
+	}
+}
+/** Returns true only when a Nuxt extends value provably selects no layers. */
+function isDefinitelyEmptyNuxtExtends(input, scope) {
+	const node = unwrapExpression(input);
+	if (node.type === "NullLiteral") return true;
+	if (node.type === "ArrayExpression") return node.elements.length === 0;
+	if (node.type !== "Identifier") return false;
+	if (node.name === "undefined" && !scope.getBinding(node.name)) return true;
+	const binding = scope.getBinding(node.name);
+	const declaration = binding?.path.node;
+	return !!(binding?.constant && !bindingHasMutation(binding) && declaration?.type === "VariableDeclarator" && declaration.init && isDefinitelyEmptyNuxtExtends(declaration.init, binding.path.scope));
+}
+/** Returns the one top-level export that the config loader evaluates. */
+function findActiveConfigExport(ast, file, errors) {
+	const esmExports = [];
+	const commonJsExports = /* @__PURE__ */ new Map();
+	traverse(ast, {
+		ExportDefaultDeclaration(exportPath) {
+			esmExports.push({
+				node: exportPath.node.declaration,
+				scope: exportPath.scope
+			});
+		},
+		AssignmentExpression(assignmentPath) {
+			if (assignmentPath.node.operator !== "=" || assignmentPath.getFunctionParent() || !assignmentPath.parentPath.isExpressionStatement() || !assignmentPath.parentPath.parentPath?.isProgram()) return;
+			const kind = readCommonJsConfigExportKind(assignmentPath.node.left, assignmentPath.scope);
+			if (!kind) return;
+			const entries = commonJsExports.get(kind) ?? [];
+			entries.push({
+				node: assignmentPath.node.right,
+				scope: assignmentPath.scope
+			});
+			commonJsExports.set(kind, entries);
+		}
+	});
+	const commonJsKinds = [...commonJsExports.keys()];
+	if (esmExports.length > 1 || esmExports.length > 0 && commonJsKinds.length > 0 || commonJsKinds.length > 1) {
+		const node = esmExports[1]?.node ?? commonJsExports.get(commonJsKinds[1])?.[0]?.node ?? esmExports[0]?.node ?? ast.program;
+		errors.push(dynamicConfigError(file, node));
+		return;
+	}
+	if (esmExports[0]) return esmExports[0];
+	const commonJs = commonJsExports.get(commonJsKinds[0]);
+	return commonJs?.[commonJs.length - 1];
+}
+/** Records return expressions by their immediately containing function. */
+function collectFunctionReturns(ast) {
+	const result = /* @__PURE__ */ new Map();
+	traverse(ast, { ReturnStatement(returnPath) {
+		if (!returnPath.node.argument) return;
+		const functionPath = returnPath.getFunctionParent();
+		if (!functionPath) return;
+		const entries = result.get(functionPath.node) ?? [];
+		entries.push({
+			node: returnPath.node.argument,
+			scope: returnPath.scope
+		});
+		result.set(functionPath.node, entries);
+	} });
+	return result;
+}
+/** Resolves an exported object or single-return config function statically. */
+function resolveActiveConfigRoot(input, scope, functionReturns, resolveHelper, seen) {
+	const node = unwrapExpression(input);
+	if (seen.has(node)) return {
+		ok: false,
+		node
+	};
+	const nextSeen = new Set(seen);
+	nextSeen.add(node);
+	if (node.type === "ObjectExpression") return {
+		ok: true,
+		value: {
+			node,
+			scope
+		}
+	};
+	if (node.type === "Identifier") {
+		const binding = scope.getBinding(node.name);
+		if (!binding?.constant || bindingHasMutation(binding)) return {
+			ok: false,
+			node
+		};
+		if (binding.path.isFunctionDeclaration()) return resolveActiveConfigRoot(binding.path.node, binding.path.scope, functionReturns, resolveHelper, nextSeen);
+		const declaration = binding.path.node;
+		return declaration.type === "VariableDeclarator" && declaration.init ? resolveActiveConfigRoot(declaration.init, binding.path.scope, functionReturns, resolveHelper, nextSeen) : {
+			ok: false,
+			node
+		};
+	}
+	if (node.type === "CallExpression" || node.type === "OptionalCallExpression") {
+		if (resolveHelper(node.callee, scope) !== "static") return {
+			ok: false,
+			node: node.callee
+		};
+		const argument = node.arguments[0];
+		return argument && argument.type !== "SpreadElement" && argument.type !== "ArgumentPlaceholder" ? resolveActiveConfigRoot(argument, scope, functionReturns, resolveHelper, nextSeen) : {
+			ok: false,
+			node
+		};
+	}
+	if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration") {
+		if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") return resolveActiveConfigRoot(node.body, scope, functionReturns, resolveHelper, nextSeen);
+		const returns = functionReturns.get(node) ?? [];
+		return returns.length === 1 ? resolveActiveConfigRoot(returns[0].node, returns[0].scope, functionReturns, resolveHelper, nextSeen) : {
+			ok: false,
+			node
+		};
+	}
+	if (node.type === "ConditionalExpression") {
+		const condition = resolveStaticTruthiness(node.test, scope, /* @__PURE__ */ new Set());
+		return condition === void 0 ? {
+			ok: false,
+			node
+		} : resolveActiveConfigRoot(condition ? node.consequent : node.alternate, scope, functionReturns, resolveHelper, nextSeen);
+	}
+	if (node.type === "SequenceExpression") {
+		const last = node.expressions[node.expressions.length - 1];
+		return last ? resolveActiveConfigRoot(last, scope, functionReturns, resolveHelper, nextSeen) : {
+			ok: false,
+			node
+		};
+	}
+	if (node.type === "AwaitExpression") return resolveActiveConfigRoot(node.argument, scope, functionReturns, resolveHelper, nextSeen);
+	return {
+		ok: false,
+		node
+	};
+}
+/** Resolves imported/global config helpers and their immutable aliases. */
+function resolveConfigHelperCall(input, scope, knownBindings, globalName, seen = /* @__PURE__ */ new Set()) {
+	const node = unwrapExpression(input);
+	if (node.type !== "Identifier") return void 0;
+	const binding = scope.getBinding(node.name);
+	if (!binding) return node.name === globalName ? "static" : void 0;
+	if (knownBindings.has(binding)) return "static";
+	if (seen.has(binding)) return void 0;
+	const declaration = binding.path.node;
+	if (declaration.type !== "VariableDeclarator" || !declaration.init) return;
+	const nextSeen = new Set(seen);
+	nextSeen.add(binding);
+	const initialValue = resolveConfigHelperCall(declaration.init, binding.path.scope, knownBindings, globalName, nextSeen);
+	return !binding.constant && initialValue ? "dynamic" : initialValue;
+}
+/** Collects Vue plugin calls reachable through the active `plugins` value. */
+function collectActiveVuePluginCalls(input, scope, context, calls, seen) {
+	const node = unwrapExpression(input);
+	if (node.type === "Identifier") {
+		const value = resolvePluginVueValue(node, scope, context.pluginBindings, context.namespaceBindings, context.moduleSource, /* @__PURE__ */ new Set());
+		if (value === "dynamic" || value === "default") return node;
+		const binding = scope.getBinding(node.name);
+		if (!binding || seen.has(binding)) return mayReferenceVuePlugin(node, scope, context, /* @__PURE__ */ new Set()) ? node : void 0;
+		const declaration = binding.path.node;
+		if (declaration.type !== "VariableDeclarator" || !declaration.init) return mayReferenceVuePlugin(node, scope, context, /* @__PURE__ */ new Set()) ? node : void 0;
+		if (bindingHasMutation(binding)) return node;
+		if (!binding.constant) return mayReferenceVuePlugin(declaration.init, binding.path.scope, context, /* @__PURE__ */ new Set()) ? node : void 0;
+		const nextSeen = new Set(seen);
+		nextSeen.add(binding);
+		return collectActiveVuePluginCalls(declaration.init, binding.path.scope, context, calls, nextSeen);
+	}
+	if (node.type === "ArrayExpression") {
+		for (const element of node.elements) {
+			if (!element) continue;
+			const unresolved = collectActiveVuePluginCalls(element.type === "SpreadElement" ? element.argument : element, scope, context, calls, seen);
+			if (unresolved) return unresolved;
+		}
+		return;
+	}
+	if (node.type === "CallExpression" || node.type === "OptionalCallExpression") {
+		const value = resolvePluginVueValue(node.callee, scope, context.pluginBindings, context.namespaceBindings, context.moduleSource, /* @__PURE__ */ new Set());
+		if (value === "dynamic") return node.callee;
+		if (value === "default") {
+			calls.push({
+				node,
+				scope
+			});
+			return;
+		}
+		return mayReferenceVuePlugin(node, scope, context, /* @__PURE__ */ new Set()) ? node : void 0;
+	}
+	if (node.type === "ConditionalExpression") {
+		const condition = resolveStaticTruthiness(node.test, scope, /* @__PURE__ */ new Set());
+		if (condition !== void 0) return collectActiveVuePluginCalls(condition ? node.consequent : node.alternate, scope, context, calls, seen);
+		return mayReferenceVuePlugin(node, scope, context, /* @__PURE__ */ new Set()) ? node : void 0;
+	}
+	if (node.type === "LogicalExpression") {
+		const left = resolveStaticTruthiness(node.left, scope, /* @__PURE__ */ new Set());
+		if (left !== void 0) {
+			const selected = node.operator === "&&" ? left ? node.right : node.left : node.operator === "||" ? left ? node.left : node.right : void 0;
+			if (selected) return collectActiveVuePluginCalls(selected, scope, context, calls, seen);
+		}
+		return mayReferenceVuePlugin(node, scope, context, /* @__PURE__ */ new Set()) ? node : void 0;
+	}
+	if (node.type === "SequenceExpression") {
+		const last = node.expressions[node.expressions.length - 1];
+		return last ? collectActiveVuePluginCalls(last, scope, context, calls, seen) : void 0;
+	}
+	return mayReferenceVuePlugin(node, scope, context, /* @__PURE__ */ new Set()) ? node : void 0;
+}
+/** Conservatively follows wrapper bindings that reference the Vue plugin. */
+function mayReferenceVuePlugin(input, scope, context, seen) {
+	const node = unwrapExpression(input);
+	const start = node.start;
+	const end = node.end;
+	if (typeof start === "number" && typeof end === "number" && context.referencePositions.some((position) => position >= start && position <= end)) return true;
+	const target = node.type === "Identifier" ? node : node.type === "CallExpression" || node.type === "OptionalCallExpression" ? unwrapExpression(node.callee) : void 0;
+	if (target?.type !== "Identifier") return false;
+	const binding = scope.getBinding(target.name);
+	if (!binding) return false;
+	if (context.pluginBindings.has(binding) || context.namespaceBindings.has(binding)) return true;
+	if (seen.has(binding)) return false;
+	const nextSeen = new Set(seen);
+	nextSeen.add(binding);
+	const declaration = binding.path.node;
+	if (declaration.type === "VariableDeclarator" && declaration.init) return mayReferenceVuePlugin(declaration.init, binding.path.scope, context, nextSeen);
+	const declarationStart = declaration.start;
+	const declarationEnd = declaration.end;
+	return typeof declarationStart === "number" && typeof declarationEnd === "number" && context.referencePositions.some((position) => position >= declarationStart && position <= declarationEnd);
+}
+/** Evaluates only primitive truthiness used to choose a static config branch. */
+function resolveStaticTruthiness(input, scope, seen) {
+	const node = unwrapExpression(input);
+	if (node.type === "BooleanLiteral") return node.value;
+	if (node.type === "NullLiteral") return false;
+	if (node.type === "NumericLiteral") return !!node.value;
+	if (node.type === "BigIntLiteral") return node.value !== "0";
+	if (node.type === "StringLiteral") return node.value.length > 0;
+	if (node.type === "UnaryExpression" && node.operator === "!") {
+		const value = resolveStaticTruthiness(node.argument, scope, seen);
+		return value === void 0 ? void 0 : !value;
+	}
+	if (node.type !== "Identifier") return void 0;
+	if (node.name === "undefined" && !scope.getBinding(node.name)) return false;
+	const binding = scope.getBinding(node.name);
+	if (!binding?.constant || bindingHasMutation(binding) || seen.has(binding)) return;
+	const declaration = binding.path.node;
+	if (declaration.type !== "VariableDeclarator" || !declaration.init) return;
+	const nextSeen = new Set(seen);
+	nextSeen.add(binding);
+	return resolveStaticTruthiness(declaration.init, binding.path.scope, nextSeen);
+}
+function readNestedCompilerOptions(root, scope, keys, file, failOnDynamicRoot, state, errors) {
+	const rootObject = resolveStaticObject(root, scope, /* @__PURE__ */ new Set());
+	if (!rootObject.ok) {
+		if (failOnDynamicRoot) errors.push(dynamicConfigError(file, rootObject.node));
+		return;
+	}
+	const parentEntry = rootObject.value.entries.get(keys[0]);
+	if (!parentEntry) return;
+	const parentObject = resolveStaticObject(parentEntry.node, parentEntry.scope, /* @__PURE__ */ new Set());
+	if (!parentObject.ok) {
+		errors.push(dynamicConfigError(file, parentObject.node));
+		return;
+	}
+	const compilerEntry = parentObject.value.entries.get(keys[1]);
+	if (!compilerEntry) return;
+	const compilerObject = resolveStaticObject(compilerEntry.node, compilerEntry.scope, /* @__PURE__ */ new Set());
+	if (!compilerObject.ok) {
+		errors.push(dynamicConfigError(file, compilerObject.node));
+		return;
+	}
+	readCompilerOptionsObject(compilerObject.value, file, state, errors);
+}
+function readCompilerOptionsObject(object, file, state, errors) {
+	for (const [key, entry] of object.entries) if (key !== "whitespace" && key !== "delimiters") errors.push(locatedOptionError(file, entry.node, `Found unsupported Vue compiler option "${key}"`, "gt-vue extraction currently supports only static whitespace and delimiters compiler options"));
+	const whitespaceEntry = object.entries.get("whitespace");
+	if (whitespaceEntry) {
+		const value = resolveStaticString(whitespaceEntry.node, whitespaceEntry.scope, /* @__PURE__ */ new Set());
+		if (value !== "condense" && value !== "preserve") errors.push(dynamicConfigError(file, whitespaceEntry.node));
+		else mergeOption(state, "whitespace", value, {
+			file,
+			node: whitespaceEntry.node
+		}, errors);
+	}
+	const delimitersEntry = object.entries.get("delimiters");
+	if (delimitersEntry) {
+		const value = resolveStaticDelimiters(delimitersEntry.node, delimitersEntry.scope, /* @__PURE__ */ new Set());
+		if (!value) errors.push(dynamicConfigError(file, delimitersEntry.node));
+		else mergeOption(state, "delimiters", value, {
+			file,
+			node: delimitersEntry.node
+		}, errors);
+	}
+}
+function resolveStaticObject(input, scope, seen) {
+	const node = unwrapExpression(input);
+	if (seen.has(node)) return {
+		ok: false,
+		node
+	};
+	seen.add(node);
+	if (node.type === "Identifier") {
+		const binding = scope.getBinding(node.name);
+		const declaration = binding?.path.node;
+		if (!binding?.constant || bindingHasMutation(binding) || declaration?.type !== "VariableDeclarator" || !declaration.init) return {
+			ok: false,
+			node
+		};
+		return resolveStaticObject(declaration.init, binding.path.scope, seen);
+	}
+	if (node.type !== "ObjectExpression") return {
+		ok: false,
+		node
+	};
+	const entries = /* @__PURE__ */ new Map();
+	for (const property of node.properties) {
+		if (property.type === "SpreadElement") {
+			const spread = resolveStaticObject(property.argument, scope, seen);
+			if (!spread.ok) return {
+				ok: false,
+				node: spread.node
+			};
+			for (const [key, entry] of spread.value.entries) entries.set(key, entry);
+			continue;
+		}
+		const key = readPropertyKey(property);
+		if (!key) return {
+			ok: false,
+			node: property
+		};
+		if (property.type !== "ObjectProperty") {
+			entries.set(key, {
+				node: property,
+				scope
+			});
+			continue;
+		}
+		entries.set(key, {
+			node: property.value,
+			scope
+		});
+	}
+	return {
+		ok: true,
+		value: { entries }
+	};
+}
+function resolveStaticString(input, scope, seen) {
+	const node = unwrapExpression(input);
+	if (seen.has(node)) return void 0;
+	seen.add(node);
+	if (node.type === "StringLiteral") return node.value;
+	if (node.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis.map((quasi) => quasi.value.cooked ?? quasi.value.raw).join("");
+	if (node.type !== "Identifier") return void 0;
+	const binding = scope.getBinding(node.name);
+	const declaration = binding?.path.node;
+	return binding?.constant && !bindingHasMutation(binding) && declaration?.type === "VariableDeclarator" && declaration.init ? resolveStaticString(declaration.init, binding.path.scope, seen) : void 0;
+}
+function resolveStaticDelimiters(input, scope, seen) {
+	const node = unwrapExpression(input);
+	if (seen.has(node)) return void 0;
+	seen.add(node);
+	if (node.type === "Identifier") {
+		const binding = scope.getBinding(node.name);
+		const declaration = binding?.path.node;
+		return binding?.constant && !bindingHasMutation(binding) && declaration?.type === "VariableDeclarator" && declaration.init ? resolveStaticDelimiters(declaration.init, binding.path.scope, seen) : void 0;
+	}
+	if (node.type !== "ArrayExpression" || node.elements.length !== 2) return;
+	const values = node.elements.map((element) => element && element.type !== "SpreadElement" ? resolveStaticString(element, scope, /* @__PURE__ */ new Set()) : void 0);
+	return isDelimiterPair(values) ? values : void 0;
+}
+function unwrapExpression(input) {
+	let node = input;
+	while (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression" || node.type === "TypeCastExpression" || node.type === "ParenthesizedExpression") node = node.expression;
+	return node;
+}
+function readPropertyKey(property) {
+	if (!property.computed && property.key.type === "Identifier") return property.key.name;
+	if (property.key.type === "StringLiteral") return property.key.value;
+}
+function getPluginVueRequireKind(input, moduleSource) {
+	if (!input) return void 0;
+	const node = unwrapExpression(input);
+	if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "require" && node.arguments[0]?.type === "StringLiteral" && node.arguments[0].value === moduleSource) return "namespace";
+	if ((node.type === "MemberExpression" || node.type === "OptionalMemberExpression") && isDefaultMember(node)) return getPluginVueRequireKind(node.object, moduleSource) ? "default" : void 0;
+}
+/** Resolves immutable aliases of the Vue Vite plugin without executing config. */
+function resolvePluginVueValue(input, scope, pluginBindings, namespaceBindings, moduleSource, seen) {
+	const node = unwrapExpression(input);
+	const requireKind = node.type === "CallExpression" || node.type === "MemberExpression" || node.type === "OptionalMemberExpression" ? getPluginVueRequireKind(node, moduleSource) : void 0;
+	if (requireKind) return requireKind;
+	if (node.type === "Identifier") {
+		const binding = scope.getBinding(node.name);
+		if (!binding) return void 0;
+		if (pluginBindings.has(binding)) return "default";
+		if (namespaceBindings.has(binding)) return "namespace";
+		if (seen.has(binding)) return void 0;
+		const declaration = binding.path.node;
+		if (declaration.type !== "VariableDeclarator" || !declaration.init) return;
+		const nextSeen = new Set(seen);
+		nextSeen.add(binding);
+		const initialValue = resolvePluginVueValue(declaration.init, binding.path.scope, pluginBindings, namespaceBindings, moduleSource, nextSeen);
+		return !binding.constant && initialValue ? "dynamic" : initialValue;
+	}
+	if ((node.type === "MemberExpression" || node.type === "OptionalMemberExpression") && isDefaultMember(node)) {
+		const objectValue = resolvePluginVueValue(node.object, scope, pluginBindings, namespaceBindings, moduleSource, seen);
+		if (objectValue === "dynamic") return "dynamic";
+		if (objectValue === "namespace") return "default";
+	}
+}
+/** Recognizes every static spelling of a module namespace default export. */
+function isDefaultMember(node) {
+	return !node.computed && node.property.type === "Identifier" && node.property.name === "default" || node.computed && node.property.type === "StringLiteral" && node.property.value === "default";
+}
+/** Classifies supported unshadowed CommonJS config exports. */
+function readCommonJsConfigExportKind(node, scope) {
+	if (node.type !== "MemberExpression" || node.object.type !== "Identifier" || !(!node.computed && node.property.type === "Identifier" || node.computed && node.property.type === "StringLiteral")) return;
+	const property = node.property.type === "Identifier" ? node.property.name : node.property.value;
+	if (node.object.name === "module" && property === "exports" && !scope.getBinding("module")) return "module-exports";
+	return node.object.name === "exports" && property === "default" && !scope.getBinding("exports") ? "exports-default" : void 0;
+}
+function readBindingIdentifier(node) {
+	if (node.type === "Identifier") return node.name;
+	return node.type === "AssignmentPattern" && node.left.type === "Identifier" ? node.left.name : void 0;
+}
+const MUTATING_METHODS = new Set([
+	"clear",
+	"copyWithin",
+	"delete",
+	"fill",
+	"pop",
+	"push",
+	"reverse",
+	"set",
+	"shift",
+	"sort",
+	"splice",
+	"unshift"
+]);
+/** Detects property, collection, and alias mutations Babel does not mark constant. */
+function bindingHasMutation(binding, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(binding)) return false;
+	const nextSeen = new Set(seen);
+	nextSeen.add(binding);
+	for (const reference of binding.referencePaths) {
+		let current = reference;
+		while (current.parentPath && (current.parentPath.isMemberExpression() || current.parentPath.isOptionalMemberExpression()) && current.parentPath.node.object === current.node) current = current.parentPath;
+		const parent = current.parentPath;
+		if (parent?.isAssignmentExpression() && parent.node.left === current.node || parent?.isUpdateExpression() && parent.node.argument === current.node || parent?.isUnaryExpression({ operator: "delete" }) && parent.node.argument === current.node) return true;
+		if (parent?.isCallExpression() || parent?.isOptionalCallExpression()) {
+			if (parent.node.callee === current.node && (current.isMemberExpression() || current.isOptionalMemberExpression()) && MUTATING_METHODS.has(readStaticMemberName(current.node) ?? "")) return true;
+			if (parent.node.arguments[0] === current.node && isGlobalMutationCall(parent.node.callee, parent.scope)) return true;
+			if (parent.node.arguments.some((argument) => argument === current.node) && !isKnownReadOnlyConfigConsumer(parent.node, current.node, parent.scope)) return true;
+		}
+		const aliasParent = reference.parentPath;
+		if (aliasParent?.isVariableDeclarator() && aliasParent.node.init === reference.node && aliasParent.node.id.type === "Identifier") {
+			const alias = aliasParent.scope.getBinding(aliasParent.node.id.name);
+			if (alias && bindingHasMutation(alias, nextSeen)) return true;
+		}
+		if (aliasParent?.isVariableDeclarator() && aliasParent.node.init === reference.node && aliasParent.node.id.type !== "Identifier") for (const name of collectBindingNames(aliasParent.node.id)) {
+			const alias = aliasParent.scope.getBinding(name);
+			if (alias && bindingHasMutation(alias, nextSeen)) return true;
+		}
+		if (parent?.isAssignmentExpression({ operator: "=" }) && parent.node.right === current.node) for (const name of collectBindingNames(parent.node.left)) {
+			const alias = parent.scope.getBinding(name);
+			if (alias && bindingHasMutation(alias, nextSeen)) return true;
+		}
+	}
+	return false;
+}
+function collectBindingNames(input) {
+	if (input.type === "Identifier") return [input.name];
+	if (input.type === "AssignmentPattern") return collectBindingNames(input.left);
+	if (input.type === "RestElement") return collectBindingNames(input.argument);
+	if (input.type === "ArrayPattern") return input.elements.flatMap((element) => element ? collectBindingNames(element) : []);
+	if (input.type === "ObjectPattern") return input.properties.flatMap((property) => property.type === "RestElement" ? collectBindingNames(property.argument) : collectBindingNames(property.value));
+	return [];
+}
+function readStaticMemberName(node) {
+	if (!node.computed && node.property.type === "Identifier") return node.property.name;
+	return node.computed && node.property.type === "StringLiteral" ? node.property.value : void 0;
+}
+function isGlobalMutationCall(input, scope) {
+	const node = unwrapExpression(input);
+	if (node.type !== "MemberExpression" && node.type !== "OptionalMemberExpression") return false;
+	const method = readStaticMemberName(node);
+	if (node.object.type !== "Identifier" || scope.getBinding(node.object.name)) return false;
+	return node.object.name === "Object" && (method === "assign" || method === "defineProperty" || method === "defineProperties") || node.object.name === "Reflect" && (method === "set" || method === "deleteProperty");
+}
+function isKnownReadOnlyConfigConsumer(call, argument, scope) {
+	if (resolveKnownConfigConsumer(call.callee, scope, /* @__PURE__ */ new Set())) return true;
+	const callee = unwrapExpression(call.callee);
+	if (callee.type !== "MemberExpression" && callee.type !== "OptionalMemberExpression") return false;
+	const method = readStaticMemberName(callee);
+	if (callee.object.type !== "Identifier" || scope.getBinding(callee.object.name)) return false;
+	const argumentIndex = call.arguments.findIndex((candidate) => candidate === argument);
+	if (callee.object.name === "Object") {
+		if (method === "assign") return argumentIndex > 0;
+		return new Set([
+			"entries",
+			"freeze",
+			"getOwnPropertyDescriptor",
+			"getOwnPropertyDescriptors",
+			"getOwnPropertyNames",
+			"getOwnPropertySymbols",
+			"isExtensible",
+			"isFrozen",
+			"isSealed",
+			"keys",
+			"preventExtensions",
+			"seal",
+			"values"
+		]).has(method ?? "");
+	}
+	return callee.object.name === "Array" && method === "isArray" || callee.object.name === "JSON" && method === "stringify";
+}
+function resolveKnownConfigConsumer(input, scope, seen) {
+	const node = unwrapExpression(input);
+	if (node.type === "Identifier") {
+		const binding = scope.getBinding(node.name);
+		if (!binding) return node.name === "defineNuxtConfig";
+		if (seen.has(binding)) return false;
+		if (binding.path.isImportDefaultSpecifier()) {
+			const declaration = binding.path.parentPath;
+			return declaration.isImportDeclaration() && (declaration.node.source.value === "@vitejs/plugin-vue" || declaration.node.source.value === "@vitejs/plugin-vue-jsx");
+		}
+		if (binding.path.isImportSpecifier()) {
+			const declaration = binding.path.parentPath;
+			if (!declaration.isImportDeclaration()) return false;
+			const imported = binding.path.node.imported;
+			const name = imported.type === "Identifier" ? imported.name : imported.value;
+			const source = declaration.node.source.value;
+			return (source === "@vitejs/plugin-vue" || source === "@vitejs/plugin-vue-jsx") && name === "default" || source === "vite" && name === "defineConfig" || (source === "nuxt" || source === "nuxt/config" || source === "#imports") && name === "defineNuxtConfig";
+		}
+		const declaration = binding.path.node;
+		if (binding.constant && declaration.type === "VariableDeclarator" && declaration.init) {
+			const nextSeen = new Set(seen);
+			nextSeen.add(binding);
+			return resolveKnownConfigConsumer(declaration.init, binding.path.scope, nextSeen);
+		}
+		return false;
+	}
+	return (node.type === "MemberExpression" || node.type === "OptionalMemberExpression") && isDefaultMember(node) && (getPluginVueRequireKind(node, "@vitejs/plugin-vue") === "default" || getPluginVueRequireKind(node, "@vitejs/plugin-vue-jsx") === "default");
+}
+function parseConfig(file, errors) {
+	const source = fs.readFileSync(file, "utf8");
+	try {
+		return parse(source, {
+			sourceType: "unambiguous",
+			plugins: parserPlugins(file)
+		});
+	} catch (error) {
+		if (!/compilerOptions|whitespace|delimiters|@vitejs\/plugin-vue-jsx|babelPlugins|pragma/.test(source)) return;
+		const syntaxError = error;
+		errors.push(withLocation(file, createDiagnosticMessage({
+			whatHappened: "Could not parse a project configuration containing Vue compiler options",
+			details: syntaxError.message,
+			fix: "Use a statically analyzable Vite or Nuxt configuration, or configure files.gt.parsingFlags.vueCompilerOptions explicitly"
+		}), syntaxError.loc ? `${syntaxError.loc.line}:${syntaxError.loc.column + 1}` : void 0));
+		return;
+	}
+}
+function parserPlugins(file) {
+	const extension = path.extname(file).toLowerCase();
+	const plugins = [];
+	if (extension === ".ts" || extension === ".mts" || extension === ".cts" || extension === ".tsx") plugins.push("typescript", "decorators-legacy");
+	if (extension === ".jsx" || extension === ".tsx") plugins.push("jsx");
+	return plugins;
+}
+function mergeOption(state, key, value, source, errors) {
+	const existing = state.options[key];
+	if (existing !== void 0 && !sameOption(existing, value)) {
+		errors.push(locatedOptionError(source.file, source.node, `Found conflicting Vue ${key} compiler options`, "Use the same Vue compiler options in the project configuration and files.gt.parsingFlags.vueCompilerOptions"));
+		return;
+	}
+	Object.assign(state.options, { [key]: value });
+	state.sources[key] ??= source;
+}
+function sameOption(first, second) {
+	return Array.isArray(first) && Array.isArray(second) ? first[0] === second[0] && first[1] === second[1] : first === second;
+}
+function isRecord(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isDelimiterPair(value) {
+	return Array.isArray(value) && value.length === 2 && value.every((delimiter) => typeof delimiter === "string" && delimiter.length > 0);
+}
+function dynamicConfigError(file, node) {
+	return locatedOptionError(file, node, "Could not statically resolve Vue compiler options", "Use static object and string literals for Vue whitespace and delimiters compiler options so extraction hashes match the compiled app");
+}
+function dynamicVueJSXConfigError(file, node) {
+	return locatedOptionError(file, node, "Could not statically resolve @vitejs/plugin-vue-jsx options", "Use one statically configured Vue JSX plugin with the default VNode transform so extraction hashes match the compiled app");
+}
+function locatedOptionError(file, node, whatHappened, fix) {
+	return withLocation(file, createDiagnosticMessage({
+		whatHappened,
+		fix
+	}), node?.loc ? `${node.loc.start.line}:${node.loc.start.column + 1}` : void 0);
+}
+function optionError(whatHappened, fix) {
+	return createDiagnosticMessage({
+		whatHappened,
+		fix
+	});
+}
+function withLocation(file, message, location) {
+	return `${file}${location ? ` (${location})` : ""}: ${message}`;
+}
+//#endregion
+export { resolveVueCompilerOptions };
+
+//# sourceMappingURL=resolveVueCompilerOptions.js.map