weapp-vite 7.4.0 → 7.5.0

package/dist/utils-CJSCgEj6.mjs

@@ -0,0 +1,1094 @@
+import { c as isSkippableResolvedId, i as normalizeRoot, l as normalizeFsResolvedId, s as toPosixPath } from "./path-doV773b7.mjs";
+import { S as shouldNormalizeUsingComponents, l as getProjectPlatformOptions, p as normalizePlatformNpmImportPath, v as shouldFillComponentGenericsDefault, x as shouldNormalizePlatformNpmImportPath } from "./platform-CnkySBKz.mjs";
+import { n as changeFileExtension } from "./file-sC3jD7Fh.mjs";
+import { i as scriptExtensions, s as vueExtensions } from "./constants-DEZdcsMn.mjs";
+import "./logger-DGn5iEVN.mjs";
+import { createRequire } from "node:module";
+import process from "node:process";
+import path from "pathe";
+import { existsSync, readFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import path$1 from "node:path";
+import { defuOverrideArray, get, isObject, removeExtensionDeep, set } from "@weapp-core/shared";
+import { parse, stringify } from "comment-json";
+import { fs as fs$1 } from "@weapp-core/shared/fs";
+import { parseJsLikeWithEngine } from "@weapp-vite/ast";
+import { BABEL_TS_MODULE_PARSER_OPTIONS as BABEL_TS_MODULE_PARSER_OPTIONS$1, generate as generate$1, parse as parse$2, parseJsLike as parseJsLike$1, traverse as traverse$1 } from "@weapp-vite/ast/babel";
+import picomatch from "picomatch";
+import { invalidateFileCache, pathExists, readFile as readFile$2 } from "wevu/compiler";
+import fs$2, { readFile as readFile$1, readdir, realpath, unlink } from "node:fs/promises";
+import { loadConfigFromFile } from "vite";
+import "semver/functions/gte.js";
+import "semver/functions/satisfies.js";
+import "semver/functions/valid.js";
+//#region src/utils/npmImport.ts
+const WINDOWS_PATH_SEPARATORS_RE = /\\/g;
+const WINDOWS_ABSOLUTE_PATH_RE = /^[a-z]:[\\/]/i;
+const NPM_PROTOCOL_RE = /^npm:/;
+const PLUGIN_PROTOCOL_RE = /^plugin:\/\//;
+const EXPLICIT_NPM_DIR_RE = /^\/(?:miniprogram_npm|node_modules)\//;
+const LEADING_SLASHES_RE = /^\/+/;
+const NODE_MODULES_SEGMENT = "/node_modules/";
+const STRIP_SCRIPT_EXTENSION_RE = /\.[cm]?[jt]sx?$/;
+const INFERRED_MINIPROGRAM_ROOTS = ["miniprogram_dist", "miniprogram"];
+const miniprogramRootCache = /* @__PURE__ */ new Map();
+const packageRootCache = /* @__PURE__ */ new Map();
+const resolveFromCurrentModule = createRequire(import.meta.url);
+function stripScriptExtension(value) {
+	return value.replace(STRIP_SCRIPT_EXTENSION_RE, "");
+}
+function stripInferredMiniprogramRoot(subPath) {
+	for (const miniprogramRoot of INFERRED_MINIPROGRAM_ROOTS) if (subPath === miniprogramRoot || subPath.startsWith(`${miniprogramRoot}/`)) return subPath.slice(miniprogramRoot.length).replace(LEADING_SLASHES_RE, "");
+	return subPath;
+}
+function readMiniprogramRoot(packageRoot) {
+	const cached = miniprogramRootCache.get(packageRoot);
+	if (cached !== void 0 || miniprogramRootCache.has(packageRoot)) return cached;
+	const packageJsonPath = path$1.join(packageRoot, "package.json");
+	if (!existsSync(packageJsonPath)) {
+		miniprogramRootCache.set(packageRoot, void 0);
+		return;
+	}
+	try {
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+		const miniprogramRoot = typeof packageJson.miniprogram === "string" ? packageJson.miniprogram.replace(WINDOWS_PATH_SEPARATORS_RE, "/").replace(LEADING_SLASHES_RE, "") : void 0;
+		miniprogramRootCache.set(packageRoot, miniprogramRoot);
+		return miniprogramRoot;
+	} catch {
+		miniprogramRootCache.set(packageRoot, void 0);
+		return;
+	}
+}
+function resolveInstalledPackageRoot(packageName, basedir) {
+	const cacheKey = `${basedir}::${packageName}`;
+	const cached = packageRootCache.get(cacheKey);
+	if (cached !== void 0 || packageRootCache.has(cacheKey)) return cached;
+	try {
+		const packageJsonPath = resolveFromCurrentModule.resolve(`${packageName}/package.json`, { paths: [basedir] });
+		const resolvedPackageRoot = path$1.dirname(packageJsonPath);
+		packageRootCache.set(cacheKey, resolvedPackageRoot);
+		return resolvedPackageRoot;
+	} catch {
+		packageRootCache.set(cacheKey, void 0);
+		return;
+	}
+}
+function normalizeAbsoluteNodeModulesImport(importee) {
+	const nodeModulesIndex = importee.lastIndexOf(NODE_MODULES_SEGMENT);
+	if (nodeModulesIndex === -1) return;
+	const packageStart = nodeModulesIndex + 14;
+	const packageTokens = importee.slice(packageStart).replace(LEADING_SLASHES_RE, "").split("/").filter(Boolean);
+	if (packageTokens.length === 0) return;
+	const packageTokenCount = packageTokens[0].startsWith("@") ? 2 : 1;
+	if (packageTokens.length < packageTokenCount) return;
+	const packageName = packageTokens.slice(0, packageTokenCount).join("/");
+	const inferredPackageRoot = `${importee.slice(0, packageStart)}${packageName}`;
+	const packageRoot = existsSync(path$1.join(inferredPackageRoot, "package.json")) ? inferredPackageRoot : resolveInstalledPackageRoot(packageName, path$1.dirname(importee)) ?? inferredPackageRoot;
+	let subPath = packageTokens.slice(packageTokenCount).join("/");
+	const miniprogramRoot = readMiniprogramRoot(packageRoot);
+	if (miniprogramRoot && (subPath === miniprogramRoot || subPath.startsWith(`${miniprogramRoot}/`))) subPath = subPath.slice(miniprogramRoot.length).replace(LEADING_SLASHES_RE, "");
+	else subPath = stripInferredMiniprogramRoot(subPath);
+	const normalizedSubPath = stripScriptExtension(subPath);
+	return normalizedSubPath ? `${packageName}/${normalizedSubPath}` : packageName;
+}
+function normalizeNpmImportLookupPath(importee) {
+	const normalized = importee.replace(WINDOWS_PATH_SEPARATORS_RE, "/").replace(NPM_PROTOCOL_RE, "");
+	const nodeModulesResolved = normalizeAbsoluteNodeModulesImport(normalized);
+	if (nodeModulesResolved) return nodeModulesResolved;
+	return normalized.replace(EXPLICIT_NPM_DIR_RE, "").replace(LEADING_SLASHES_RE, "");
+}
+function resolveNpmDependencyId(importee) {
+	const normalizedImportee = normalizeNpmImportLookupPath(importee);
+	const importeeTokens = normalizedImportee.split("/").filter(Boolean);
+	if (importeeTokens.length === 0) return "";
+	if (normalizedImportee.startsWith("@") && importeeTokens.length > 1) return `${importeeTokens[0]}/${importeeTokens[1]}`;
+	return importeeTokens[0];
+}
+function normalizeNpmPackageSpecifier(specifier) {
+	const normalized = specifier.trim();
+	if (!normalized || normalized.startsWith(".") || normalized.startsWith("/") || normalized.startsWith("\\")) return;
+	if (WINDOWS_ABSOLUTE_PATH_RE.test(normalized)) return;
+	return normalized;
+}
+function parseNpmPackageSpecifier(specifier) {
+	const normalized = normalizeNpmPackageSpecifier(specifier);
+	if (!normalized) return;
+	const normalizedImportee = normalizeNpmImportLookupPath(normalized);
+	if (normalizedImportee.startsWith("@") && !normalizedImportee.includes("/")) return;
+	const packageName = resolveNpmDependencyId(normalizedImportee);
+	if (!packageName) return;
+	return {
+		packageName,
+		subPath: normalizedImportee.slice(packageName.length).replace(LEADING_SLASHES_RE, "")
+	};
+}
+function hasNpmDependencyPrefix(dependencies, importee) {
+	if (!dependencies) return false;
+	const importeeTokens = normalizeNpmImportLookupPath(importee).split("/").filter(Boolean);
+	if (importeeTokens.length === 0) return false;
+	return Object.keys(dependencies).some((dep) => {
+		const depTokens = dep.replace(WINDOWS_PATH_SEPARATORS_RE, "/").split("/").filter(Boolean);
+		if (depTokens.length === 0 || depTokens.length > importeeTokens.length) return false;
+		for (let i = 0; i < depTokens.length; i++) if (depTokens[i] !== importeeTokens[i]) return false;
+		return true;
+	});
+}
+function shouldNormalizeNpmImportByPlatform(importee, options) {
+	const trimmed = importee.trim();
+	if (!trimmed || PLUGIN_PROTOCOL_RE.test(trimmed)) return false;
+	if (!options.platform || !shouldNormalizePlatformNpmImportPath(options.platform)) return false;
+	const normalized = trimmed.replace(NPM_PROTOCOL_RE, "");
+	if (EXPLICIT_NPM_DIR_RE.test(normalized)) return true;
+	return hasNpmDependencyPrefix(options.dependencies, normalized);
+}
+function normalizeNpmImportPathByPlatform(importee, options) {
+	const trimmed = importee.trim();
+	if (!shouldNormalizeNpmImportByPlatform(trimmed, options)) return importee;
+	if (!options.platform) return importee;
+	const normalized = trimmed.replace(NPM_PROTOCOL_RE, "");
+	return normalizePlatformNpmImportPath(options.platform, normalized, { alipayNpmMode: options.alipayNpmMode });
+}
+//#endregion
+//#region src/utils/json.ts
+const ALIPAY_GENERIC_COMPONENT_PLACEHOLDER = "./__weapp_vite_generic_component";
+const WEAPP_SCOPED_SLOT_GENERIC_COMPONENT_PLACEHOLDER = "./__weapp_vite_scoped_slot_generic_component";
+const JSON_FILE_JS_EXTENSION_RE = /\.[jt]s$/;
+const COMPONENT_NAME_LOWER_TO_UPPER_RE = /([a-z0-9])([A-Z])/g;
+const COMPONENT_NAME_MULTI_UPPER_RE = /([A-Z]+)([A-Z][a-z])/g;
+const COMPONENT_NAME_HAS_UPPER_RE = /[A-Z]/;
+const SCOPED_SLOT_GENERIC_KEY_RE = /^scoped-slots-/;
+function parseCommentJson(json) {
+	return parse(json, void 0, true);
+}
+function jsonFileRemoveJsExtension(fileName) {
+	return fileName.replace(JSON_FILE_JS_EXTENSION_RE, "");
+}
+function stringifyJson(value, replacer) {
+	return stringify(value, replacer, 2);
+}
+function normalizeAppJson(json) {
+	if (!json || typeof json !== "object" || Array.isArray(json)) return json;
+	const subPackages = Array.isArray(json.subPackages) ? json.subPackages : Array.isArray(json.subpackages) ? json.subpackages : [];
+	const { subpackages: _subpackages, ...rest } = json;
+	return {
+		...rest,
+		subPackages: subPackages.map((subPackage) => ({
+			...subPackage,
+			pages: Array.isArray(subPackage?.pages) ? subPackage.pages : []
+		}))
+	};
+}
+function matches(pattern, importee) {
+	if (pattern instanceof RegExp) return pattern.test(importee);
+	if (importee.length < pattern.length) return false;
+	if (importee === pattern) return true;
+	return importee.startsWith(pattern + "/");
+}
+function getAliasEntries(options = {}) {
+	if (options === false) return [];
+	const { entries } = options;
+	if (!entries) return [];
+	if (Array.isArray(entries)) return entries.map((entry) => {
+		return {
+			find: entry.find,
+			replacement: entry.replacement
+		};
+	});
+	return Object.entries(entries).map(([key, value]) => {
+		return {
+			find: key,
+			replacement: value
+		};
+	});
+}
+function resolveImportee(importee, jsonPath, aliasEntries) {
+	if (Array.isArray(aliasEntries)) {
+		if (!jsonPath) return importee;
+		const matchedEntry = aliasEntries.find((x) => matches(x.find, importee));
+		if (!matchedEntry) return importee;
+		const updatedId = importee.replace(matchedEntry.find, matchedEntry.replacement);
+		return toPosixPath(path.relative(path.dirname(jsonPath), updatedId));
+	}
+	return importee;
+}
+function toKebabCaseComponentName(name) {
+	return name.replace(COMPONENT_NAME_LOWER_TO_UPPER_RE, "$1-$2").replace(COMPONENT_NAME_MULTI_UPPER_RE, "$1-$2").toLowerCase();
+}
+function normalizeUsingComponentPathByPlatform(importee, platform, dependencies, mode) {
+	if (!hasNpmDependencyPrefix(dependencies, importee) && !importee.trim().startsWith("/")) return importee;
+	return normalizeNpmImportPathByPlatform(importee, {
+		platform,
+		dependencies,
+		alipayNpmMode: mode
+	});
+}
+function normalizeUsingComponentsByPlatform(usingComponents, platform, options) {
+	if (!shouldNormalizeUsingComponents(platform)) return usingComponents;
+	const normalized = {};
+	for (const [key, value] of Object.entries(usingComponents)) {
+		const nextKey = COMPONENT_NAME_HAS_UPPER_RE.test(key) ? toKebabCaseComponentName(key) : key;
+		const nextValue = normalizeUsingComponentPathByPlatform(value, platform, options?.dependencies, options?.alipayNpmMode);
+		if (!Reflect.has(normalized, nextKey)) normalized[nextKey] = nextValue;
+	}
+	return normalized;
+}
+function normalizeComponentGenericsByPlatform(componentGenerics, platform) {
+	if (!shouldFillComponentGenericsDefault(platform) && platform !== "weapp") return componentGenerics;
+	const normalized = {};
+	for (const [key, value] of Object.entries(componentGenerics)) {
+		const placeholder = platform === "weapp" ? SCOPED_SLOT_GENERIC_KEY_RE.test(key) ? WEAPP_SCOPED_SLOT_GENERIC_COMPONENT_PLACEHOLDER : void 0 : ALIPAY_GENERIC_COMPONENT_PLACEHOLDER;
+		if (!placeholder) {
+			normalized[key] = value;
+			continue;
+		}
+		if (value === true) {
+			normalized[key] = { default: placeholder };
+			continue;
+		}
+		if (isObject(value)) {
+			const nextValue = { ...value };
+			if (typeof nextValue.default !== "string" || !nextValue.default.trim()) nextValue.default = placeholder;
+			normalized[key] = nextValue;
+			continue;
+		}
+		normalized[key] = value;
+	}
+	return normalized;
+}
+function resolveJson(entry, aliasEntries, platform, options) {
+	if (entry.json) {
+		const json = entry.type === "app" ? normalizeAppJson(structuredClone(entry.json)) : structuredClone(entry.json);
+		if (entry.type === "app" && options?.omitEmptySubPackages && json.subPackages?.length === 0) delete json.subPackages;
+		if (entry.jsonPath && Array.isArray(aliasEntries)) {
+			const usingComponents = get(json, "usingComponents");
+			if (isObject(usingComponents)) {
+				for (const [key, importee] of Object.entries(usingComponents)) {
+					const resolvedId = resolveImportee(importee, entry.jsonPath, aliasEntries);
+					set(json, `usingComponents.${key}`, resolvedId);
+				}
+				set(json, "usingComponents", normalizeUsingComponentsByPlatform(usingComponents, platform, options));
+			}
+			if (entry.type === "app") for (const field of ["subPackages", "subpackages"]) {
+				const subPackages = get(json, field);
+				if (Array.isArray(subPackages)) {
+					for (const subPackage of subPackages) if (subPackage.entry) subPackage.entry = changeFileExtension(subPackage.entry, "js");
+				}
+			}
+		} else {
+			const usingComponents = get(json, "usingComponents");
+			if (isObject(usingComponents)) set(json, "usingComponents", normalizeUsingComponentsByPlatform(usingComponents, platform, options));
+		}
+		const componentGenerics = get(json, "componentGenerics");
+		if (isObject(componentGenerics)) set(json, "componentGenerics", normalizeComponentGenericsByPlatform(componentGenerics, platform));
+		if (Reflect.has(json, "$schema")) delete json.$schema;
+		return stringifyJson(json);
+	}
+}
+const PROD_PATH_EXISTS_TTL_MS = 6e4;
+function getPathExistsTtlMs(config) {
+	return config?.isDev ? 250 : PROD_PATH_EXISTS_TTL_MS;
+}
+function getReadFileCheckMtime(config) {
+	return Boolean(config?.isDev);
+}
+//#endregion
+//#region src/utils/configErrors.ts
+const CJS_ERROR_PATTERNS = [
+	"__dirname is not defined",
+	"__filename is not defined",
+	"require is not defined",
+	"module is not defined",
+	"exports is not defined",
+	"es module scope"
+];
+function collectErrorText(error, texts) {
+	if (!error) return;
+	if (typeof error === "string") {
+		texts.push(error);
+		return;
+	}
+	if (typeof error === "object") {
+		const err = error;
+		if (err.message) texts.push(String(err.message));
+		if (err.stack) texts.push(String(err.stack));
+		if ("cause" in err) collectErrorText(err.cause, texts);
+	}
+}
+function formatConfigPath(configPath, cwd) {
+	if (!configPath) return "vite.config.ts";
+	const relative = path.relative(cwd, configPath);
+	if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) return relative;
+	return configPath;
+}
+function createCjsConfigLoadError(options) {
+	const texts = [];
+	collectErrorText(options.error, texts);
+	const haystack = texts.join("\n").toLowerCase();
+	if (!CJS_ERROR_PATTERNS.some((pattern) => haystack.includes(pattern))) return;
+	const message = `${formatConfigPath(options.configPath, options.cwd)} 为 CJS 格式，需要改为 ESM 写法（可参考 import.meta.dirname 等用法）。`;
+	const error = new Error(message);
+	if (options.error instanceof Error) error.cause = options.error;
+	return error;
+}
+//#endregion
+//#region src/utils/entryResolve.ts
+function buildCandidates(base, extensions) {
+	return extensions.map((ext) => changeFileExtension(base, ext));
+}
+function resolveEntryExtensions(kind, isDir) {
+	return kind === "named" || isDir ? [...scriptExtensions, ...vueExtensions] : [...vueExtensions, ...scriptExtensions];
+}
+function createCachedEntryResolveOptions(configService, options) {
+	return {
+		kind: options?.kind,
+		indexBaseName: options?.indexBaseName,
+		exists: (filePath) => pathExists(filePath, { ttlMs: getPathExistsTtlMs(configService) }),
+		stat: (filePath) => fs$1.stat(filePath)
+	};
+}
+/**
+* 用于处理 resolver 返回“目录路径”或“无扩展名路径”的场景。
+*
+* - 如果 `input` 是目录：尝试 `${dir}/${indexBaseName}.{js/ts..}`（必要时再尝试 .vue）
+* - 如果 `input` 没扩展名：尝试补全 `{.vue, .ts, .js...}`（default 优先 .vue，named 优先 js/ts）
+*
+* 如果 `input` 已带扩展名，则返回 `undefined`（表示无需补全）。
+*/
+async function resolveEntryPath(input, options) {
+	if (!input || typeof input !== "string") return;
+	if (path.extname(input)) return;
+	const kind = options?.kind ?? "default";
+	const exists = options?.exists ?? (async (p) => fs$1.pathExists(p));
+	const stat = options?.stat ?? (async (p) => fs$1.stat(p));
+	const indexBaseName = options?.indexBaseName ?? "index";
+	let base = input;
+	let isDir = false;
+	try {
+		isDir = Boolean((await stat(input))?.isDirectory?.());
+	} catch {
+		isDir = false;
+	}
+	if (isDir) base = path.join(input, indexBaseName);
+	const extensions = resolveEntryExtensions(kind, isDir);
+	for (const candidate of buildCandidates(base, extensions)) if (await exists(candidate)) return candidate;
+}
+//#endregion
+//#region src/utils/loadViteConfigFile.ts
+const DEFAULT_VITE_CONFIG_FILES = [
+	"vite.config.ts",
+	"vite.config.mts",
+	"vite.config.cts",
+	"vite.config.js",
+	"vite.config.mjs",
+	"vite.config.cjs"
+];
+const DEFAULT_VITE_CONFIG_FILE_SET = new Set(DEFAULT_VITE_CONFIG_FILES);
+const TYPELESS_PACKAGE_JSON_WARNING_CODE = "MODULE_TYPELESS_PACKAGE_JSON";
+function resolveWarningCode(warning, typeOrOptions, code) {
+	if (warning instanceof Error && typeof warning.code === "string") return warning.code;
+	if (typeOrOptions && typeof typeOrOptions === "object" && typeof typeOrOptions.code === "string") return typeOrOptions.code;
+	return code;
+}
+async function withSuppressedWarningCodes(suppressedCodes, fn) {
+	if (!suppressedCodes || suppressedCodes.length === 0) return fn();
+	const suppressedCodeSet = new Set(suppressedCodes);
+	const originalEmitWarning = process.emitWarning.bind(process);
+	process.emitWarning = ((warning, typeOrOptions, code) => {
+		const warningCode = resolveWarningCode(warning, typeOrOptions, code);
+		if (warningCode && suppressedCodeSet.has(warningCode)) return;
+		return originalEmitWarning(warning, typeOrOptions, code);
+	});
+	try {
+		return await fn();
+	} finally {
+		process.emitWarning = originalEmitWarning;
+	}
+}
+function isDefaultViteConfigBasename(filePath) {
+	return DEFAULT_VITE_CONFIG_FILE_SET.has(path.basename(filePath));
+}
+async function resolveImplicitConfigFile(configRoot) {
+	for (const fileName of DEFAULT_VITE_CONFIG_FILES) {
+		const filePath = path.resolve(configRoot, fileName);
+		try {
+			await fs$2.access(filePath);
+			return filePath;
+		} catch {
+			continue;
+		}
+	}
+}
+async function loadViteConfigFile(configEnv, configFile, configRoot, configFileDependencies, configFileExport, configLoader, suppressedWarningCodes, logLevel) {
+	const resolvedConfigFile = configFile ?? await resolveImplicitConfigFile(configRoot);
+	const resolvedConfigLoader = configLoader ?? "bundle";
+	return withSuppressedWarningCodes(suppressedWarningCodes, () => loadConfigFromFile(configEnv, resolvedConfigFile, configRoot, logLevel, void 0, resolvedConfigLoader));
+}
+//#endregion
+//#region src/utils/preloadScan.ts
+const HOST_ROUTER_METHODS = /* @__PURE__ */ new Set([
+	"navigateTo",
+	"redirectTo",
+	"reLaunch",
+	"switchTab"
+]);
+const ROUTER_METHODS = /* @__PURE__ */ new Set(["push", "replace"]);
+const ROUTER_MODULES = /* @__PURE__ */ new Set([
+	"vue-router",
+	"wevu",
+	"wevu/router"
+]);
+const ROUTER_FACTORY_METHODS = /* @__PURE__ */ new Map([
+	["createRouter", ROUTER_METHODS],
+	["useNativeRouter", HOST_ROUTER_METHODS],
+	["useRouter", ROUTER_METHODS]
+]);
+const TEMPLATE_NAVIGATOR_RE = /<navigator(?=\s|>)[^>]*?\surl\s*=\s*(["'])([^"'{}\s]+)\1/gi;
+function normalizePagePath$1(value) {
+	return path.posix.normalize(value).replace(/^\/+/, "").replace(/^\.\//, "");
+}
+function normalizeStaticTarget(target, sourcePage) {
+	const route = toPosixPath(target).split(/[?#]/, 1)[0];
+	return normalizePagePath$1(route.startsWith("/") ? route : route.startsWith("./") || route.startsWith("../") ? path.posix.join(path.posix.dirname(sourcePage), route) : route);
+}
+function getStaticString(node) {
+	if (node?.type === "StringLiteral" || node?.type === "Literal" && typeof node.value === "string") return node.value;
+	if (node?.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw;
+}
+function getPropertyName(node) {
+	if (!node) return;
+	if (node.type === "Identifier" && !node.computed) return node.name;
+	return getStaticString(node);
+}
+function getRouteFromObject(argument) {
+	if (argument?.type !== "ObjectExpression") return;
+	for (const property of argument.properties ?? []) {
+		if (property.type !== "ObjectProperty" && property.type !== "Property") continue;
+		const name = getPropertyName(property.key);
+		if (name !== "url" && name !== "path") continue;
+		const value = getStaticString(property.value);
+		if (value) return value;
+	}
+}
+function getIdentifierName(node) {
+	return node?.type === "Identifier" ? node.name : void 0;
+}
+function collectRouterBindings(ast) {
+	const importedFactories = /* @__PURE__ */ new Map();
+	const routerObjects = /* @__PURE__ */ new Map();
+	const routerFunctions = /* @__PURE__ */ new Map();
+	traverse$1(ast, { ImportDeclaration(importPath) {
+		if (!ROUTER_MODULES.has(importPath.node.source?.value)) return;
+		for (const specifier of importPath.node.specifiers ?? []) {
+			if (specifier.type !== "ImportSpecifier") continue;
+			const imported = getIdentifierName(specifier.imported) ?? getStaticString(specifier.imported);
+			const local = getIdentifierName(specifier.local);
+			const methods = imported ? ROUTER_FACTORY_METHODS.get(imported) : void 0;
+			const binding = local ? importPath.scope.getBinding(local) : void 0;
+			if (methods && binding) importedFactories.set(binding, methods);
+		}
+	} });
+	traverse$1(ast, { VariableDeclarator(declaratorPath) {
+		const init = declaratorPath.node.init;
+		const factory = init?.type === "CallExpression" ? getIdentifierName(init.callee) : void 0;
+		if (!factory) return;
+		const factoryBinding = declaratorPath.scope.getBinding(factory);
+		const methods = factoryBinding ? importedFactories.get(factoryBinding) : ROUTER_FACTORY_METHODS.get(factory);
+		if (!methods) return;
+		const id = declaratorPath.node.id;
+		const objectName = getIdentifierName(id);
+		if (objectName) {
+			const binding = declaratorPath.scope.getBinding(objectName);
+			if (binding?.constant) routerObjects.set(binding, methods);
+			return;
+		}
+		if (id?.type !== "ObjectPattern") return;
+		for (const property of id.properties ?? []) {
+			if (property.type !== "ObjectProperty" && property.type !== "Property") continue;
+			const importedMethod = getPropertyName(property.key);
+			const local = getIdentifierName(property.value);
+			const binding = local ? declaratorPath.scope.getBinding(local) : void 0;
+			if (importedMethod && methods.has(importedMethod) && binding?.constant) routerFunctions.set(binding, importedMethod);
+		}
+	} });
+	return {
+		routerFunctions,
+		routerObjects
+	};
+}
+function getNavigationMethod(callPath, bindings) {
+	const callee = callPath.node.callee;
+	const directName = getIdentifierName(callee);
+	const directMethod = directName ? bindings.routerFunctions.get(callPath.scope.getBinding(directName)) : void 0;
+	if (directMethod) return directMethod;
+	if (callee?.type !== "MemberExpression" && callee?.type !== "OptionalMemberExpression") return;
+	const objectName = getIdentifierName(callee.object);
+	const method = getPropertyName(callee.property);
+	if (objectName === "wx" && !callPath.scope.getBinding("wx") && method && HOST_ROUTER_METHODS.has(method)) return method;
+	if (objectName && method) {
+		if (bindings.routerObjects.get(callPath.scope.getBinding(objectName))?.has(method)) return method;
+	}
+}
+function collectScriptTargets(source, sourcePage) {
+	const targets = [];
+	try {
+		const ast = parseJsLike$1(source);
+		const bindings = collectRouterBindings(ast);
+		traverse$1(ast, { CallExpression(callPath) {
+			if (!getNavigationMethod(callPath, bindings)) return;
+			const argument = callPath.node.arguments?.[0];
+			const target = getStaticString(argument) ?? getRouteFromObject(argument);
+			if (target) targets.push(normalizeStaticTarget(target, sourcePage));
+		} });
+	} catch {}
+	return [...new Set(targets)];
+}
+function collectTemplateTargets(source, sourcePage) {
+	const targets = [];
+	const withoutComments = source.replace(/<!--[\s\S]*?-->/g, "");
+	TEMPLATE_NAVIGATOR_RE.lastIndex = 0;
+	for (const match of withoutComments.matchAll(TEMPLATE_NAVIGATOR_RE)) {
+		const target = match[2];
+		if (target) targets.push(normalizeStaticTarget(target, sourcePage));
+	}
+	return [...new Set(targets)];
+}
+function collectStaticRouteTargets(source, kind, sourcePage) {
+	return kind === "template" ? collectTemplateTargets(source, sourcePage) : collectScriptTargets(source, sourcePage);
+}
+//#endregion
+//#region src/utils/preloadRule.ts
+const PRELOAD_RULE_GLOB_RE = /[*?[\]{}()!+@]/g;
+function normalizePagePath(value) {
+	return normalizeRoot(value).replace(/^\/+/, "");
+}
+function normalizePackageRoot(value) {
+	return normalizeRoot(value).replace(/^\/+|\/+$/g, "");
+}
+function normalizeRule(value, pattern) {
+	if (!isObject(value)) throw new TypeError(`routeRules.${pattern}.preload 必须是对象。`);
+	const packages = value.packages;
+	if (!Array.isArray(packages) || packages.length === 0 || packages.some((item) => typeof item !== "string" || !item.trim())) throw new TypeError(`routeRules.${pattern}.preload.packages 必须是非空字符串数组。`);
+	const network = value.network;
+	if (network !== void 0 && network !== "all" && network !== "wifi") throw new TypeError(`routeRules.${pattern}.preload.network 只能是 "all" 或 "wifi"。`);
+	const normalizedPackages = [...new Set(packages.map((item) => normalizePackageRoot(item)).filter(Boolean))];
+	if (normalizedPackages.length === 0) throw new TypeError(`routeRules.${pattern}.preload.packages 必须包含有效的分包 root。`);
+	return {
+		packages: normalizedPackages,
+		...network === void 0 ? {} : { network }
+	};
+}
+function getRuleScore(pattern) {
+	const segments = pattern.split("/").filter(Boolean);
+	const wildcards = pattern.match(PRELOAD_RULE_GLOB_RE) ?? [];
+	PRELOAD_RULE_GLOB_RE.lastIndex = 0;
+	return [
+		segments.filter((segment) => {
+			PRELOAD_RULE_GLOB_RE.lastIndex = 0;
+			return !PRELOAD_RULE_GLOB_RE.test(segment);
+		}).length,
+		pattern.replace(PRELOAD_RULE_GLOB_RE, "").length,
+		-wildcards.length,
+		segments.length,
+		pattern.length
+	];
+}
+function compareScores(left, right) {
+	for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+		const leftValue = left[index] ?? 0;
+		const rightValue = right[index] ?? 0;
+		if (leftValue !== rightValue) return leftValue > rightValue ? 1 : -1;
+	}
+	return 0;
+}
+function pageCandidates(page) {
+	const normalized = normalizePagePath(page);
+	const withoutPagesPrefix = normalized.startsWith("pages/") ? normalized.slice(6) : normalized;
+	const candidates = /* @__PURE__ */ new Set();
+	for (const route of [normalized, withoutPagesPrefix]) {
+		const withoutIndex = route.replace(/\/index$/, "") || route;
+		for (const value of [route, withoutIndex]) {
+			candidates.add(value);
+			candidates.add(`/${value}`);
+		}
+	}
+	return [...candidates];
+}
+function findRouteRuleMatch(page, routeRules) {
+	if (!routeRules) return;
+	const candidates = pageCandidates(page);
+	let matched;
+	for (const [pattern, value] of Object.entries(routeRules)) {
+		if (!value || value.preload === void 0) continue;
+		if (!candidates.some((candidate) => picomatch(pattern)(candidate))) continue;
+		const rule = normalizeRule(value.preload, pattern);
+		const score = getRuleScore(pattern);
+		if (!matched || compareScores(score, matched.score) > 0) matched = {
+			page,
+			rule,
+			pattern,
+			score
+		};
+	}
+	if (!matched) return;
+	const { score: _score, ...result } = matched;
+	return result;
+}
+function collectSubPackages(appJson) {
+	return (Array.isArray(appJson.subPackages) ? appJson.subPackages : Array.isArray(appJson.subpackages) ? appJson.subpackages : []).flatMap((item) => {
+		if (!isObject(item) || typeof item.root !== "string") return [];
+		const root = normalizePackageRoot(item.root);
+		return (Array.isArray(item.pages) ? item.pages.filter((page) => typeof page === "string" && page.trim().length > 0) : []).map((page) => ({
+			route: normalizePagePath(path.posix.join(root, page)),
+			packageRoot: root,
+			...item.independent === true ? { independent: true } : {}
+		}));
+	});
+}
+function collectPreloadPages(appJson) {
+	return [...Array.isArray(appJson.pages) ? appJson.pages.filter((page) => typeof page === "string" && page.trim().length > 0).map((page) => ({ route: normalizePagePath(page) })) : [], ...collectSubPackages(appJson)];
+}
+function findPreloadRuleKey(page, preloadRule) {
+	const candidates = pageCandidates(page);
+	return Object.keys(preloadRule).find((candidate) => candidates.includes(normalizePagePath(candidate)));
+}
+function resolvePreloadPackageIdentifier(value, appJson) {
+	const normalized = value === "__APP__" ? value : normalizePackageRoot(value);
+	if (!normalized || normalized === "__APP__") return normalized || void 0;
+	const source = Array.isArray(appJson.subPackages) ? appJson.subPackages : Array.isArray(appJson.subpackages) ? appJson.subpackages : [];
+	for (const item of source) {
+		if (!isObject(item) || typeof item.root !== "string") continue;
+		const root = normalizePackageRoot(item.root);
+		if (root === normalized || typeof item.name === "string" && item.name === value) return root;
+	}
+	return normalized;
+}
+function cloneRule(rule) {
+	if (!isObject(rule)) return rule;
+	const packages = Array.isArray(rule.packages) ? rule.packages.filter((item) => typeof item === "string") : [];
+	return {
+		...rule,
+		packages: [...packages]
+	};
+}
+/**
+* @description 将 routeRules 中的 preload 声明合成为 app.json.preloadRule。
+* 手写的 preloadRule 保持优先，其他平台不生成微信专属字段。
+*/
+function applyPreloadRulesToAppJson(appJson, routeRules, platform) {
+	if (platform !== "weapp" || !routeRules) return appJson;
+	const existing = isObject(appJson.preloadRule) ? appJson.preloadRule : {};
+	const next = { ...existing };
+	for (const page of collectPreloadPages(appJson)) {
+		const match = findRouteRuleMatch(page.route, routeRules);
+		if (!match || findPreloadRuleKey(page.route, existing) !== void 0) continue;
+		next[page.route] = cloneRule(match.rule);
+	}
+	if (Object.keys(next).length > 0) appJson.preloadRule = next;
+	return appJson;
+}
+function suggestPreloadRules(appJson, pageSources) {
+	const pages = collectPreloadPages(appJson);
+	const pageByRoute = new Map(pages.map((page) => [page.route, page]));
+	const suggestions = [];
+	const uncovered = /* @__PURE__ */ new Set();
+	for (const page of pages) {
+		const source = pageSources.get(page.route);
+		for (const kind of ["template", "script"]) for (const target of collectStaticRouteTargets(source?.[kind] ?? "", kind, page.route)) {
+			const targetPage = pageByRoute.get(target);
+			if (!targetPage) continue;
+			const packageRoot = targetPage.packageRoot ?? (page.independent ? "__APP__" : void 0);
+			if (!packageRoot || packageRoot === page.packageRoot) continue;
+			const suggestion = {
+				page: page.route,
+				packageRoot,
+				target,
+				source: kind
+			};
+			suggestions.push(suggestion);
+		}
+		if (source && !source.template && !source.script) uncovered.add(page.route);
+	}
+	return {
+		pages,
+		suggestions,
+		uncovered: [...uncovered]
+	};
+}
+//#endregion
+//#region src/plugins/asset/prune.ts
+/** 成功写出后仅撤销上一轮持有的文件，不清空目录，也不越过输出根内的符号链接。 */
+async function pruneOwnedAssetFiles(outDir, fileNames) {
+	const root = path$1.resolve(outDir);
+	const files = [...fileNames].map((fileName) => {
+		const normalized = fileName.replaceAll("\\", "/");
+		const file = path$1.resolve(root, normalized);
+		const relative = path$1.relative(root, file);
+		if (!relative || relative === ".." || relative.startsWith(`..${path$1.sep}`) || path$1.isAbsolute(relative) || path$1.posix.isAbsolute(normalized) || /^[a-z]:/i.test(normalized)) throw new Error(`Invalid owned output asset path: ${fileName}`);
+		return file;
+	});
+	if (!files.length) return;
+	let realRoot;
+	try {
+		realRoot = await realpath(root);
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+	for (const file of files) try {
+		const parent = await realpath(path$1.dirname(file));
+		const relative = path$1.relative(realRoot, parent);
+		if (relative === ".." || relative.startsWith(`..${path$1.sep}`) || path$1.isAbsolute(relative)) throw new Error("Owned output asset parent resolves outside the output directory");
+		await unlink(file);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+}
+//#endregion
+//#region src/runtime/viteHost/engine.ts
+function readIdentity(file) {
+	const value = JSON.parse(readFileSync(file, "utf8"));
+	if (!value || typeof value !== "object" || !("name" in value) || typeof value.name !== "string" || !("version" in value) || typeof value.version !== "string") throw new Error("[weapp-vite] Vite 宿主 package.json 缺少 name/version。");
+	return {
+		name: value.name,
+		version: value.version
+	};
+}
+/** 按宿主的真实导出解析引擎，不依赖扁平 node_modules 布局或版本号相等。 */
+function resolveViteHost(importer = import.meta.url) {
+	const packagePath = createRequire(importer).resolve("vite/package.json");
+	const identity = readIdentity(packagePath);
+	const hostRequire = createRequire(packagePath);
+	if (identity.name === "@voidzero-dev/vite-plus-core") return {
+		kind: "vite-plus",
+		packagePath,
+		packageVersion: identity.version,
+		experimentalPath: hostRequire.resolve("@voidzero-dev/vite-plus-core/rolldown/experimental")
+	};
+	if (identity.name !== "vite") throw new Error(`[weapp-vite] 不支持的 Vite 宿主：${identity.name}@${identity.version}。`);
+	return {
+		kind: "vite",
+		packagePath,
+		packageVersion: identity.version,
+		experimentalPath: hostRequire.resolve("rolldown/experimental")
+	};
+}
+/** 加载与宿主绑定的引擎；缺失能力时保留原始错误，禁止回退到另一套引擎。 */
+async function loadHostRolldown(importer) {
+	let identity;
+	try {
+		identity = resolveViteHost(importer);
+		const runtime = await import(pathToFileURL(identity.experimentalPath).href);
+		if (typeof runtime.dev !== "function" || typeof runtime.scan !== "function") throw new TypeError("Rolldown 缺少 dev/scan 能力");
+		return runtime;
+	} catch (cause) {
+		const host = identity ? `${identity.kind}@${identity.packageVersion}` : "vite";
+		throw new Error(`[weapp-vite] 无法加载 ${host} 配套的 Rolldown；请检查宿主依赖和 Vite+ alias 配置。`, { cause });
+	}
+}
+/** 原生输出写出也绑定宿主引擎，避免 Vite+ 额外加载包内另一套 Rolldown。 */
+async function loadHostRolldownBuild(importer) {
+	const identity = resolveViteHost(importer);
+	const entry = createRequire(identity.packagePath).resolve(identity.kind === "vite-plus" ? "@voidzero-dev/vite-plus-core/rolldown" : "rolldown");
+	const runtime = await import(pathToFileURL(entry).href);
+	if (typeof runtime.rolldown !== "function") throw new TypeError(`[weapp-vite] ${identity.kind}@${identity.packageVersion} 缺少 Rolldown 原生写出能力。`);
+	return runtime;
+}
+//#endregion
+//#region src/utils/projectConfigOutput.ts
+/** 平台项目目录独立发布，禁止覆盖由主编译持有的小程序目录。 */
+async function collectProjectConfigAssets(sourceDir, outputRoot, outDir, watch) {
+	const assets = [];
+	async function visit(dir) {
+		watch?.(path.normalize(await realpath(dir)));
+		for (const entry of await readdir(dir, { withFileTypes: true })) {
+			const file = path.join(dir, entry.name);
+			if (entry.isSymbolicLink()) throw new Error(`[weapp-vite] 平台项目配置目录不支持符号链接：${path.relative(sourceDir, file)}`);
+			const fileName = path.relative(sourceDir, file);
+			const target = path.resolve(outputRoot, fileName);
+			const relative = path.relative(path.resolve(outDir), target);
+			if (!relative || !relative.startsWith("../") && relative !== ".." && !path.isAbsolute(relative)) throw new Error(`[weapp-vite] 平台项目配置不能覆盖小程序输出：${fileName}`);
+			if (entry.isDirectory()) await visit(file);
+			else if (entry.isFile()) {
+				watch?.(path.normalize(await realpath(file)));
+				assets.push({
+					fileName,
+					source: await readFile$1(file)
+				});
+			}
+		}
+	}
+	await visit(sourceDir);
+	return assets;
+}
+/** 使用宿主配套引擎写出平台配置，写入失败时不删除上一轮文件。 */
+async function publishProjectConfigAssets(outputRoot, assets, previous = /* @__PURE__ */ new Set()) {
+	const entry = "\0weapp-vite-project-config-output";
+	const { rolldown } = await loadHostRolldownBuild();
+	const bundle = await rolldown({
+		input: entry,
+		logLevel: "silent",
+		plugins: [{
+			name: "weapp-vite:project-config-writer",
+			resolveId: (id) => id === entry ? entry : void 0,
+			load: (id) => id === entry ? "export {}" : void 0,
+			generateBundle(_options, output) {
+				for (const [name, item] of Object.entries(output)) if (item.type === "chunk" && item.facadeModuleId === entry) delete output[name];
+				for (const asset of assets) this.emitFile({
+					type: "asset",
+					...asset
+				});
+			}
+		}]
+	});
+	const current = new Set(assets.map((asset) => asset.fileName));
+	try {
+		await bundle.write({
+			dir: outputRoot,
+			format: "es"
+		});
+		await pruneOwnedAssetFiles(outputRoot, [...previous].filter((file) => !current.has(file)));
+	} finally {
+		await bundle.close();
+	}
+	return current;
+}
+//#endregion
+//#region src/utils/projectConfig.ts
+async function readProjectConfigFile(filePath, required) {
+	if (!await fs$1.pathExists(filePath)) {
+		if (required) throw new Error(`找不到项目配置文件：${filePath}`);
+		return {};
+	}
+	try {
+		return await fs$1.readJson(filePath) || {};
+	} catch {
+		throw new Error(`解析 json 格式失败, ${filePath} 为非法的 json 格式`);
+	}
+}
+const DEFAULT_PROJECT_PRIVATE_CONFIG_FILE_NAME = "project.private.config.json";
+function getProjectConfigFileName(platform) {
+	return getProjectPlatformOptions(platform).projectConfigFileName;
+}
+function getProjectPrivateConfigFileName(_) {
+	return DEFAULT_PROJECT_PRIVATE_CONFIG_FILE_NAME;
+}
+function getProjectConfigRootKeys(platform) {
+	return getProjectPlatformOptions(platform).projectConfigRootKeys;
+}
+function resolveProjectConfigRoot(projectConfig, platform) {
+	const keys = getProjectConfigRootKeys(platform);
+	for (const key of keys) {
+		const value = projectConfig[key];
+		if (typeof value === "string" && value.trim()) return value;
+	}
+}
+async function getProjectConfig(root, options) {
+	const baseJsonPath = path.resolve(root, options?.basePath ?? "project.config.json");
+	const privateJsonPath = path.resolve(root, options?.privatePath ?? "project.private.config.json");
+	const baseJson = await readProjectConfigFile(baseJsonPath, true);
+	const privateJson = options?.ignorePrivate ? {} : await readProjectConfigFile(privateJsonPath, false);
+	return defuOverrideArray(privateJson, baseJson);
+}
+async function getProjectPrivateConfig(root, options) {
+	return await readProjectConfigFile(path.resolve(root, options?.privatePath ?? "project.private.config.json"), false);
+}
+async function disableProjectPrivateConfigHotReload(filePath) {
+	const config = await readProjectConfigFile(filePath, true);
+	const setting = config.setting && typeof config.setting === "object" && !Array.isArray(config.setting) ? config.setting : {};
+	if (setting.compileHotReLoad === false) return false;
+	config.setting = {
+		...setting,
+		compileHotReLoad: false
+	};
+	await fs$1.writeFile(filePath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+	return true;
+}
+function resolveProjectConfigSyncDirs(options) {
+	const outputRoot = path.dirname(options.outDir);
+	const sourceBasePath = path.resolve(options.projectConfigPath);
+	const sourceDir = path.dirname(sourceBasePath);
+	const resolvedOutputRoot = path.resolve(outputRoot);
+	const resolvedSourceDir = path.resolve(sourceDir);
+	return {
+		outputRoot,
+		sourceBasePath,
+		sourceDir,
+		resolvedOutputRoot,
+		resolvedSourceDir,
+		shouldSync: resolvedSourceDir !== resolvedOutputRoot
+	};
+}
+async function syncProjectConfigToOutput(options) {
+	if (!options.enabled || !options.projectConfigPath) return;
+	const syncDirs = resolveProjectConfigSyncDirs({
+		outDir: options.outDir,
+		projectConfigPath: options.projectConfigPath
+	});
+	if (!syncDirs.shouldSync) return;
+	const assets = await collectProjectConfigAssets(syncDirs.sourceDir, syncDirs.outputRoot, options.outDir);
+	await publishProjectConfigAssets(syncDirs.outputRoot, assets);
+}
+//#endregion
+//#region src/utils/reExport.ts
+function getExportedName(spec) {
+	const exported = spec?.exported;
+	if (!exported) return;
+	if (exported.type === "Identifier") return exported.name;
+	if (exported.type === "StringLiteral") return exported.value;
+}
+function getSourceValue(node) {
+	const source = node?.source;
+	if (!source || source.type !== "StringLiteral" && source.type !== "Literal") return;
+	return source.value;
+}
+function getReExportCacheKey(file, astEngine) {
+	return `${astEngine ?? "babel"}::${file}`;
+}
+function parseModuleForReExport(code, astEngine) {
+	if (astEngine === "oxc") return parseJsLikeWithEngine(code, {
+		engine: "oxc",
+		filename: "inline.ts"
+	});
+	return parse$2(code, BABEL_TS_MODULE_PARSER_OPTIONS$1).program;
+}
+async function resolveReExportedInternal(exporterFile, exportName, depth, visited, options) {
+	if (depth <= 0) return;
+	if (visited.has(exporterFile)) return;
+	visited.add(exporterFile);
+	const cacheKey = getReExportCacheKey(exporterFile, options.astEngine);
+	let entry = options.cache.get(cacheKey);
+	if (!entry) {
+		entry = /* @__PURE__ */ new Map();
+		options.cache.set(cacheKey, entry);
+	}
+	if (entry.has(exportName)) return entry.get(exportName);
+	let code;
+	try {
+		code = await options.readFile(exporterFile);
+	} catch {
+		entry.set(exportName, void 0);
+		return;
+	}
+	let ast;
+	try {
+		ast = parseModuleForReExport(code, options.astEngine);
+	} catch {
+		entry.set(exportName, void 0);
+		return;
+	}
+	const exportAllSources = [];
+	for (const node of ast.body ?? []) {
+		if (node?.type === "ExportNamedDeclaration") {
+			const source = getSourceValue(node);
+			if (!source) continue;
+			for (const spec of node.specifiers ?? []) {
+				if (spec?.type !== "ExportSpecifier") continue;
+				const exportedName = getExportedName(spec);
+				if (!exportedName || exportedName !== exportName) continue;
+				const resolved = await options.resolveId(source, exporterFile);
+				if (resolved) {
+					entry.set(exportName, resolved);
+					return resolved;
+				}
+			}
+		}
+		if (node?.type === "ExportAllDeclaration") {
+			const source = getSourceValue(node);
+			if (source) exportAllSources.push(source);
+		}
+	}
+	for (const source of exportAllSources) {
+		const hopId = await options.resolveId(source, exporterFile);
+		if (!hopId) continue;
+		const nested = await resolveReExportedInternal(hopId, exportName, depth - 1, visited, options);
+		if (nested) {
+			entry.set(exportName, nested);
+			return nested;
+		}
+	}
+	entry.set(exportName, void 0);
+}
+async function resolveReExportedName(exporterFile, exportName, options) {
+	return resolveReExportedInternal(exporterFile, exportName, options.maxDepth ?? 4, /* @__PURE__ */ new Set(), options);
+}
+//#endregion
+//#region src/utils/toAbsoluteId.ts
+function resolveAbsoluteIdBaseDir(configService, importer, options) {
+	const cleanImporter = importer ? normalizeFsResolvedId(importer) : void 0;
+	if (cleanImporter && !isSkippableResolvedId(cleanImporter) && path.isAbsolute(cleanImporter)) return path.dirname(cleanImporter);
+	return options?.base === "cwd" ? configService.cwd : configService.absoluteSrcRoot;
+}
+/**
+* 将可能为相对路径的 id 解析为绝对路径。
+*
+* - 会先对 id/importer 做 `normalizeFsResolvedId`（去 query、处理 file://、/@fs/、\0vue: 等）
+* - 若 id 已是绝对路径则直接返回
+* - 若 importer 是绝对路径，则以 importer 所在目录为基准解析
+* - 否则使用 `configService.absoluteSrcRoot`（默认）或 `configService.cwd`（可选）作为基准解析
+*
+* 注意：对于 `\0xxx` / `node:` 这类虚拟 id，会原样返回（不做路径解析）。
+*/
+function toAbsoluteId(id, configService, importer, options) {
+	const cleanId = normalizeFsResolvedId(id);
+	if (!cleanId || isSkippableResolvedId(cleanId)) return cleanId;
+	if (path.isAbsolute(cleanId)) return cleanId;
+	const baseDir = resolveAbsoluteIdBaseDir(configService, importer, options);
+	return path.resolve(baseDir, cleanId);
+}
+//#endregion
+//#region src/utils/usingComponentFrom.ts
+function shouldResolveUsingComponentFrom(normalizedResolvedFile) {
+	return Boolean(normalizedResolvedFile && !isSkippableResolvedId(normalizedResolvedFile) && path.isAbsolute(normalizedResolvedFile));
+}
+function usingComponentFromResolvedFile(resolvedFile, configService) {
+	if (!resolvedFile) return;
+	const normalized = normalizeFsResolvedId(resolvedFile);
+	if (!shouldResolveUsingComponentFrom(normalized)) return;
+	const base = removeExtensionDeep(normalized);
+	const relative = configService.relativeOutputPath(base);
+	if (!relative || relative.startsWith("..")) return;
+	return `/${toPosixPath(relative)}`;
+}
+//#endregion
+//#region src/utils/weappConfig.ts
+const WEAPP_VITE_CONFIG_CANDIDATES = [
+	"weapp-vite.config.ts",
+	"weapp-vite.config.mts",
+	"weapp-vite.config.cts",
+	"weapp-vite.config.js",
+	"weapp-vite.config.mjs",
+	"weapp-vite.config.cjs",
+	"weapp-vite.config.json"
+];
+const WEAPP_VITE_CONFIG_SET = new Set(WEAPP_VITE_CONFIG_CANDIDATES);
+function resolveSpecifiedWeappConfigPath(root, specified) {
+	return path.isAbsolute(specified) ? specified : path.resolve(root, specified);
+}
+function isWeappConfigBasename(filePath) {
+	return WEAPP_VITE_CONFIG_SET.has(path.basename(filePath));
+}
+function isExplicitCustomConfigFile(filePath) {
+	return path.basename(filePath).includes(".config.") && !isDefaultViteConfigBasename(filePath) && !isWeappConfigBasename(filePath);
+}
+async function findWeappConfigInDirectory(directory) {
+	for (const filename of WEAPP_VITE_CONFIG_CANDIDATES) {
+		const candidatePath = path.resolve(directory, filename);
+		if (await fs$1.pathExists(candidatePath)) return candidatePath;
+	}
+}
+async function resolveWeappConfigFile(options) {
+	const { root, specified } = options;
+	if (specified) {
+		const resolvedSpecified = resolveSpecifiedWeappConfigPath(root, specified);
+		if (isWeappConfigBasename(resolvedSpecified)) {
+			if (await fs$1.pathExists(resolvedSpecified)) return resolvedSpecified;
+			return;
+		}
+		if (isExplicitCustomConfigFile(resolvedSpecified)) return;
+		const fromSpecifiedDirectory = await findWeappConfigInDirectory(path.dirname(resolvedSpecified));
+		if (fromSpecifiedDirectory) return fromSpecifiedDirectory;
+	}
+	return findWeappConfigInDirectory(root);
+}
+//#endregion
+export { parseNpmPackageSpecifier as $, pathExists as A, ALIPAY_GENERIC_COMPONENT_PLACEHOLDER as B, resolvePreloadPackageIdentifier as C, createCachedEntryResolveOptions as D, loadViteConfigFile as E, BABEL_TS_MODULE_PARSER_OPTIONS$1 as F, normalizeAppJson as G, getAliasEntries as H, generate$1 as I, resolveJson as J, parseCommentJson as K, parse$2 as L, createCjsConfigLoadError as M, getPathExistsTtlMs as N, resolveEntryPath as O, getReadFileCheckMtime as P, normalizeNpmImportPathByPlatform as Q, parseJsLike$1 as R, findPreloadRuleKey as S, TYPELESS_PACKAGE_JSON_WARNING_CODE as T, jsonFileRemoveJsExtension as U, WEAPP_SCOPED_SLOT_GENERIC_COMPONENT_PLACEHOLDER as V, matches as W, hasNpmDependencyPrefix as X, toKebabCaseComponentName as Y, normalizeNpmImportLookupPath as Z, loadHostRolldown as _, resolveReExportedName as a, applyPreloadRulesToAppJson as b, getProjectConfigFileName as c, getProjectPrivateConfigFileName as d, resolveNpmDependencyId as et, resolveProjectConfigRoot as f, publishProjectConfigAssets as g, collectProjectConfigAssets as h, toAbsoluteId as i, readFile$2 as j, invalidateFileCache as k, getProjectConfigRootKeys as l, syncProjectConfigToOutput as m, shouldResolveUsingComponentFrom as n, disableProjectPrivateConfigHotReload as o, resolveProjectConfigSyncDirs as p, resolveImportee as q, usingComponentFromResolvedFile as r, getProjectConfig as s, resolveWeappConfigFile as t, getProjectPrivateConfig as u, loadHostRolldownBuild as v, suggestPreloadRules as w, collectPreloadPages as x, pruneOwnedAssetFiles as y, traverse$1 as z };