@generaltranslation/vue-extractor 0.0.0 → 0.1.0-iris.0

package/dist/internal/project/viteAliases.js

@@ -0,0 +1,1020 @@
+import { NUXT_CONFIG_FILES, VITE_CONFIG_EXTENSIONS, VITE_CONFIG_FILES } from "../config/configFiles.js";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { parse } from "@babel/parser";
+import traverseModule from "@babel/traverse";
+import { fileURLToPath, pathToFileURL } from "node:url";
+//#region src/internal/project/viteAliases.ts
+const traverse = traverseModule.default || traverseModule;
+/**
+* Reads string aliases from statically analyzable Vite and Nuxt config.
+*
+* Config files are parsed as source and are never imported or executed.
+* Dynamic aliases, regular-expression find values, and unsupported syntax are
+* ignored so alias discovery cannot make otherwise valid extraction fatal.
+*/
+function resolveVueProjectAliases(cwd, options = {}) {
+	return resolveVueProjectAliasConfiguration(cwd, options).aliases;
+}
+/**
+* Resolves aliases and reports whether the active alias surface was proven.
+*
+* Incomplete analysis never returns partial aliases. This lets project-level
+* integrations distinguish a project with no configured aliases from one
+* whose dynamic resolver behavior must block safe static extraction.
+*/
+function resolveVueProjectAliasConfiguration(cwd, options = {}) {
+	const packageRoot = path.resolve(cwd);
+	const hasExplicitConfig = options.viteConfigPath !== void 0;
+	const explicitConfig = options.viteConfigPath !== void 0 ? resolveExplicitConfig(packageRoot, options.viteConfigPath) : void 0;
+	const discovery = hasExplicitConfig ? explicitConfig ? {
+		complete: true,
+		source: {
+			file: explicitConfig,
+			kind: "vite"
+		}
+	} : { complete: false } : discoverConfigSource(packageRoot);
+	if (!discovery.complete) return incompleteAliasConfiguration();
+	if (!discovery.source) return completeAliasConfiguration();
+	return readConfigAliases(discovery.source, packageRoot, options.nuxtMajorVersion);
+}
+function discoverConfigSource(cwd) {
+	const viteConfig = findFirstConfig(cwd, VITE_CONFIG_FILES);
+	const nuxtConfig = findFirstConfig(cwd, NUXT_CONFIG_FILES);
+	if (!viteConfig.complete || !nuxtConfig.complete) return { complete: false };
+	if (viteConfig.file && nuxtConfig.file) return { complete: false };
+	if (nuxtConfig.file) return {
+		complete: true,
+		source: {
+			file: nuxtConfig.file,
+			kind: "nuxt"
+		}
+	};
+	if (viteConfig.file) return {
+		complete: true,
+		source: {
+			file: viteConfig.file,
+			kind: "vite"
+		}
+	};
+	return { complete: true };
+}
+function findFirstConfig(cwd, filenames) {
+	for (const filename of filenames) {
+		const candidate = path.join(cwd, filename);
+		try {
+			return fs.statSync(candidate).isFile() ? {
+				complete: true,
+				file: candidate
+			} : { complete: false };
+		} catch (error) {
+			if (isMissingPathError(error)) continue;
+			return { complete: false };
+		}
+	}
+	return { complete: true };
+}
+function resolveExplicitConfig(cwd, configuredPath) {
+	if (!configuredPath.trim()) return void 0;
+	const candidate = path.resolve(cwd, configuredPath);
+	if (!isInsideDirectory(cwd, candidate)) return void 0;
+	if (!VITE_CONFIG_EXTENSIONS.has(path.extname(candidate).toLowerCase())) return;
+	try {
+		if (!fs.statSync(candidate).isFile()) return void 0;
+		const realRoot = fs.realpathSync(cwd);
+		const realCandidate = fs.realpathSync(candidate);
+		if (!isInsideDirectory(realRoot, realCandidate)) return void 0;
+		if (path.relative(realRoot, realCandidate).split(path.sep).includes("node_modules")) return;
+		return candidate;
+	} catch {
+		return;
+	}
+}
+function isInsideDirectory(root, candidate) {
+	const relative = path.relative(root, candidate);
+	return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function isMissingPathError(error) {
+	return Boolean(error && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR"));
+}
+function completeAliasConfiguration(aliases = /* @__PURE__ */ new Map()) {
+	return {
+		aliases,
+		complete: true
+	};
+}
+function incompleteAliasConfiguration(potentialAliasKeys = [], potentialAliases = /* @__PURE__ */ new Map()) {
+	const keys = new Set(potentialAliasKeys);
+	const aliases = clonePotentialAliases(potentialAliases);
+	for (const key of aliases.keys()) keys.add(key);
+	return {
+		aliases: /* @__PURE__ */ new Map(),
+		complete: false,
+		...aliases.size > 0 && { potentialAliases: aliases },
+		...keys.size > 0 && { potentialAliasKeys: keys }
+	};
+}
+function collectAliasResolutionKeys(...sources) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const source of sources) {
+		if (!source) continue;
+		if ("ok" in source) {
+			addAll(keys, source.ok ? source.aliases.entries.map(([find]) => find) : source.potentialAliasKeys);
+			continue;
+		}
+		for (const [find] of source.entries) keys.add(find);
+	}
+	return keys;
+}
+function collectAliasResolutionCandidates(...sources) {
+	const aliases = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		if (!source) continue;
+		if ("ok" in source) {
+			if (source.ok) for (const [find, replacement] of source.aliases.entries) addPotentialAlias(aliases, find, replacement);
+			else mergePotentialAliases(aliases, source.potentialAliases);
+			continue;
+		}
+		for (const [find, replacement] of source.entries) addPotentialAlias(aliases, find, replacement);
+	}
+	return aliases;
+}
+function readConfigAliases(source, packageRoot, configuredNuxtMajor) {
+	const ast = parseConfig(source.file);
+	if (!ast) return incompleteAliasConfiguration();
+	const { helpers, scopes } = collectAnalysisContext(ast);
+	const activeExport = findActiveConfigExport(ast);
+	if (!activeExport) return incompleteAliasConfiguration();
+	const context = {
+		configFile: source.file,
+		helpers,
+		nuxtMajorVersion: configuredNuxtMajor ?? readInstalledNuxtMajor(packageRoot),
+		packageRoot,
+		scopes
+	};
+	const root = resolveConfigRoot(activeExport, context, /* @__PURE__ */ new Set());
+	const config = root ? resolveStaticObject(root, context, /* @__PURE__ */ new Set(), "config") : void 0;
+	if (!config) return incompleteAliasConfiguration();
+	if (source.kind === "vite") {
+		const aliases = readNestedAliasObject(config, ["resolve", "alias"], context);
+		if (!aliases) return completeAliasConfiguration();
+		return aliases.ok ? completeAliasConfiguration(toFirstMatchMap(aliases.aliases.entries)) : incompleteAliasConfiguration(aliases.potentialAliasKeys, aliases.potentialAliases);
+	}
+	const builtInAliases = readNuxtBuiltInAliases(config, context);
+	if (!builtInAliases) return incompleteAliasConfiguration();
+	const configuredNuxtAliases = readNestedAliasObject(config, ["alias"], context);
+	const viteAliases = readNestedAliasObject(config, [
+		"vite",
+		"resolve",
+		"alias"
+	], context);
+	if (configuredNuxtAliases && !configuredNuxtAliases.ok) return incompleteAliasConfiguration(collectAliasResolutionKeys(builtInAliases, configuredNuxtAliases, viteAliases), collectAliasResolutionCandidates(builtInAliases, configuredNuxtAliases, viteAliases));
+	if (viteAliases && !viteAliases.ok) return incompleteAliasConfiguration(collectAliasResolutionKeys(builtInAliases, configuredNuxtAliases, viteAliases), collectAliasResolutionCandidates(builtInAliases, configuredNuxtAliases, viteAliases));
+	if (configuredNuxtAliases?.ok && configuredNuxtAliases.aliases.form !== "object") return incompleteAliasConfiguration(collectAliasResolutionKeys(builtInAliases, configuredNuxtAliases, viteAliases), collectAliasResolutionCandidates(builtInAliases, configuredNuxtAliases, viteAliases));
+	return completeAliasConfiguration(mergeNuxtAliases(mergeObjectAliases(builtInAliases, configuredNuxtAliases?.ok ? configuredNuxtAliases.aliases : void 0), viteAliases?.ok ? viteAliases.aliases : void 0));
+}
+function readNuxtBuiltInAliases(config, context) {
+	const configuredRoot = config.get("rootDir");
+	const rootDirValue = configuredRoot ? resolveStaticString(configuredRoot, context, /* @__PURE__ */ new Set()) : void 0;
+	if (configuredRoot && rootDirValue === void 0) return void 0;
+	const rootDir = resolveSafeNuxtDirectory(context.packageRoot, rootDirValue ?? ".");
+	if (!rootDir) return void 0;
+	const configuredSource = config.get("srcDir");
+	const sourceValue = configuredSource ? resolveStaticString(configuredSource, context, /* @__PURE__ */ new Set()) : void 0;
+	if (configuredSource && sourceValue === void 0) return void 0;
+	const compatibilityMajor = readNuxtCompatibilityMajor(config, context);
+	if (compatibilityMajor === null) return void 0;
+	const effectiveNuxtMajor = compatibilityMajor ?? context.nuxtMajorVersion;
+	const hasExplicitSource = Boolean(configuredSource && sourceValue);
+	if (!hasExplicitSource && effectiveNuxtMajor === void 0) return void 0;
+	const srcDir = hasExplicitSource ? resolveSafeNuxtDirectory(rootDir, sourceValue) : effectiveNuxtMajor >= 4 ? resolveDefaultNuxt4SourceDirectory(rootDir) : rootDir;
+	if (!srcDir) return void 0;
+	const sourceAlias = withTrailingSlash(srcDir);
+	const rootAlias = withTrailingSlash(rootDir);
+	return {
+		entries: [
+			["~", sourceAlias],
+			["@", sourceAlias],
+			["~~", rootAlias],
+			["@@", rootAlias]
+		],
+		form: "object"
+	};
+}
+function readNuxtCompatibilityMajor(config, context) {
+	const futureEntry = config.get("future");
+	if (!futureEntry) return void 0;
+	const future = resolveStaticObject(futureEntry, context, /* @__PURE__ */ new Set(), "config");
+	if (!future) return null;
+	const compatibilityEntry = future.get("compatibilityVersion");
+	if (!compatibilityEntry) return void 0;
+	return resolveStaticInteger(compatibilityEntry, context, /* @__PURE__ */ new Set()) ?? null;
+}
+function resolveStaticInteger(entry, context, seen) {
+	const unwrapped = unwrapEntry(entry);
+	if (seen.has(unwrapped.node)) return void 0;
+	seen.add(unwrapped.node);
+	try {
+		if (unwrapped.node.type === "NumericLiteral" && Number.isInteger(unwrapped.node.value)) return unwrapped.node.value;
+		if (unwrapped.node.type === "StringLiteral" && /^\d+$/.test(unwrapped.node.value)) return Number(unwrapped.node.value);
+		if (unwrapped.node.type !== "Identifier") return void 0;
+		const bound = resolveImmutableBinding(unwrapped, context, "none");
+		return bound ? resolveStaticInteger(bound, context, seen) : void 0;
+	} finally {
+		seen.delete(unwrapped.node);
+	}
+}
+function resolveSafeNuxtDirectory(root, configuredPath) {
+	const candidate = path.resolve(root, configuredPath);
+	if (!isInsideDirectory(root, candidate)) return void 0;
+	if (path.relative(root, candidate).split(path.sep).includes("node_modules")) return;
+	try {
+		const realRoot = fs.realpathSync(root);
+		let existingAncestor = candidate;
+		while (!fs.existsSync(existingAncestor)) {
+			const parent = path.dirname(existingAncestor);
+			if (parent === existingAncestor) return void 0;
+			existingAncestor = parent;
+		}
+		const realAncestor = fs.realpathSync(existingAncestor);
+		return isInsideDirectory(realRoot, path.resolve(realAncestor, path.relative(existingAncestor, candidate))) ? candidate : void 0;
+	} catch {
+		return;
+	}
+}
+function resolveDefaultNuxt4SourceDirectory(rootDir) {
+	const appDir = path.join(rootDir, "app");
+	try {
+		if (!fs.statSync(appDir).isDirectory()) return rootDir;
+		if (fs.readdirSync(appDir).filter((entry) => entry !== "spa-loading-template.html" && !entry.startsWith("router.options")).length > 0) return appDir;
+		if ([
+			"app.vue",
+			"App.vue",
+			"assets",
+			"layouts",
+			"middleware",
+			"pages",
+			"plugins"
+		].map((entry) => path.join(rootDir, entry)).some((entry) => fs.existsSync(entry))) return rootDir;
+		return appDir;
+	} catch {
+		return rootDir;
+	}
+}
+function withTrailingSlash(directory) {
+	return `${directory.replaceAll(path.sep, "/")}/`;
+}
+function readInstalledNuxtMajor(cwd) {
+	try {
+		const manifestPath = createRequire(path.join(cwd, "package.json")).resolve("nuxt/package.json");
+		const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+		if (typeof manifest.version !== "string") return void 0;
+		const major = Number(manifest.version.split(".")[0]);
+		return Number.isInteger(major) ? major : void 0;
+	} catch {
+		return;
+	}
+}
+function parseConfig(configFile) {
+	try {
+		return parse(fs.readFileSync(configFile, "utf8"), {
+			allowAwaitOutsideFunction: true,
+			plugins: [
+				"decorators-legacy",
+				"typescript",
+				"jsx",
+				"importAttributes"
+			],
+			sourceType: "unambiguous"
+		});
+	} catch {
+		return;
+	}
+}
+function collectAnalysisContext(ast) {
+	const helpers = {
+		configFunctions: /* @__PURE__ */ new Set(),
+		configNamespaces: /* @__PURE__ */ new Set(),
+		fileURLToPathFunctions: /* @__PURE__ */ new Set(),
+		pathNamespaces: /* @__PURE__ */ new Set(),
+		pathResolveFunctions: /* @__PURE__ */ new Set(),
+		urlConstructors: /* @__PURE__ */ new Set(),
+		urlNamespaces: /* @__PURE__ */ new Set()
+	};
+	const scopes = /* @__PURE__ */ new WeakMap();
+	traverse(ast, {
+		enter(nodePath) {
+			scopes.set(nodePath.node, nodePath.scope);
+		},
+		ImportDeclaration(importPath) {
+			const source = importPath.node.source.value;
+			for (const specifierPath of importPath.get("specifiers")) {
+				const binding = specifierPath.scope.getBinding(specifierPath.node.local.name);
+				if (!binding || !binding.constant || hasDirectMemberMutation(binding)) continue;
+				registerHelperBinding(helpers, source, specifierPath.node.type === "ImportSpecifier" ? specifierPath.node.imported.type === "Identifier" ? specifierPath.node.imported.name : specifierPath.node.imported.value : specifierPath.node.type === "ImportDefaultSpecifier" ? "default" : "*", binding);
+			}
+		},
+		VariableDeclarator(variablePath) {
+			registerRequireBinding(variablePath, helpers);
+		}
+	});
+	return {
+		helpers,
+		scopes
+	};
+}
+function registerHelperBinding(helpers, source, importedName, binding) {
+	if (source === "vite" || source === "nuxt/config" || source === "nuxt" || source === "#imports") {
+		if (importedName === "defineConfig" || importedName === "defineNuxtConfig") helpers.configFunctions.add(binding);
+		else if (importedName === "*" || importedName === "default") helpers.configNamespaces.add(binding);
+		return;
+	}
+	if (source === "node:path" || source === "path") {
+		if (importedName === "resolve") helpers.pathResolveFunctions.add(binding);
+		else if (importedName === "*" || importedName === "default") helpers.pathNamespaces.add(binding);
+		return;
+	}
+	if (source === "node:url" || source === "url") {
+		if (importedName === "fileURLToPath") helpers.fileURLToPathFunctions.add(binding);
+		else if (importedName === "URL") helpers.urlConstructors.add(binding);
+		else if (importedName === "*" || importedName === "default") helpers.urlNamespaces.add(binding);
+	}
+}
+function registerRequireBinding(variablePath, helpers) {
+	const source = readRequireSource(variablePath.node.init);
+	if (!source) return;
+	const idPath = variablePath.get("id");
+	if (idPath.isIdentifier()) {
+		const binding = idPath.scope.getBinding(idPath.node.name);
+		if (!binding || !binding.constant || hasDirectMemberMutation(binding)) return;
+		registerHelperBinding(helpers, source, "*", binding);
+		return;
+	}
+	if (!idPath.isObjectPattern()) return;
+	for (const propertyPath of idPath.get("properties")) {
+		if (!propertyPath.isObjectProperty()) continue;
+		const importedName = readPropertyKey(propertyPath.node);
+		const valuePath = propertyPath.get("value");
+		const localPath = valuePath.isAssignmentPattern() ? valuePath.get("left") : valuePath;
+		if (!importedName || !localPath.isIdentifier()) continue;
+		const binding = localPath.scope.getBinding(localPath.node.name);
+		if (binding?.constant && !hasDirectMemberMutation(binding)) registerHelperBinding(helpers, source, importedName, binding);
+	}
+}
+function readRequireSource(node) {
+	const unwrapped = unwrapNode(node);
+	if (!unwrapped || unwrapped.type !== "CallExpression" || unwrapped.callee.type !== "Identifier" || unwrapped.callee.name !== "require" || unwrapped.arguments.length !== 1 || unwrapped.arguments[0]?.type !== "StringLiteral") return;
+	return unwrapped.arguments[0].value;
+}
+function findActiveConfigExport(ast) {
+	const candidates = [];
+	traverse(ast, {
+		ExportDefaultDeclaration(exportPath) {
+			candidates.push({
+				node: exportPath.node.declaration,
+				scope: exportPath.scope,
+				start: exportPath.node.start ?? -1
+			});
+		},
+		ExportNamedDeclaration(exportPath) {
+			for (const specifierPath of exportPath.get("specifiers")) {
+				if (!specifierPath.isExportSpecifier()) continue;
+				const exported = specifierPath.node.exported;
+				if ((exported.type === "Identifier" ? exported.name : exported.value) !== "default") continue;
+				candidates.push({
+					node: specifierPath.node.local,
+					scope: specifierPath.scope,
+					start: exportPath.node.start ?? -1
+				});
+			}
+		},
+		TSExportAssignment(exportPath) {
+			candidates.push({
+				node: exportPath.node.expression,
+				scope: exportPath.scope,
+				start: exportPath.node.start ?? -1
+			});
+		},
+		AssignmentExpression(assignmentPath) {
+			if (!isCommonJsConfigExport(assignmentPath.node.left)) return;
+			candidates.push({
+				node: assignmentPath.node.right,
+				scope: assignmentPath.scope,
+				start: assignmentPath.node.start ?? -1
+			});
+		}
+	});
+	candidates.sort((left, right) => left.start - right.start);
+	return candidates.at(-1);
+}
+function isCommonJsConfigExport(node) {
+	if (node.type !== "MemberExpression" || node.computed) return false;
+	if (node.object.type === "Identifier" && node.property.type === "Identifier") return node.object.name === "module" && node.property.name === "exports" || node.object.name === "exports" && node.property.name === "default";
+	if (node.object.type === "MemberExpression" && !node.object.computed && node.object.object.type === "Identifier" && node.object.object.name === "module" && node.object.property.type === "Identifier" && node.object.property.name === "exports" && node.property.type === "Identifier" && node.property.name === "default") return true;
+	return false;
+}
+function resolveConfigRoot(entry, context, seen) {
+	const unwrapped = unwrapEntry(entry);
+	if (seen.has(unwrapped.node)) return void 0;
+	seen.add(unwrapped.node);
+	try {
+		if (unwrapped.node.type === "Identifier") {
+			const bound = resolveImmutableBinding(unwrapped, context, "config");
+			return bound ? resolveConfigRoot(bound, context, seen) : void 0;
+		}
+		if (unwrapped.node.type === "CallExpression" || unwrapped.node.type === "OptionalCallExpression") {
+			if (!isConfigHelperCall(unwrapped, context.helpers)) return void 0;
+			const argument = unwrapped.node.arguments[0];
+			if (!argument || argument.type === "SpreadElement" || argument.type === "ArgumentPlaceholder") return;
+			return resolveConfigRoot(scopedEntry(argument, unwrapped.scope, context), context, seen);
+		}
+		if (unwrapped.node.type === "ArrowFunctionExpression" || unwrapped.node.type === "FunctionExpression" || unwrapped.node.type === "FunctionDeclaration") {
+			const returned = readStaticFunctionReturn(unwrapped, context);
+			return returned ? resolveConfigRoot(returned, context, seen) : void 0;
+		}
+		return unwrapped;
+	} finally {
+		seen.delete(unwrapped.node);
+	}
+}
+function isConfigHelperCall(entry, helpers) {
+	if (entry.node.type !== "CallExpression" && entry.node.type !== "OptionalCallExpression") return false;
+	const callee = unwrapNode(entry.node.callee);
+	if (!callee) return false;
+	if (callee.type === "Identifier") {
+		const binding = entry.scope.getBinding(callee.name);
+		return binding ? helpers.configFunctions.has(binding) : callee.name === "defineConfig" || callee.name === "defineNuxtConfig";
+	}
+	if (callee.type === "MemberExpression" && !callee.computed && callee.object.type === "Identifier" && callee.property.type === "Identifier" && (callee.property.name === "defineConfig" || callee.property.name === "defineNuxtConfig")) {
+		const binding = entry.scope.getBinding(callee.object.name);
+		return Boolean(binding && helpers.configNamespaces.has(binding));
+	}
+	return false;
+}
+function readStaticFunctionReturn(entry, context) {
+	if (entry.node.type !== "ArrowFunctionExpression" && entry.node.type !== "FunctionExpression" && entry.node.type !== "FunctionDeclaration") return;
+	if (entry.node.body.type !== "BlockStatement") return scopedEntry(entry.node.body, entry.scope, context);
+	const returns = entry.node.body.body.filter((statement) => statement.type === "ReturnStatement" && Boolean(statement.argument));
+	if (returns.length !== 1 || !returns[0].argument) return void 0;
+	return scopedEntry(returns[0].argument, entry.scope, context);
+}
+function readNestedAliasObject(root, keys, context) {
+	let entry;
+	let object = root;
+	for (const [index, key] of keys.entries()) {
+		entry = object.get(key);
+		if (!entry) return void 0;
+		if (isDefinitelyAbsentAliasValue(entry, context, /* @__PURE__ */ new Set())) return;
+		if (index === keys.length - 1) break;
+		const nested = resolveStaticObject(entry, context, /* @__PURE__ */ new Set(), "config");
+		if (!nested) return {
+			ok: false,
+			potentialAliasKeys: /* @__PURE__ */ new Set(),
+			potentialAliases: /* @__PURE__ */ new Map()
+		};
+		object = nested;
+	}
+	return entry ? readAliasValue(entry, context) : void 0;
+}
+function isDefinitelyAbsentAliasValue(entry, context, seen) {
+	const unwrapped = unwrapEntry(entry);
+	if (seen.has(unwrapped.node)) return false;
+	seen.add(unwrapped.node);
+	try {
+		if (unwrapped.node.type === "NullLiteral") return true;
+		if (unwrapped.node.type === "BooleanLiteral" && !unwrapped.node.value) return true;
+		if (unwrapped.node.type === "Identifier" && unwrapped.node.name === "undefined" && !unwrapped.scope.getBinding("undefined")) return true;
+		if (unwrapped.node.type === "UnaryExpression" && unwrapped.node.operator === "void") return true;
+		if (unwrapped.node.type !== "Identifier") return false;
+		const bound = resolveImmutableBinding(unwrapped, context, "none");
+		return bound ? isDefinitelyAbsentAliasValue(bound, context, seen) : false;
+	} finally {
+		seen.delete(unwrapped.node);
+	}
+}
+function readAliasValue(entry, context) {
+	const potentialAliasKeys = collectPotentialAliasKeys(entry, context, /* @__PURE__ */ new Set());
+	const potentialAliases = collectPotentialAliases(entry, context, /* @__PURE__ */ new Set());
+	const object = resolveStaticObject(entry, context, /* @__PURE__ */ new Set(), "alias");
+	if (object) {
+		const entries = [];
+		for (const [find, replacementEntry] of object) {
+			const replacement = resolveStaticString(replacementEntry, context, /* @__PURE__ */ new Set());
+			if (replacement === void 0) return {
+				ok: false,
+				potentialAliasKeys,
+				potentialAliases
+			};
+			entries.push([find, replacement]);
+		}
+		return {
+			ok: true,
+			aliases: {
+				entries,
+				form: "object"
+			}
+		};
+	}
+	const entries = resolveStaticArray(entry, context, /* @__PURE__ */ new Set(), "alias");
+	if (!entries) return {
+		ok: false,
+		potentialAliasKeys,
+		potentialAliases
+	};
+	const arrayAliases = /* @__PURE__ */ new Map();
+	for (const item of entries) {
+		const aliasObject = resolveStaticObject(item, context, /* @__PURE__ */ new Set(), "alias");
+		if (!aliasObject || aliasObject.has("customResolver")) return {
+			ok: false,
+			potentialAliasKeys,
+			potentialAliases
+		};
+		const findEntry = aliasObject.get("find");
+		const replacementEntry = aliasObject.get("replacement");
+		if (!findEntry || !replacementEntry) return {
+			ok: false,
+			potentialAliasKeys,
+			potentialAliases
+		};
+		const find = resolveStaticString(findEntry, context, /* @__PURE__ */ new Set());
+		const replacement = resolveStaticString(replacementEntry, context, /* @__PURE__ */ new Set());
+		if (find === void 0 || replacement === void 0) return {
+			ok: false,
+			potentialAliasKeys,
+			potentialAliases
+		};
+		if (!arrayAliases.has(find)) arrayAliases.set(find, replacement);
+	}
+	return {
+		ok: true,
+		aliases: {
+			entries: [...arrayAliases],
+			form: "array"
+		}
+	};
+}
+/** Collects only fully static key-to-replacement candidates. */
+function collectPotentialAliases(entry, context, seen) {
+	const unwrapped = unwrapEntry(entry);
+	if (seen.has(unwrapped.node)) return /* @__PURE__ */ new Map();
+	seen.add(unwrapped.node);
+	try {
+		if (unwrapped.node.type === "Identifier") {
+			const bound = resolveImmutableBinding(unwrapped, context, "none");
+			return bound ? collectPotentialAliases(bound, context, seen) : /* @__PURE__ */ new Map();
+		}
+		if (unwrapped.node.type === "ObjectExpression") {
+			const aliases = /* @__PURE__ */ new Map();
+			for (const property of unwrapped.node.properties) {
+				if (property.type === "SpreadElement") {
+					mergePotentialAliases(aliases, collectPotentialAliases(scopedEntry(property.argument, unwrapped.scope, context), context, seen));
+					continue;
+				}
+				if (property.type !== "ObjectProperty") continue;
+				const find = readPropertyKey(property);
+				if (find === void 0) continue;
+				const replacement = resolveStaticString(scopedEntry(property.value, unwrapped.scope, context), context, /* @__PURE__ */ new Set());
+				if (replacement !== void 0) addPotentialAlias(aliases, find, replacement);
+			}
+			return aliases;
+		}
+		if (unwrapped.node.type === "ArrayExpression") {
+			const aliases = /* @__PURE__ */ new Map();
+			for (const element of unwrapped.node.elements) {
+				if (!element) continue;
+				if (element.type === "SpreadElement") {
+					mergePotentialAliases(aliases, collectPotentialAliases(scopedEntry(element.argument, unwrapped.scope, context), context, seen));
+					continue;
+				}
+				const aliasObject = resolveStaticObject(scopedEntry(element, unwrapped.scope, context), context, /* @__PURE__ */ new Set(), "none");
+				const findEntry = aliasObject?.get("find");
+				const replacementEntry = aliasObject?.get("replacement");
+				if (!findEntry || !replacementEntry) continue;
+				const find = resolveStaticString(findEntry, context, /* @__PURE__ */ new Set());
+				const replacement = resolveStaticString(replacementEntry, context, /* @__PURE__ */ new Set());
+				if (find !== void 0 && replacement !== void 0) addPotentialAlias(aliases, find, replacement);
+			}
+			return aliases;
+		}
+		return /* @__PURE__ */ new Map();
+	} finally {
+		seen.delete(unwrapped.node);
+	}
+}
+/**
+* Collects statically visible alias keys without claiming that their final
+* replacement or precedence is known. Dynamic spreads and overrides can make
+* the full alias surface incomplete, but the observed keys remain useful as
+* narrowly scoped evidence that an import may belong to the Vue project.
+*/
+function collectPotentialAliasKeys(entry, context, seen) {
+	const unwrapped = unwrapEntry(entry);
+	if (seen.has(unwrapped.node)) return /* @__PURE__ */ new Set();
+	seen.add(unwrapped.node);
+	try {
+		if (unwrapped.node.type === "Identifier") {
+			const bound = resolveImmutableBinding(unwrapped, context, "none");
+			return bound ? collectPotentialAliasKeys(bound, context, seen) : /* @__PURE__ */ new Set();
+		}
+		if (unwrapped.node.type === "ObjectExpression") {
+			const keys = /* @__PURE__ */ new Set();
+			for (const property of unwrapped.node.properties) {
+				if (property.type === "SpreadElement") {
+					addAll(keys, collectPotentialAliasKeys(scopedEntry(property.argument, unwrapped.scope, context), context, seen));
+					continue;
+				}
+				if (property.type !== "ObjectProperty" && property.type !== "ObjectMethod") continue;
+				const key = readPropertyKey(property);
+				if (key !== void 0) keys.add(key);
+			}
+			return keys;
+		}
+		if (unwrapped.node.type === "ArrayExpression") {
+			const keys = /* @__PURE__ */ new Set();
+			for (const element of unwrapped.node.elements) {
+				if (!element) continue;
+				if (element.type === "SpreadElement") {
+					addAll(keys, collectPotentialAliasKeys(scopedEntry(element.argument, unwrapped.scope, context), context, seen));
+					continue;
+				}
+				addAll(keys, collectPotentialArrayAliasKeys(scopedEntry(element, unwrapped.scope, context), context, seen));
+			}
+			return keys;
+		}
+		return /* @__PURE__ */ new Set();
+	} finally {
+		seen.delete(unwrapped.node);
+	}
+}
+function collectPotentialArrayAliasKeys(entry, context, seen) {
+	const unwrapped = unwrapEntry(entry);
+	if (seen.has(unwrapped.node)) return /* @__PURE__ */ new Set();
+	seen.add(unwrapped.node);
+	try {
+		if (unwrapped.node.type === "Identifier") {
+			const bound = resolveImmutableBinding(unwrapped, context, "none");
+			return bound ? collectPotentialArrayAliasKeys(bound, context, seen) : /* @__PURE__ */ new Set();
+		}
+		if (unwrapped.node.type !== "ObjectExpression") return /* @__PURE__ */ new Set();
+		const keys = /* @__PURE__ */ new Set();
+		for (const property of unwrapped.node.properties) {
+			if (property.type === "SpreadElement") {
+				addAll(keys, collectPotentialArrayAliasKeys(scopedEntry(property.argument, unwrapped.scope, context), context, seen));
+				continue;
+			}
+			if (property.type !== "ObjectProperty" || readPropertyKey(property) !== "find") continue;
+			const find = resolveStaticString(scopedEntry(property.value, unwrapped.scope, context), context, /* @__PURE__ */ new Set());
+			if (find !== void 0) keys.add(find);
+		}
+		return keys;
+	} finally {
+		seen.delete(unwrapped.node);
+	}
+}
+function addAll(target, values) {
+	for (const value of values) target.add(value);
+}
+function addPotentialAlias(target, find, replacement) {
+	const replacements = target.get(find) ?? /* @__PURE__ */ new Set();
+	replacements.add(replacement);
+	target.set(find, replacements);
+}
+function mergePotentialAliases(target, source) {
+	for (const [find, replacements] of source) for (const replacement of replacements) addPotentialAlias(target, find, replacement);
+}
+function clonePotentialAliases(aliases) {
+	const clone = /* @__PURE__ */ new Map();
+	mergePotentialAliases(clone, aliases);
+	return clone;
+}
+function resolveStaticObject(entry, context, seen, bindingSafety) {
+	const unwrapped = unwrapEntry(entry);
+	if (seen.has(unwrapped.node)) return void 0;
+	seen.add(unwrapped.node);
+	try {
+		if (unwrapped.node.type === "Identifier") {
+			const bound = resolveImmutableBinding(unwrapped, context, bindingSafety);
+			return bound ? resolveStaticObject(bound, context, seen, bindingSafety) : void 0;
+		}
+		if (unwrapped.node.type !== "ObjectExpression") return void 0;
+		const object = /* @__PURE__ */ new Map();
+		for (const property of unwrapped.node.properties) {
+			if (property.type === "SpreadElement") {
+				const spread = resolveStaticObject(scopedEntry(property.argument, unwrapped.scope, context), context, seen, bindingSafety);
+				if (!spread) return void 0;
+				for (const pair of spread) object.set(...pair);
+				continue;
+			}
+			if (property.type !== "ObjectProperty" && property.type !== "ObjectMethod") continue;
+			const key = readPropertyKey(property);
+			if (key === void 0) return void 0;
+			object.set(key, scopedEntry(property.type === "ObjectProperty" ? property.value : property, unwrapped.scope, context));
+		}
+		return object;
+	} finally {
+		seen.delete(unwrapped.node);
+	}
+}
+function resolveStaticArray(entry, context, seen, bindingSafety) {
+	const unwrapped = unwrapEntry(entry);
+	if (seen.has(unwrapped.node)) return void 0;
+	seen.add(unwrapped.node);
+	try {
+		if (unwrapped.node.type === "Identifier") {
+			const bound = resolveImmutableBinding(unwrapped, context, bindingSafety);
+			return bound ? resolveStaticArray(bound, context, seen, bindingSafety) : void 0;
+		}
+		if (unwrapped.node.type !== "ArrayExpression") return void 0;
+		const result = [];
+		for (const element of unwrapped.node.elements) {
+			if (!element) continue;
+			if (element.type === "SpreadElement") {
+				const spread = resolveStaticArray(scopedEntry(element.argument, unwrapped.scope, context), context, seen, bindingSafety);
+				if (!spread) return void 0;
+				result.push(...spread);
+				continue;
+			}
+			result.push(scopedEntry(element, unwrapped.scope, context));
+		}
+		return result;
+	} finally {
+		seen.delete(unwrapped.node);
+	}
+}
+function resolveStaticString(entry, context, seen) {
+	const unwrapped = unwrapEntry(entry);
+	if (seen.has(unwrapped.node)) return void 0;
+	seen.add(unwrapped.node);
+	try {
+		const node = unwrapped.node;
+		if (node.type === "StringLiteral") return node.value;
+		if (node.type === "Identifier") {
+			if (node.name === "__dirname" && !unwrapped.scope.getBinding(node.name)) return path.dirname(context.configFile);
+			const bound = resolveImmutableBinding(unwrapped, context, "none");
+			return bound ? resolveStaticString(bound, context, seen) : void 0;
+		}
+		if (node.type === "TemplateLiteral") {
+			let value = node.quasis[0]?.value.cooked ?? "";
+			for (const [index, expression] of node.expressions.entries()) {
+				const resolved = resolveStaticString(scopedEntry(expression, unwrapped.scope, context), context, seen);
+				if (resolved === void 0) return void 0;
+				value += resolved + (node.quasis[index + 1]?.value.cooked ?? "");
+			}
+			return value;
+		}
+		if (node.type === "BinaryExpression" && node.operator === "+") {
+			const left = resolveStaticString(scopedEntry(node.left, unwrapped.scope, context), context, seen);
+			const right = resolveStaticString(scopedEntry(node.right, unwrapped.scope, context), context, seen);
+			return left === void 0 || right === void 0 ? void 0 : left + right;
+		}
+		if (node.type === "CallExpression" || node.type === "OptionalCallExpression") {
+			if (isPathResolveCall(unwrapped, context.helpers)) {
+				const parts = [];
+				for (const argument of node.arguments) {
+					if (argument.type === "SpreadElement" || argument.type === "ArgumentPlaceholder") return;
+					const part = resolveStaticString(scopedEntry(argument, unwrapped.scope, context), context, seen);
+					if (part === void 0) return void 0;
+					parts.push(part);
+				}
+				if (parts.length === 0 || !path.isAbsolute(parts[0])) return;
+				return path.resolve(...parts);
+			}
+			if (isFileURLToPathCall(unwrapped, context.helpers)) {
+				const argument = node.arguments[0];
+				if (!argument || argument.type === "SpreadElement" || argument.type === "ArgumentPlaceholder") return;
+				const url = resolveStaticUrl(scopedEntry(argument, unwrapped.scope, context), context, seen);
+				if (!url || url.protocol !== "file:") return void 0;
+				return fileURLToPath(url);
+			}
+		}
+		if (node.type === "MemberExpression" && !node.computed && node.object.type === "MetaProperty" && node.object.meta.name === "import" && node.object.property.name === "meta" && node.property.type === "Identifier" && node.property.name === "dirname") return path.dirname(context.configFile);
+		return;
+	} finally {
+		seen.delete(unwrapped.node);
+	}
+}
+function resolveStaticUrl(entry, context, seen) {
+	const unwrapped = unwrapEntry(entry);
+	if (seen.has(unwrapped.node)) return void 0;
+	seen.add(unwrapped.node);
+	try {
+		if (unwrapped.node.type === "Identifier") {
+			const bound = resolveImmutableBinding(unwrapped, context, "none");
+			return bound ? resolveStaticUrl(bound, context, seen) : void 0;
+		}
+		if (unwrapped.node.type !== "NewExpression" || unwrapped.node.callee.type !== "Identifier" || unwrapped.node.callee.name !== "URL" || !isTrustedUrlConstructor(unwrapped, context.helpers) || unwrapped.node.arguments.length !== 2) return;
+		const [relativeArgument, baseArgument] = unwrapped.node.arguments;
+		if (!relativeArgument || relativeArgument.type === "SpreadElement" || relativeArgument.type === "ArgumentPlaceholder" || !baseArgument || baseArgument.type === "SpreadElement" || baseArgument.type === "ArgumentPlaceholder" || !isImportMetaUrl(baseArgument)) return;
+		const relative = resolveStaticString(scopedEntry(relativeArgument, unwrapped.scope, context), context, seen);
+		if (relative === void 0) return void 0;
+		return new URL(relative, pathToFileURL(context.configFile));
+	} catch {
+		return;
+	} finally {
+		seen.delete(unwrapped.node);
+	}
+}
+/** Accepts the global URL constructor and immutable imports from node:url. */
+function isTrustedUrlConstructor(entry, helpers) {
+	if (entry.node.type !== "NewExpression" || entry.node.callee.type !== "Identifier" || entry.node.callee.name !== "URL") return false;
+	const binding = entry.scope.getBinding(entry.node.callee.name);
+	return binding === void 0 || helpers.urlConstructors.has(binding);
+}
+function isPathResolveCall(entry, helpers) {
+	if (entry.node.type !== "CallExpression" && entry.node.type !== "OptionalCallExpression") return false;
+	const callee = unwrapNode(entry.node.callee);
+	if (!callee) return false;
+	if (callee.type === "Identifier") {
+		const binding = entry.scope.getBinding(callee.name);
+		return Boolean(binding && helpers.pathResolveFunctions.has(binding));
+	}
+	if (callee.type === "MemberExpression" && !callee.computed && callee.object.type === "Identifier" && callee.property.type === "Identifier" && callee.property.name === "resolve") {
+		const binding = entry.scope.getBinding(callee.object.name);
+		return Boolean(binding && helpers.pathNamespaces.has(binding));
+	}
+	return false;
+}
+function isFileURLToPathCall(entry, helpers) {
+	if (entry.node.type !== "CallExpression" && entry.node.type !== "OptionalCallExpression") return false;
+	const callee = unwrapNode(entry.node.callee);
+	if (!callee) return false;
+	if (callee.type === "Identifier") {
+		const binding = entry.scope.getBinding(callee.name);
+		return Boolean(binding && helpers.fileURLToPathFunctions.has(binding));
+	}
+	if (callee.type === "MemberExpression" && !callee.computed && callee.object.type === "Identifier" && callee.property.type === "Identifier" && callee.property.name === "fileURLToPath") {
+		const binding = entry.scope.getBinding(callee.object.name);
+		return Boolean(binding && helpers.urlNamespaces.has(binding));
+	}
+	return false;
+}
+function isImportMetaUrl(node) {
+	const unwrapped = unwrapNode(node);
+	return Boolean(unwrapped && unwrapped.type === "MemberExpression" && !unwrapped.computed && unwrapped.object.type === "MetaProperty" && unwrapped.object.meta.name === "import" && unwrapped.object.property.name === "meta" && unwrapped.property.type === "Identifier" && unwrapped.property.name === "url");
+}
+function resolveImmutableBinding(entry, context, safety) {
+	if (entry.node.type !== "Identifier") return void 0;
+	const binding = entry.scope.getBinding(entry.node.name);
+	if (!binding || binding.kind !== "const" || !binding.constant || binding.constantViolations.length > 0 || !binding.path.isVariableDeclarator() || hasDirectMemberMutation(binding) || safety === "alias" && hasUnsafeAliasBindingUse(binding, context, /* @__PURE__ */ new Set()) || safety === "config" && !isSafeConfigBinding(binding, context, /* @__PURE__ */ new Set()) || !binding.path.node.init) return;
+	return scopedEntry(binding.path.node.init, binding.path.scope, context);
+}
+function hasUnsafeAliasBindingUse(binding, context, seen) {
+	if (seen.has(binding)) return false;
+	seen.add(binding);
+	try {
+		return binding.referencePaths.some((referencePath) => {
+			let targetPath = unwrapReferencePath(referencePath);
+			while ((targetPath.parentPath?.isMemberExpression() || targetPath.parentPath?.isOptionalMemberExpression()) && targetPath.parentPath.node.object === targetPath.node) targetPath = targetPath.parentPath;
+			const parentPath = targetPath.parentPath;
+			if (!parentPath) return true;
+			if (parentPath.isAssignmentExpression()) return true;
+			if (parentPath.isUpdateExpression()) return true;
+			if (parentPath.isUnaryExpression({ operator: "delete" })) return true;
+			if (parentPath.isCallExpression() || parentPath.isOptionalCallExpression()) {
+				if (parentPath.node.callee === targetPath.node) return true;
+				return !isConfigHelperCall({
+					node: parentPath.node,
+					scope: parentPath.scope
+				}, context.helpers);
+			}
+			if (parentPath.isSpreadElement()) return !isSafeConfigValuePath(parentPath.parentPath, context, seen);
+			if (parentPath.isObjectProperty()) return !(parentPath.node.value === targetPath.node && readPropertyKey(parentPath.node) === "alias" && isSafeConfigValuePath(parentPath.parentPath, context, seen));
+			if (parentPath.isArrayExpression()) return !isSafeConfigValuePath(parentPath, context, seen);
+			if (parentPath.isVariableDeclarator()) {
+				if (parentPath.node.init !== targetPath.node || parentPath.node.id.type !== "Identifier" || !parentPath.parentPath?.isVariableDeclaration({ kind: "const" })) return true;
+				const aliasBinding = parentPath.scope.getBinding(parentPath.node.id.name);
+				return !aliasBinding || hasUnsafeAliasBindingUse(aliasBinding, context, seen);
+			}
+			return true;
+		});
+	} finally {
+		seen.delete(binding);
+	}
+}
+function hasDirectMemberMutation(binding) {
+	return binding.referencePaths.some((referencePath) => {
+		let targetPath = unwrapReferencePath(referencePath);
+		while ((targetPath.parentPath?.isMemberExpression() || targetPath.parentPath?.isOptionalMemberExpression()) && targetPath.parentPath.node.object === targetPath.node) targetPath = targetPath.parentPath;
+		const parentPath = targetPath.parentPath;
+		return Boolean(parentPath && (parentPath.isAssignmentExpression() || parentPath.isUpdateExpression() || parentPath.isUnaryExpression({ operator: "delete" })));
+	});
+}
+function isSafeConfigValuePath(inputPath, context, seen) {
+	if (!inputPath) return false;
+	const targetPath = unwrapReferencePath(inputPath);
+	const parentPath = targetPath.parentPath;
+	if (!parentPath) return false;
+	if (parentPath.isObjectProperty()) {
+		if (parentPath.node.value !== targetPath.node) return false;
+		return isSafeConfigValuePath(parentPath.parentPath, context, seen);
+	}
+	if (parentPath.isSpreadElement()) return isSafeConfigValuePath(parentPath.parentPath, context, seen);
+	if (parentPath.isArrowFunctionExpression()) {
+		if (parentPath.node.body !== targetPath.node) return false;
+		return isSafeConfigValuePath(parentPath, context, seen);
+	}
+	if (parentPath.isReturnStatement()) {
+		const functionScope = parentPath.scope.getFunctionParent();
+		return functionScope ? isSafeConfigValuePath(functionScope.path, context, seen) : false;
+	}
+	if (parentPath.isVariableDeclarator()) {
+		if (parentPath.node.init !== targetPath.node || parentPath.node.id.type !== "Identifier" || !parentPath.parentPath?.isVariableDeclaration({ kind: "const" })) return false;
+		const binding = parentPath.scope.getBinding(parentPath.node.id.name);
+		return binding ? isSafeConfigBinding(binding, context, seen) : false;
+	}
+	if (parentPath.isCallExpression() || parentPath.isOptionalCallExpression()) {
+		if (!parentPath.node.arguments.includes(targetPath.node)) return false;
+		return isConfigHelperCall({
+			node: parentPath.node,
+			scope: parentPath.scope
+		}, context.helpers);
+	}
+	if (parentPath.isExportDefaultDeclaration()) return true;
+	if (parentPath.isExportSpecifier()) {
+		const exported = parentPath.node.exported;
+		return (exported.type === "Identifier" ? exported.name : exported.value) === "default";
+	}
+	if (parentPath.isAssignmentExpression()) return parentPath.node.right === targetPath.node && isCommonJsConfigExport(parentPath.node.left);
+	return false;
+}
+function isSafeConfigBinding(binding, context, seen) {
+	if (seen.has(binding)) return true;
+	if (binding.kind !== "const" || !binding.constant || binding.constantViolations.length > 0) return false;
+	seen.add(binding);
+	try {
+		return binding.referencePaths.every((referencePath) => isSafeConfigValuePath(referencePath, context, seen));
+	} finally {
+		seen.delete(binding);
+	}
+}
+function unwrapReferencePath(referencePath) {
+	let targetPath = referencePath;
+	while (targetPath.parentPath && isTransparentExpression(targetPath.parentPath.node) && targetPath.parentPath.node.expression === targetPath.node) targetPath = targetPath.parentPath;
+	return targetPath;
+}
+function isTransparentExpression(node) {
+	return node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSNonNullExpression" || node.type === "TypeCastExpression" || node.type === "ParenthesizedExpression" || node.type === "TSInstantiationExpression";
+}
+function scopedEntry(node, fallbackScope, context) {
+	return {
+		node,
+		scope: context.scopes.get(node) ?? fallbackScope
+	};
+}
+function toFirstMatchMap(entries) {
+	const aliases = /* @__PURE__ */ new Map();
+	for (const [find, replacement] of entries) if (!aliases.has(find)) aliases.set(find, replacement);
+	return aliases;
+}
+function mergeObjectAliases(defaults, overrides) {
+	if (!overrides) return defaults;
+	const entries = new Map(defaults.entries);
+	for (const [find, replacement] of overrides.entries) entries.set(find, replacement);
+	return {
+		entries: [...entries],
+		form: "object"
+	};
+}
+/**
+* Mirrors Vite's mergeAlias behavior used by Nuxt. Two object forms merge in
+* property order with nested `vite.resolve.alias` values overriding duplicate
+* Nuxt aliases. If either side is an array, nested Vite aliases are prepended
+* because Vite resolves array aliases from first to last.
+*/
+function mergeNuxtAliases(nuxtAliases, viteAliases) {
+	if (!nuxtAliases) return toFirstMatchMap(viteAliases?.entries ?? []);
+	if (!viteAliases) return toFirstMatchMap(nuxtAliases.entries);
+	if (nuxtAliases.form === "object" && viteAliases.form === "object") {
+		const merged = new Map(nuxtAliases.entries);
+		for (const [find, replacement] of viteAliases.entries) merged.set(find, replacement);
+		return merged;
+	}
+	return toFirstMatchMap([...viteAliases.entries, ...nuxtAliases.entries]);
+}
+function readPropertyKey(property) {
+	if (!property.computed && property.key.type === "Identifier") return property.key.name;
+	if (property.key.type === "StringLiteral") return property.key.value;
+	if (property.key.type === "NumericLiteral") return String(property.key.value);
+}
+function unwrapEntry(entry) {
+	return {
+		node: unwrapNode(entry.node) ?? entry.node,
+		scope: entry.scope
+	};
+}
+function unwrapNode(node) {
+	let current = node;
+	while (current) {
+		if (isTransparentExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		break;
+	}
+	return current ?? void 0;
+}
+//#endregion
+export { resolveVueProjectAliasConfiguration, resolveVueProjectAliases };
+
+//# sourceMappingURL=viteAliases.js.map