weapp-vite 7.3.0 → 7.5.0

package/dist/chunkStrategy-DRA5WpB-.mjs

@@ -0,0 +1,1436 @@
+import { a as parseSidecarModuleId, i as parseLogicalEntryId, o as parseSidecarSourceRequest } from "./protocol-vg8HGJ4n.mjs";
+import { r as normalizeRelativePath } from "./path-doV773b7.mjs";
+import { posix } from "pathe";
+import { removeExtensionDeep } from "@weapp-core/shared";
+import { Buffer } from "node:buffer";
+import MagicString from "magic-string";
+import remapping from "@jridgewell/remapping";
+//#region src/runtime/chunkStrategy/state.ts
+const sharedChunkDiagnostics = /* @__PURE__ */ new Map();
+const takeImportersMap = /* @__PURE__ */ new Map();
+const forceDuplicateSharedChunks = /* @__PURE__ */ new Set();
+const sharedChunkNameCache = /* @__PURE__ */ new Map();
+function resetTakeImportRegistry(options = {}) {
+	takeImportersMap.clear();
+	forceDuplicateSharedChunks.clear();
+	sharedChunkDiagnostics.clear();
+	if (!options.preserveSharedChunkNameCache) sharedChunkNameCache.clear();
+}
+function getTakeImporters(moduleId) {
+	return takeImportersMap.get(moduleId);
+}
+function markForceDuplicateSharedChunk(sharedName) {
+	if (!sharedName) return;
+	forceDuplicateSharedChunks.add(sharedName);
+	forceDuplicateSharedChunks.add(`${sharedName}.js`);
+}
+function isForceDuplicateSharedChunk(fileName) {
+	return forceDuplicateSharedChunks.has(fileName);
+}
+function hasForceDuplicateSharedChunks() {
+	return forceDuplicateSharedChunks.size > 0;
+}
+function recordSharedChunkDiagnostics(sharedName, ignoredMainImporters) {
+	if (!sharedName || ignoredMainImporters.length === 0) return;
+	const uniqueImporters = Array.from(new Set(ignoredMainImporters));
+	sharedChunkDiagnostics.set(sharedName, { ignoredMainImporters: uniqueImporters });
+	sharedChunkDiagnostics.set(`${sharedName}.js`, { ignoredMainImporters: uniqueImporters });
+}
+function consumeSharedChunkDiagnostics(fileName) {
+	const direct = sharedChunkDiagnostics.get(fileName);
+	if (direct) {
+		sharedChunkDiagnostics.delete(fileName);
+		return direct;
+	}
+	const withoutExt = fileName.replace(/\.[^./\\]+$/, "");
+	const fallback = sharedChunkDiagnostics.get(withoutExt);
+	if (fallback) {
+		sharedChunkDiagnostics.delete(withoutExt);
+		return fallback;
+	}
+}
+function getCachedSharedChunkName(moduleId) {
+	if (!sharedChunkNameCache.has(moduleId)) return;
+	return sharedChunkNameCache.get(moduleId) ?? null;
+}
+function setCachedSharedChunkName(moduleId, value) {
+	if (!moduleId) return;
+	sharedChunkNameCache.set(moduleId, value ?? null);
+}
+//#endregion
+//#region src/utils/sourcemap.ts
+function isEncodedSourceMapLike(value) {
+	return Boolean(value && typeof value === "object" && "version" in value && typeof value.version === "number" && "mappings" in value && "names" in value && "sources" in value);
+}
+function normalizeEncodedSourceMapLike(value) {
+	if (!value || typeof value !== "object") return null;
+	const sourceMap = value;
+	const numericVersion = typeof sourceMap.version === "number" ? sourceMap.version : typeof sourceMap.version === "string" ? Number(sourceMap.version) : NaN;
+	if (!Number.isFinite(numericVersion)) return null;
+	const normalized = {
+		...sourceMap,
+		version: numericVersion
+	};
+	return isEncodedSourceMapLike(normalized) ? normalized : null;
+}
+function composeSourceMaps(transformedMap, originalMap) {
+	if (isEncodedSourceMapLike(transformedMap) && isEncodedSourceMapLike(originalMap)) return remapping([transformedMap, originalMap], () => null);
+	if (isEncodedSourceMapLike(transformedMap)) return transformedMap;
+	if (isEncodedSourceMapLike(originalMap)) return originalMap;
+	return null;
+}
+/** 空来源名代表本轮转换输入；补齐身份和内容后再与上一层映射组合。 */
+function labelSourceMapInput(value, fileName, code) {
+	const map = normalizeEncodedSourceMapLike(value);
+	if (!map?.sources.includes("")) return map;
+	return {
+		...map,
+		sources: map.sources.map((source) => source || fileName),
+		sourcesContent: map.sources.map((source, index) => map.sourcesContent?.[index] ?? (source === "" ? code : null))
+	};
+}
+//#endregion
+//#region src/utils/outputChunk.ts
+const INLINE_SOURCE_MAP_RE = /\n?\/\/[#@]\s*sourceMappingURL=(data:application\/json\S*)\s*$/u;
+function resolveInlineSourceMap(code) {
+	const match = INLINE_SOURCE_MAP_RE.exec(code);
+	if (typeof match?.index !== "number") return null;
+	const dataUrl = match[1];
+	const commaIndex = dataUrl.indexOf(",");
+	if (commaIndex < 0) return null;
+	try {
+		const metadata = dataUrl.slice(0, commaIndex);
+		const payload = dataUrl.slice(commaIndex + 1);
+		const json = metadata.includes(";base64") ? Buffer.from(payload, "base64").toString("utf8") : decodeURIComponent(payload);
+		const map = normalizeEncodedSourceMapLike(JSON.parse(json));
+		return map ? {
+			code: code.slice(0, match.index),
+			map,
+			start: match.index
+		} : null;
+	} catch {
+		return null;
+	}
+}
+function appendInlineSourceMap(code, map) {
+	return `${code}${code.endsWith("\n") ? "" : "\n"}//# sourceMappingURL=data:application/json;charset=utf-8;base64,${Buffer.from(JSON.stringify(map)).toString("base64")}`;
+}
+/**
+* 返回不含 inline sourcemap 数据 URI 的实际脚本，供 AST 转换使用。
+*/
+function resolveOutputChunkTransformCode(chunk) {
+	return resolveInlineSourceMap(chunk.code)?.code ?? chunk.code;
+}
+/**
+* 应用 MagicString 改写，并把本轮映射与 chunk 既有映射组合。
+*/
+function applyMagicStringChunkRewrite(chunk, magicString, options) {
+	const previousCode = chunk.code;
+	const inlineSourceMap = resolveInlineSourceMap(previousCode);
+	if (inlineSourceMap) magicString.remove(inlineSourceMap.start, previousCode.length);
+	const nextCode = magicString.toString();
+	if (nextCode === (inlineSourceMap?.code ?? previousCode)) return false;
+	const previousMap = normalizeEncodedSourceMapLike(chunk.map) ?? inlineSourceMap?.map;
+	if (previousMap) {
+		const composedMap = composeSourceMaps(magicString.generateMap({
+			hires: options?.hires ?? "boundary",
+			includeContent: true,
+			source: chunk.fileName
+		}), previousMap);
+		chunk.map = composedMap;
+		chunk.code = inlineSourceMap && composedMap ? appendInlineSourceMap(nextCode, composedMap) : nextCode;
+	} else chunk.code = nextCode;
+	return true;
+}
+/**
+* 在 chunk 当前代码上执行一次可追踪编辑。
+*/
+function editOutputChunkCode(chunk, edit, options) {
+	const code = chunk.code;
+	const magicString = new MagicString(code);
+	edit(magicString, code);
+	return applyMagicStringChunkRewrite(chunk, magicString, options);
+}
+/**
+* 在 chunk 前方插入无源代码，同时保留原代码映射。
+*/
+function prependOutputChunkCode(chunk, code) {
+	if (!code) return false;
+	return editOutputChunkCode(chunk, (magicString) => magicString.prepend(code));
+}
+/**
+* 在 chunk 后方插入无源代码，同时保留原代码映射。
+*/
+function appendOutputChunkCode(chunk, code) {
+	if (!code) return false;
+	return editOutputChunkCode(chunk, (magicString) => magicString.append(code));
+}
+/**
+* 按原始代码坐标批量替换互不重叠的区间。
+*/
+function replaceOutputChunkCodeRanges(chunk, replacements) {
+	if (replacements.length === 0) return false;
+	const sorted = [...replacements].sort((left, right) => left.start - right.start);
+	let previousEnd = -1;
+	for (const replacement of sorted) {
+		if (replacement.start < 0 || replacement.end < replacement.start || replacement.end > chunk.code.length || replacement.start < previousEnd) throw new RangeError(`Invalid or overlapping output chunk replacement: ${replacement.start}-${replacement.end}`);
+		previousEnd = replacement.end;
+	}
+	return editOutputChunkCode(chunk, (magicString) => {
+		for (const replacement of sorted) magicString.overwrite(replacement.start, replacement.end, replacement.content);
+	});
+}
+/**
+* 使用正则匹配的原始坐标改写 chunk，避免整段字符串替换破坏映射。
+*/
+function replaceOutputChunkCode(chunk, pattern, replace) {
+	const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+	const matcher = new RegExp(pattern.source, flags);
+	const replacements = [];
+	for (const match of chunk.code.matchAll(matcher)) {
+		if (typeof match.index !== "number") continue;
+		const content = replace(match);
+		if (content == null || content === match[0]) continue;
+		replacements.push({
+			content,
+			end: match.index + match[0].length,
+			start: match.index
+		});
+	}
+	return replaceOutputChunkCodeRanges(chunk, replacements);
+}
+/**
+* 应用自带映射的完整代码转换，并组合 chunk 既有映射。
+*/
+function applyOutputChunkTransform(chunk, code, map) {
+	const previousInlineSourceMap = resolveInlineSourceMap(chunk.code);
+	const transformedInlineSourceMap = resolveInlineSourceMap(code);
+	const previousCode = previousInlineSourceMap?.code ?? chunk.code;
+	const transformedCode = transformedInlineSourceMap?.code ?? code;
+	if (transformedCode === previousCode) return false;
+	const previousMap = normalizeEncodedSourceMapLike(chunk.map) ?? previousInlineSourceMap?.map;
+	const transformedMap = normalizeEncodedSourceMapLike(map);
+	if (previousMap && !transformedMap) throw new Error(`Output chunk transform for ${chunk.fileName} must provide a source map`);
+	if (previousMap && transformedMap) {
+		const composedMap = composeSourceMaps(transformedMap, previousMap);
+		chunk.map = composedMap;
+		chunk.code = previousInlineSourceMap && composedMap ? appendInlineSourceMap(transformedCode, composedMap) : transformedCode;
+	} else chunk.code = transformedCode;
+	return true;
+}
+/**
+* 将 generateBundle 阶段组合后的 chunk map 提交到 Rolldown 管理的 map asset。
+*/
+function syncOutputChunkSourceMapAssets(bundle) {
+	let synced = 0;
+	for (const output of Object.values(bundle)) {
+		if (output?.type !== "chunk") continue;
+		const map = normalizeEncodedSourceMapLike(output.map);
+		if (!map) continue;
+		const mapAsset = bundle[output.sourcemapFileName ?? `${output.fileName}.map`];
+		if (!mapAsset || mapAsset.type !== "asset") continue;
+		mapAsset.source = JSON.stringify(map);
+		synced += 1;
+	}
+	return synced;
+}
+//#endregion
+//#region src/runtime/chunkStrategy/utils.ts
+function createRelativeImport(fromFile, toFile) {
+	const relative = posix.relative(posix.dirname(fromFile), toFile);
+	if (!relative || relative.startsWith(".")) return relative || "./";
+	return `./${relative}`;
+}
+//#endregion
+//#region src/runtime/chunkStrategy/bundle.ts
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function replaceChunkCodeAll(chunk, searchValue, replaceValue) {
+	if (!searchValue) return false;
+	const replaceExact = () => replaceOutputChunkCode(chunk, new RegExp(escapeRegExp(searchValue), "g"), () => replaceValue);
+	if (chunk.code.includes(searchValue)) return replaceExact();
+	if (searchValue.startsWith("./") && replaceValue.startsWith("./")) {
+		const trimmedSearch = searchValue.slice(2);
+		const trimmedReplace = replaceValue.slice(2);
+		if (trimmedSearch && chunk.code.includes(trimmedSearch)) return replaceOutputChunkCode(chunk, new RegExp(escapeRegExp(trimmedSearch), "g"), () => trimmedReplace);
+	}
+	return false;
+}
+function addDirectImporter(directImporters, imported, importer) {
+	if (typeof imported !== "string" || !imported || imported === importer) return;
+	let importers = directImporters.get(imported);
+	if (!importers) {
+		importers = /* @__PURE__ */ new Set();
+		directImporters.set(imported, importers);
+	}
+	importers.add(importer);
+}
+function removeDirectImporter(directImporters, imported, importer) {
+	const importers = directImporters.get(imported);
+	if (!importers) return;
+	importers.delete(importer);
+	if (!importers.size) directImporters.delete(imported);
+}
+function addCollectionImporters(directImporters, collection, importer) {
+	if (collection instanceof Set) {
+		for (const imported of collection) addDirectImporter(directImporters, imported, importer);
+		return;
+	}
+	if (Array.isArray(collection)) {
+		for (const imported of collection) addDirectImporter(directImporters, imported, importer);
+		return;
+	}
+	if (collection instanceof Map) for (const imported of collection.keys()) addDirectImporter(directImporters, imported, importer);
+}
+function isIdentifierChar(char) {
+	if (!char) return false;
+	const code = char.charCodeAt(0);
+	return code === 36 || code === 95 || code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function readQuotedSpecifier(code, fromIndex) {
+	let index = fromIndex;
+	while (index < code.length && /\s/.test(code[index])) index += 1;
+	const quote = code[index];
+	if (quote !== "'" && quote !== "\"" && quote !== "`") return;
+	let endIndex = index + 1;
+	while (endIndex < code.length) {
+		if (code[endIndex] === quote && code[endIndex - 1] !== "\\") return code.slice(index + 1, endIndex);
+		endIndex += 1;
+	}
+}
+function collectBareImportTargets(code, targets) {
+	let searchIndex = 0;
+	while (searchIndex < code.length) {
+		const importIndex = code.indexOf("import", searchIndex);
+		if (importIndex === -1) return;
+		if (isIdentifierChar(code[importIndex - 1])) {
+			searchIndex = importIndex + 6;
+			continue;
+		}
+		const specifier = readQuotedSpecifier(code, importIndex + 6);
+		if (specifier) targets.add(specifier);
+		searchIndex = importIndex + 6;
+	}
+}
+function collectImportFromTargets(code, targets) {
+	let searchIndex = 0;
+	while (searchIndex < code.length) {
+		const importIndex = code.indexOf("import", searchIndex);
+		if (importIndex === -1) return;
+		if (isIdentifierChar(code[importIndex - 1])) {
+			searchIndex = importIndex + 6;
+			continue;
+		}
+		const fromIndex = code.indexOf("from", importIndex + 6);
+		if (fromIndex !== -1) {
+			const specifier = readQuotedSpecifier(code, fromIndex + 4);
+			if (specifier) targets.add(specifier);
+		}
+		searchIndex = importIndex + 6;
+	}
+}
+function collectExportFromTargets(code, targets) {
+	let searchIndex = 0;
+	while (searchIndex < code.length) {
+		const exportIndex = code.indexOf("export", searchIndex);
+		if (exportIndex === -1) return;
+		if (isIdentifierChar(code[exportIndex - 1])) {
+			searchIndex = exportIndex + 6;
+			continue;
+		}
+		const fromIndex = code.indexOf("from", exportIndex + 6);
+		if (fromIndex !== -1) {
+			const specifier = readQuotedSpecifier(code, fromIndex + 4);
+			if (specifier) targets.add(specifier);
+		}
+		searchIndex = exportIndex + 6;
+	}
+}
+function collectRequireTargets(code, targets) {
+	let searchIndex = 0;
+	while (searchIndex < code.length) {
+		const requireIndex = code.indexOf("require", searchIndex);
+		if (requireIndex === -1) return;
+		if (isIdentifierChar(code[requireIndex - 1])) {
+			searchIndex = requireIndex + 7;
+			continue;
+		}
+		const openParenIndex = code.indexOf("(", requireIndex + 7);
+		if (openParenIndex !== -1) {
+			const specifier = readQuotedSpecifier(code, openParenIndex + 1);
+			if (specifier) targets.add(specifier);
+		}
+		searchIndex = requireIndex + 7;
+	}
+}
+function collectDynamicImportTargets(code, targets) {
+	let searchIndex = 0;
+	while (searchIndex < code.length) {
+		const importIndex = code.indexOf("import(", searchIndex);
+		if (importIndex === -1) return;
+		if (isIdentifierChar(code[importIndex - 1])) {
+			searchIndex = importIndex + 7;
+			continue;
+		}
+		const specifier = readQuotedSpecifier(code, importIndex + 7);
+		if (specifier) targets.add(specifier);
+		searchIndex = importIndex + 7;
+	}
+}
+function collectCodeImportTargets(code, targets) {
+	collectBareImportTargets(code, targets);
+	collectImportFromTargets(code, targets);
+	collectExportFromTargets(code, targets);
+	collectRequireTargets(code, targets);
+	collectDynamicImportTargets(code, targets);
+}
+function addCodeImporters(codeImporters, code, importer) {
+	if (!code) return;
+	const targets = /* @__PURE__ */ new Set();
+	collectCodeImportTargets(code, targets);
+	for (const target of targets) {
+		if (!target || !target.startsWith(".")) continue;
+		addDirectImporter(codeImporters, posix.normalize(posix.join(posix.dirname(importer), target)), importer);
+	}
+}
+function removeImporterFromCodeImporters(codeImporters, importer) {
+	for (const [target, importers] of codeImporters) {
+		importers.delete(importer);
+		if (!importers.size) codeImporters.delete(target);
+	}
+}
+function replaceInArray(list, searchValues, replaceValue, shouldInsert) {
+	const values = Array.isArray(list) ? [...list] : [];
+	let replaced = false;
+	for (let index = 0; index < values.length; index++) {
+		const current = values[index];
+		if (searchValues.includes(current)) {
+			values[index] = replaceValue;
+			replaced = true;
+		}
+	}
+	if ((replaced || shouldInsert) && replaceValue && !values.includes(replaceValue)) values.push(replaceValue);
+	return values;
+}
+function updateViteMetadata(importerChunk, originalFileNames, newChunkFile, shouldInsert) {
+	const metadata = importerChunk.viteMetadata;
+	if (!metadata || typeof metadata !== "object") return;
+	for (const key of [
+		"importedChunks",
+		"importedScripts",
+		"importedScriptsByUrl"
+	]) {
+		const collection = metadata[key];
+		if (collection instanceof Set) {
+			let hadOriginal = false;
+			for (const originalFileName of originalFileNames) hadOriginal = collection.delete(originalFileName) || hadOriginal;
+			if (hadOriginal || shouldInsert) collection.add(newChunkFile);
+		} else if (Array.isArray(collection)) metadata[key] = replaceInArray(collection, originalFileNames, newChunkFile, shouldInsert);
+		else if (collection instanceof Map) {
+			let originalValue;
+			let hadOriginal = false;
+			for (const originalFileName of originalFileNames) {
+				if (!collection.has(originalFileName)) continue;
+				if (!hadOriginal) originalValue = collection.get(originalFileName);
+				hadOriginal = true;
+				collection.delete(originalFileName);
+			}
+			if (hadOriginal) collection.set(newChunkFile, originalValue);
+		}
+	}
+}
+function createChunkImporterIndex(bundle, entries = Object.entries(bundle)) {
+	const directImporters = /* @__PURE__ */ new Map();
+	const codeImporters = /* @__PURE__ */ new Map();
+	const chunks = /* @__PURE__ */ new Map();
+	const addImporter = (target, importer) => {
+		if (!target || target === importer) return;
+		let importers = directImporters.get(target);
+		if (!importers) {
+			importers = /* @__PURE__ */ new Set();
+			directImporters.set(target, importers);
+		}
+		importers.add(importer);
+	};
+	for (const [fileName, output] of entries) {
+		if (output?.type !== "chunk") continue;
+		const chunk = output;
+		chunks.set(fileName, chunk);
+		for (const imported of chunk.imports ?? []) addImporter(imported, fileName);
+		for (const imported of chunk.dynamicImports ?? []) addImporter(imported, fileName);
+		addCodeImporters(codeImporters, chunk.code, fileName);
+		const metadata = chunk.viteMetadata;
+		if (metadata) {
+			addCollectionImporters(directImporters, metadata.importedChunks, fileName);
+			addCollectionImporters(directImporters, metadata.importedScripts ?? metadata.importedScriptsByUrl, fileName);
+		}
+	}
+	return {
+		directImporters,
+		codeImporters,
+		chunks
+	};
+}
+function removeChunkFromImporterIndex(index, fileName) {
+	index.chunks.delete(fileName);
+	index.directImporters.delete(fileName);
+	removeImporterFromCodeImporters(index.codeImporters, fileName);
+	for (const [target, importers] of index.directImporters) {
+		importers.delete(fileName);
+		if (!importers.size) index.directImporters.delete(target);
+	}
+}
+function updateChunkImporterIndex(index, importerFile, originalFileNames, newChunkFile, shouldInsert) {
+	if (!newChunkFile || originalFileNames.includes(newChunkFile)) return;
+	let hadOriginal = false;
+	for (const originalFileName of originalFileNames) {
+		hadOriginal = index.directImporters.get(originalFileName)?.has(importerFile) === true || hadOriginal;
+		removeDirectImporter(index.directImporters, originalFileName, importerFile);
+	}
+	if (hadOriginal || shouldInsert) addDirectImporter(index.directImporters, newChunkFile, importerFile);
+}
+function findChunkImporters(bundle, target, index = createChunkImporterIndex(bundle)) {
+	const importers = new Set(index.directImporters.get(target));
+	for (const importer of index.codeImporters.get(target) ?? []) importers.add(importer);
+	return Array.from(importers);
+}
+function ensureUniqueFileName(bundle, fileName) {
+	if (!bundle[fileName]) return fileName;
+	const { dir, name, ext } = posix.parse(fileName);
+	let index = 1;
+	let candidate = fileName;
+	while (bundle[candidate]) {
+		const nextName = `${name}.${index}`;
+		candidate = dir ? posix.join(dir, `${nextName}${ext}`) : `${nextName}${ext}`;
+		index += 1;
+	}
+	return candidate;
+}
+function updateImporters(bundle, importerToChunk, originalFileName, index) {
+	const originalFileNames = Array.isArray(originalFileName) ? originalFileName : [originalFileName];
+	for (const [importerFile, newChunkFile] of importerToChunk.entries()) {
+		const importer = bundle[importerFile];
+		if (!importer || importer.type !== "chunk") continue;
+		const importerChunk = importer;
+		const newImportPath = createRelativeImport(importerFile, newChunkFile);
+		let codeUpdated = false;
+		for (const originalFileName of originalFileNames) {
+			const originalImportPath = createRelativeImport(importerFile, originalFileName);
+			if (originalImportPath === newImportPath) continue;
+			codeUpdated = replaceChunkCodeAll(importerChunk, originalImportPath, newImportPath) || codeUpdated;
+		}
+		importerChunk.imports = replaceInArray(importerChunk.imports, originalFileNames, newChunkFile, codeUpdated);
+		importerChunk.dynamicImports = replaceInArray(importerChunk.dynamicImports, originalFileNames, newChunkFile, codeUpdated);
+		const implicitlyLoadedBefore = importerChunk.implicitlyLoadedBefore;
+		if (Array.isArray(implicitlyLoadedBefore)) importerChunk.implicitlyLoadedBefore = replaceInArray(implicitlyLoadedBefore, originalFileNames, newChunkFile, codeUpdated);
+		const referencedFiles = importerChunk.referencedFiles;
+		if (Array.isArray(referencedFiles)) importerChunk.referencedFiles = replaceInArray(referencedFiles, originalFileNames, newChunkFile, codeUpdated);
+		updateViteMetadata(importerChunk, originalFileNames, newChunkFile, codeUpdated);
+		if (index) {
+			updateChunkImporterIndex(index, importerFile, originalFileNames, newChunkFile, codeUpdated);
+			if (codeUpdated) {
+				removeImporterFromCodeImporters(index.codeImporters, importerFile);
+				addCodeImporters(index.codeImporters, importerChunk.code, importerFile);
+			}
+		}
+	}
+}
+//#endregion
+//#region src/runtime/chunkStrategy/collector.ts
+function resolveChunkGraphSourceId(id) {
+	return parseLogicalEntryId(id)?.sourceId ?? parseSidecarModuleId(id)?.ownerId ?? parseSidecarSourceRequest(id)?.ownerId ?? id;
+}
+function resolveSubPackagePrefix(fileName, subPackageRoots) {
+	for (const root of subPackageRoots) {
+		if (!root) continue;
+		if (fileName === root || fileName.startsWith(`${root}/`)) return root;
+	}
+	return "";
+}
+function collectEffectivePrefixes(importer, options, state) {
+	const cached = state.cache.get(importer);
+	if (cached) return {
+		prefixes: [...cached.prefixes],
+		hasRealMain: cached.hasRealMain,
+		ignored: [...cached.ignored]
+	};
+	if (state.stack.has(importer)) return {
+		prefixes: [""],
+		hasRealMain: true,
+		ignored: []
+	};
+	state.stack.add(importer);
+	const { ctx, relativeAbsoluteSrcRoot, subPackageRoots, forceDuplicateTester } = options;
+	const sourceImporter = resolveChunkGraphSourceId(importer);
+	const relativeId = relativeAbsoluteSrcRoot(sourceImporter);
+	const subPackagePrefix = resolveSubPackagePrefix(relativeId, subPackageRoots);
+	if (subPackagePrefix) {
+		const result = {
+			prefixes: [subPackagePrefix],
+			hasRealMain: false,
+			ignored: []
+		};
+		state.cache.set(importer, result);
+		state.stack.delete(importer);
+		return {
+			prefixes: [...result.prefixes],
+			hasRealMain: result.hasRealMain,
+			ignored: []
+		};
+	}
+	const importerParents = ctx.getModuleInfo(importer)?.importers ?? [];
+	const forcedDuplicate = forceDuplicateTester?.(relativeId, sourceImporter) ?? false;
+	if (!importerParents.length) {
+		const result = forcedDuplicate ? {
+			prefixes: [],
+			hasRealMain: false,
+			ignored: [relativeId]
+		} : {
+			prefixes: [""],
+			hasRealMain: true,
+			ignored: []
+		};
+		state.cache.set(importer, result);
+		state.stack.delete(importer);
+		return {
+			prefixes: [...result.prefixes],
+			hasRealMain: result.hasRealMain,
+			ignored: [...result.ignored]
+		};
+	}
+	const aggregatedPrefixes = /* @__PURE__ */ new Set();
+	let hasRealMain = false;
+	const aggregatedIgnored = [];
+	for (const parent of importerParents) {
+		const collectorResult = collectEffectivePrefixes(parent, options, state);
+		for (const prefix of collectorResult.prefixes) aggregatedPrefixes.add(prefix);
+		if (collectorResult.hasRealMain) hasRealMain = true;
+		if (collectorResult.ignored.length) aggregatedIgnored.push(...collectorResult.ignored);
+	}
+	if (!aggregatedPrefixes.size) {
+		aggregatedPrefixes.add("");
+		hasRealMain = true;
+	}
+	const ignored = !aggregatedPrefixes.has("") && importerParents.length > 0 || forcedDuplicate && !aggregatedPrefixes.has("") ? [relativeId] : [];
+	const result = {
+		prefixes: Array.from(aggregatedPrefixes),
+		hasRealMain,
+		ignored: Array.from(/* @__PURE__ */ new Set([...aggregatedIgnored, ...ignored]))
+	};
+	state.cache.set(importer, result);
+	state.stack.delete(importer);
+	return {
+		prefixes: [...result.prefixes],
+		hasRealMain: result.hasRealMain,
+		ignored: [...result.ignored]
+	};
+}
+function summarizeImportPrefixes(options) {
+	const { ctx, importers, relativeAbsoluteSrcRoot, subPackageRoots, forceDuplicateTester } = options;
+	const summary = {};
+	const ignoredImporters = /* @__PURE__ */ new Set();
+	const state = {
+		cache: /* @__PURE__ */ new Map(),
+		stack: /* @__PURE__ */ new Set()
+	};
+	for (const importer of importers) {
+		const { prefixes, ignored } = collectEffectivePrefixes(importer, {
+			ctx,
+			relativeAbsoluteSrcRoot,
+			subPackageRoots,
+			forceDuplicateTester
+		}, state);
+		for (const prefix of prefixes) summary[prefix] = (summary[prefix] || 0) + 1;
+		for (const entry of ignored) ignoredImporters.add(entry);
+	}
+	return {
+		summary,
+		ignoredMainImporters: Array.from(ignoredImporters)
+	};
+}
+function assertModuleScopedToRoot(options) {
+	const { moduleInfo, moduleRoot, relativeAbsoluteSrcRoot, subPackageRoots, moduleId } = options;
+	if (!moduleRoot || !moduleInfo?.importers?.length) return;
+	for (const importer of moduleInfo.importers) {
+		const sourceImporter = resolveChunkGraphSourceId(importer);
+		if (resolveSubPackagePrefix(relativeAbsoluteSrcRoot(sourceImporter), subPackageRoots) !== moduleRoot) {
+			const moduleLabel = relativeAbsoluteSrcRoot(moduleId);
+			const importerLabel = relativeAbsoluteSrcRoot(sourceImporter);
+			throw new Error(`[分包] 模块 "${moduleLabel}" 位于分包 "${moduleRoot}"，但被 "${importerLabel}" 引用，请将该模块移动到主包或公共目录以进行跨分包共享。`);
+		}
+	}
+}
+//#endregion
+//#region src/runtime/chunkStrategy/sourcemap.ts
+function isSourceLike(source) {
+	return typeof source === "string" || source instanceof Uint8Array || Buffer.isBuffer(source);
+}
+function cloneSourceLike(source) {
+	if (typeof source === "string") return source;
+	return Buffer.from(source);
+}
+function collectSourceMapKeys(fileName, chunk) {
+	const keys = /* @__PURE__ */ new Set();
+	if (fileName) keys.add(`${fileName}.map`);
+	if (typeof chunk.sourcemapFileName === "string" && chunk.sourcemapFileName) keys.add(chunk.sourcemapFileName);
+	return keys;
+}
+function findSourceMapAsset(bundle, candidateKeys) {
+	for (const key of candidateKeys) {
+		if (!key) continue;
+		const entry = bundle[key];
+		if (entry?.type === "asset") return {
+			asset: entry,
+			key
+		};
+	}
+}
+function resolveSourceMapSource(originalMap, assetSource) {
+	if (originalMap) {
+		if (typeof originalMap === "string") return originalMap;
+		if (originalMap instanceof Uint8Array || Buffer.isBuffer(originalMap)) return Buffer.from(originalMap);
+		return JSON.stringify(originalMap);
+	}
+	if (isSourceLike(assetSource)) return cloneSourceLike(assetSource);
+}
+function resolveEncodedSourceMap(originalMap, assetSource) {
+	const chunkMap = normalizeEncodedSourceMapLike(originalMap);
+	if (chunkMap) return chunkMap;
+	if (!isSourceLike(assetSource)) return null;
+	try {
+		const source = typeof assetSource === "string" ? assetSource : Buffer.from(assetSource).toString("utf8");
+		return normalizeEncodedSourceMapLike(JSON.parse(source));
+	} catch {
+		return null;
+	}
+}
+function emitSourceMapAsset(ctx, targetFileName, sourceMapAssetInfo, fallbackSource) {
+	if (!targetFileName) return;
+	if (sourceMapAssetInfo?.asset && isSourceLike(sourceMapAssetInfo.asset.source)) {
+		const [name] = sourceMapAssetInfo.asset.names ?? [];
+		ctx.emitFile({
+			type: "asset",
+			fileName: targetFileName,
+			source: cloneSourceLike(sourceMapAssetInfo.asset.source),
+			...name ? { name } : {}
+		});
+		return;
+	}
+	if (fallbackSource) ctx.emitFile({
+		type: "asset",
+		fileName: targetFileName,
+		source: cloneSourceLike(fallbackSource)
+	});
+}
+//#endregion
+//#region src/runtime/chunkStrategy/apply/runtime.ts
+const ROLLDOWN_RUNTIME_FILE_NAME$2 = "rolldown-runtime.js";
+function applyRuntimeChunkLocalization(bundle, options) {
+	if (!this) throw new Error("applyRuntimeChunkLocalization 需要 PluginContext。");
+	const runtimeFileName = options.runtimeFileName ?? ROLLDOWN_RUNTIME_FILE_NAME$2;
+	const runtimeRecord = resolveRuntimeBundleRecord(bundle, runtimeFileName);
+	if (!runtimeRecord) return;
+	const { output: runtimeOutput, lookupKeys: runtimeLookupKeys } = runtimeRecord;
+	const runtimeSource = resolveRuntimeSource(runtimeOutput);
+	if (!runtimeSource) return;
+	const subPackageRoots = Array.from(options.subPackageRoots).filter(Boolean);
+	if (!subPackageRoots.length) return;
+	const runtimeLookupSet = new Set(runtimeLookupKeys);
+	const rootToImporters = /* @__PURE__ */ new Map();
+	for (const [fileName, output] of Object.entries(bundle)) {
+		if (output?.type !== "chunk") continue;
+		const root = resolveSubPackagePrefix(fileName, subPackageRoots);
+		if (!root) continue;
+		if (!chunkReferencesRuntime(output, runtimeFileName, runtimeLookupSet)) continue;
+		const existing = rootToImporters.get(root);
+		if (existing) existing.push(fileName);
+		else rootToImporters.set(root, [fileName]);
+	}
+	const forceRoots = Array.from(options.forceRoots ?? []).filter(Boolean);
+	for (const root of forceRoots) {
+		if (!subPackageRoots.includes(root)) continue;
+		if (!rootToImporters.has(root)) rootToImporters.set(root, []);
+	}
+	if (!rootToImporters.size) return;
+	const importerToRuntime = /* @__PURE__ */ new Map();
+	const duplicates = [];
+	for (const [root, importerFiles] of rootToImporters.entries()) {
+		const duplicateBaseName = posix.basename(runtimeFileName);
+		const uniqueFileName = ensureUniqueFileName(bundle, posix.join(root, duplicateBaseName));
+		this.emitFile({
+			type: "asset",
+			fileName: uniqueFileName,
+			source: cloneSourceLike(runtimeSource)
+		});
+		if (runtimeOutput.type === "chunk") options.onEmitChunk?.(uniqueFileName, runtimeOutput);
+		for (const importerFile of importerFiles) importerToRuntime.set(importerFile, uniqueFileName);
+		duplicates.push({
+			fileName: uniqueFileName,
+			importers: [...importerFiles]
+		});
+	}
+	updateImporters(bundle, importerToRuntime, runtimeLookupKeys);
+	options.onDuplicate?.({
+		runtimeFileName,
+		duplicates
+	});
+}
+function chunkReferencesRuntime(chunk, runtimeFileName, runtimeLookupSet) {
+	const hasRuntimeReference = (specifier) => runtimeLookupSet.has(specifier) || posix.basename(specifier) === runtimeFileName;
+	if (chunk.imports.some(hasRuntimeReference) || chunk.dynamicImports.some(hasRuntimeReference)) return true;
+	const metadata = chunk.viteMetadata;
+	if (metadata) {
+		const importedChunks = metadata.importedChunks;
+		if (hasInCollection(importedChunks, runtimeFileName)) return true;
+		for (const lookupKey of runtimeLookupSet) if (hasInCollection(importedChunks, lookupKey)) return true;
+		const importedScripts = metadata.importedScripts ?? metadata.importedScriptsByUrl;
+		if (hasInCollection(importedScripts, runtimeFileName)) return true;
+		for (const lookupKey of runtimeLookupSet) if (hasInCollection(importedScripts, lookupKey)) return true;
+	}
+	return (chunk.code ?? "").includes(runtimeFileName);
+}
+function resolveRuntimeBundleRecord(bundle, runtimeFileName) {
+	const direct = bundle[runtimeFileName];
+	if (isRuntimeBundleOutput(direct)) return {
+		output: direct,
+		lookupKeys: dedupeLookupKeys([runtimeFileName, resolveBundleOutputFileName(direct, runtimeFileName)])
+	};
+	for (const [key, output] of Object.entries(bundle)) {
+		if (!isRuntimeBundleOutput(output)) continue;
+		const fileName = resolveBundleOutputFileName(output, key);
+		if (fileName !== runtimeFileName && posix.basename(fileName) !== runtimeFileName) continue;
+		return {
+			output,
+			lookupKeys: dedupeLookupKeys([
+				runtimeFileName,
+				key,
+				fileName
+			])
+		};
+	}
+}
+function resolveRuntimeSource(output) {
+	if (output.type === "chunk") return output.code || void 0;
+	if (typeof output.source === "string" || output.source instanceof Uint8Array || Buffer.isBuffer(output.source)) return output.source;
+	if (output.source == null) return;
+	return String(output.source);
+}
+function hasInCollection(collection, value) {
+	if (!collection || !value) return false;
+	if (collection instanceof Set) return collection.has(value);
+	if (Array.isArray(collection)) return collection.includes(value);
+	if (collection instanceof Map) return collection.has(value);
+	return false;
+}
+function resolveBundleOutputFileName(output, fallback) {
+	if (typeof output.fileName === "string" && output.fileName) return output.fileName;
+	return fallback;
+}
+function dedupeLookupKeys(values) {
+	return Array.from(new Set(values.filter(Boolean)));
+}
+function isRuntimeBundleOutput(output) {
+	return output?.type === "chunk" || output?.type === "asset";
+}
+//#endregion
+//#region src/runtime/chunkStrategy/constants.ts
+const SHARED_CHUNK_VIRTUAL_PREFIX = "weapp_shared_virtual";
+const SUB_PACKAGE_SHARED_DIR = "weapp-shared";
+const DEFAULT_SHARED_CHUNK_STRATEGY = "hoist";
+//#endregion
+//#region src/runtime/chunkStrategy/apply/rewrite.ts
+const ROLLDOWN_RUNTIME_FILE_NAME$1 = "rolldown-runtime.js";
+const REGEXP_ESCAPE_PATTERN = /[.*+?^${}()|[\]\\]/g;
+function createChunkSourceFileNameCandidates(fileName) {
+	const candidates = [fileName];
+	const normalized = resolveChunkSourceFileNameForRewrite(fileName);
+	if (normalized !== fileName) candidates.push(normalized);
+	return candidates;
+}
+function reserveUniqueFileName(reservedFileNames, fileName) {
+	if (!reservedFileNames.has(fileName)) {
+		reservedFileNames.add(fileName);
+		return fileName;
+	}
+	const { dir, name, ext } = posix.parse(fileName);
+	let index = 1;
+	let candidate = fileName;
+	while (reservedFileNames.has(candidate)) {
+		const nextName = `${name}.${index}`;
+		candidate = dir ? posix.join(dir, `${nextName}${ext}`) : `${nextName}${ext}`;
+		index += 1;
+	}
+	reservedFileNames.add(candidate);
+	return candidate;
+}
+function createChunkImportSpecifiersRewrite(sourceCode, options) {
+	const { sourceFileName, sourceFileNames, targetFileName, imports, dynamicImports, runtimeFileName, resolveImportTarget } = options;
+	const sourceFileNameCandidates = (sourceFileNames ?? [sourceFileName ?? ""]).filter(Boolean);
+	const specifiers = new Set([...imports, ...dynamicImports].filter(Boolean));
+	const magicString = new MagicString(sourceCode);
+	const rewrittenRanges = /* @__PURE__ */ new Set();
+	for (const specifier of specifiers) {
+		const targetImportPath = createRelativeImportPath(targetFileName, posix.basename(specifier) === ROLLDOWN_RUNTIME_FILE_NAME$1 ? runtimeFileName : resolveImportTarget?.(specifier) ?? specifier);
+		if (!targetImportPath) continue;
+		for (const sourceCandidate of sourceFileNameCandidates) {
+			const sourceImportPath = createRelativeImportPath(sourceCandidate, specifier);
+			if (!sourceImportPath || sourceImportPath === targetImportPath) continue;
+			replaceQuotedImportLiteralValue(magicString, sourceCode, sourceImportPath, targetImportPath, rewrittenRanges);
+		}
+	}
+	return magicString;
+}
+function resolveChunkSourceFileNameForRewrite(fileName) {
+	if (!fileName.startsWith(`weapp_shared_virtual/`)) return fileName;
+	return fileName.slice(21);
+}
+function replaceQuotedImportLiteralValue(magicString, sourceCode, sourcePath, targetPath, rewrittenRanges) {
+	const escapedSourcePath = escapeRegExpForPattern(sourcePath);
+	const pattern = new RegExp(`(['"\`])${escapedSourcePath}\\1`, "g");
+	for (const match of sourceCode.matchAll(pattern)) {
+		if (typeof match.index !== "number") continue;
+		const end = match.index + match[0].length;
+		const rangeKey = `${match.index}:${end}`;
+		if (rewrittenRanges.has(rangeKey)) continue;
+		const quote = match[1];
+		magicString.overwrite(match.index, end, `${quote}${targetPath}${quote}`);
+		rewrittenRanges.add(rangeKey);
+	}
+}
+function escapeRegExpForPattern(value) {
+	return value.replace(REGEXP_ESCAPE_PATTERN, "\\$&");
+}
+function createRelativeImportPath(fromFileName, toFileName) {
+	const relativePath = posix.relative(posix.dirname(fromFileName), toFileName);
+	if (!relativePath || relativePath.startsWith(".")) return relativePath || "./";
+	return `./${relativePath}`;
+}
+//#endregion
+//#region src/runtime/chunkStrategy/apply/shared/runtime.ts
+const ROLLDOWN_RUNTIME_FILE_NAME = "rolldown-runtime.js";
+const SLASHES_PATTERN = /[\\/]+/g;
+function createCrossSubPackageDuplicateBaseName(sourceRoot, fileName) {
+	return `${sourceRoot.replace(SLASHES_PATTERN, "_")}.${posix.basename(fileName)}`;
+}
+function ensureLocalizedDuplicate(args) {
+	const { runtimeContext, pendingLocalizedDuplicates, root, sourceFileName } = args;
+	const sourceRoot = resolveSubPackagePrefix(sourceFileName, runtimeContext.subPackageRoots);
+	if (!sourceRoot || sourceRoot === root) return sourceFileName;
+	const key = `${root}::${sourceFileName}`;
+	const existing = runtimeContext.localizedDuplicateFileMap.get(key);
+	if (existing) return existing;
+	const sourceOutput = runtimeContext.bundle[sourceFileName];
+	if (sourceOutput?.type !== "chunk") return sourceFileName;
+	const duplicateBaseName = createCrossSubPackageDuplicateBaseName(sourceRoot, sourceFileName);
+	const targetFileName = reserveUniqueFileName(runtimeContext.reservedFileNames, posix.join(root, SUB_PACKAGE_SHARED_DIR, duplicateBaseName));
+	runtimeContext.localizedDuplicateFileMap.set(key, targetFileName);
+	pendingLocalizedDuplicates.push({
+		root,
+		sourceFileName,
+		targetFileName,
+		chunk: sourceOutput
+	});
+	return targetFileName;
+}
+function rewriteDuplicatedChunkSource(args) {
+	const runtimeFileName = posix.join(args.root, ROLLDOWN_RUNTIME_FILE_NAME);
+	const sourceMapKeys = collectSourceMapKeys(args.sourceFileName, args.chunk);
+	const sourceMapAssetInfo = findSourceMapAsset(args.runtimeContext.bundle, sourceMapKeys);
+	const rewrittenChunk = {
+		...args.chunk,
+		map: resolveEncodedSourceMap(args.chunk.map, sourceMapAssetInfo?.asset.source)
+	};
+	applyMagicStringChunkRewrite(rewrittenChunk, createChunkImportSpecifiersRewrite(rewrittenChunk.code ?? "", {
+		sourceFileNames: createChunkSourceFileNameCandidates(args.sourceFileName),
+		targetFileName: args.targetFileName,
+		imports: args.chunk.imports,
+		dynamicImports: args.chunk.dynamicImports,
+		runtimeFileName,
+		resolveImportTarget: (specifier) => {
+			return ensureLocalizedDuplicate({
+				runtimeContext: args.runtimeContext,
+				pendingLocalizedDuplicates: args.pendingLocalizedDuplicates,
+				root: args.root,
+				sourceFileName: specifier
+			});
+		}
+	}));
+	for (const specifier of [...args.chunk.imports, ...args.chunk.dynamicImports]) {
+		const localizedSpecifier = ensureLocalizedDuplicate({
+			runtimeContext: args.runtimeContext,
+			pendingLocalizedDuplicates: args.pendingLocalizedDuplicates,
+			root: args.root,
+			sourceFileName: specifier
+		});
+		if (!localizedSpecifier || localizedSpecifier === specifier) continue;
+		applyMagicStringChunkRewrite(rewrittenChunk, createChunkImportSpecifiersRewrite(rewrittenChunk.code, {
+			sourceFileName: args.targetFileName,
+			targetFileName: args.targetFileName,
+			imports: [specifier],
+			dynamicImports: [],
+			runtimeFileName,
+			resolveImportTarget: () => localizedSpecifier
+		}));
+	}
+	return rewrittenChunk;
+}
+function emitDuplicatedChunkAsset(args) {
+	if (args.emittedLocalizedDuplicateFiles.has(args.targetFileName)) return;
+	const duplicatedChunk = rewriteDuplicatedChunkSource({
+		runtimeContext: args.runtimeContext,
+		pendingLocalizedDuplicates: args.pendingLocalizedDuplicates,
+		root: args.root,
+		sourceFileName: args.sourceFileName,
+		targetFileName: args.targetFileName,
+		chunk: args.chunk
+	});
+	args.runtimeContext.pluginContext.emitFile({
+		type: "asset",
+		fileName: args.targetFileName,
+		source: duplicatedChunk.code
+	});
+	args.runtimeContext.onEmitChunk?.(args.targetFileName, duplicatedChunk);
+	const sourceMapKeys = collectSourceMapKeys(args.sourceFileName, args.chunk);
+	const sourceMapAssetInfo = findSourceMapAsset(args.runtimeContext.bundle, sourceMapKeys);
+	const unchangedSourceMap = duplicatedChunk.code === args.chunk.code ? resolveSourceMapSource(args.chunk.map, sourceMapAssetInfo?.asset.source) : void 0;
+	if (duplicatedChunk.map) {
+		const sourceMapFileName = reserveUniqueFileName(args.runtimeContext.reservedFileNames, `${args.targetFileName}.map`);
+		args.runtimeContext.pluginContext.emitFile({
+			type: "asset",
+			fileName: sourceMapFileName,
+			source: JSON.stringify(duplicatedChunk.map)
+		});
+	} else if (unchangedSourceMap) {
+		const sourceMapFileName = reserveUniqueFileName(args.runtimeContext.reservedFileNames, `${args.targetFileName}.map`);
+		args.runtimeContext.pluginContext.emitFile({
+			type: "asset",
+			fileName: sourceMapFileName,
+			source: cloneSourceLike(unchangedSourceMap)
+		});
+	}
+	args.emittedLocalizedDuplicateFiles.add(args.targetFileName);
+}
+function buildDuplicateDiagnostics(args) {
+	const chunkBytes = typeof args.chunk.code === "string" ? Buffer.byteLength(args.chunk.code, "utf8") : void 0;
+	return {
+		chunkBytes,
+		redundantBytes: typeof chunkBytes === "number" ? chunkBytes * Math.max(args.redundantDuplicateCount, 0) : void 0,
+		requiresRuntimeLocalization: chunkReferencesRuntime(args.chunk, ROLLDOWN_RUNTIME_FILE_NAME, new Set(args.sourceRoot ? [posix.join(args.sourceRoot, ROLLDOWN_RUNTIME_FILE_NAME), ROLLDOWN_RUNTIME_FILE_NAME] : [ROLLDOWN_RUNTIME_FILE_NAME]))
+	};
+}
+//#endregion
+//#region src/runtime/chunkStrategy/apply/shared/leaks.ts
+function localizeCrossSubPackageChunkLeaks(bundle, options) {
+	const { subPackageRoots, reservedFileNames, localizedDuplicateFileMap, onDuplicate } = options;
+	if (subPackageRoots.length === 0) return;
+	const entries = Object.entries(bundle);
+	const importerIndex = options.importerIndex ?? createChunkImporterIndex(bundle, entries);
+	for (const [fileName, output] of entries) {
+		if (output?.type !== "chunk") continue;
+		if (fileName.startsWith(`weapp_shared_virtual/`)) continue;
+		if (posix.basename(fileName) === "rolldown-runtime.js") continue;
+		const sourceRoot = resolveSubPackagePrefix(fileName, subPackageRoots);
+		if (!sourceRoot) continue;
+		const importers = findChunkImporters(bundle, fileName, importerIndex);
+		if (importers.length === 0) continue;
+		const crossRootImporters = /* @__PURE__ */ new Map();
+		for (const importerFile of importers) {
+			const importerRoot = resolveSubPackagePrefix(importerFile, subPackageRoots);
+			if (!importerRoot || importerRoot === sourceRoot) continue;
+			const list = crossRootImporters.get(importerRoot);
+			if (list) list.push(importerFile);
+			else crossRootImporters.set(importerRoot, [importerFile]);
+		}
+		if (crossRootImporters.size === 0) continue;
+		const chunk = output;
+		const sourceMapAssetInfo = findSourceMapAsset(bundle, collectSourceMapKeys(fileName, chunk));
+		const resolvedSourceMap = resolveEncodedSourceMap(chunk.map, sourceMapAssetInfo?.asset.source);
+		const importerToChunk = /* @__PURE__ */ new Map();
+		const duplicates = [];
+		for (const [targetRoot, importerFiles] of crossRootImporters.entries()) {
+			const duplicateKey = `${targetRoot}::${fileName}`;
+			const existingDuplicateFileName = localizedDuplicateFileMap.get(duplicateKey);
+			const uniqueFileName = existingDuplicateFileName ?? (() => {
+				const duplicateBaseName = createCrossSubPackageDuplicateBaseName(sourceRoot, fileName);
+				const intendedFileName = posix.join(targetRoot, "weapp-shared", duplicateBaseName);
+				const createdFileName = reserveUniqueFileName(reservedFileNames, intendedFileName);
+				localizedDuplicateFileMap.set(duplicateKey, createdFileName);
+				return createdFileName;
+			})();
+			const runtimeFileName = posix.join(targetRoot, ROLLDOWN_RUNTIME_FILE_NAME);
+			if (!existingDuplicateFileName) {
+				const duplicatedChunk = {
+					...chunk,
+					map: resolvedSourceMap
+				};
+				applyMagicStringChunkRewrite(duplicatedChunk, createChunkImportSpecifiersRewrite(duplicatedChunk.code ?? "", {
+					sourceFileName: fileName,
+					targetFileName: uniqueFileName,
+					imports: chunk.imports,
+					dynamicImports: chunk.dynamicImports,
+					runtimeFileName
+				}));
+				this.emitFile({
+					type: "asset",
+					fileName: uniqueFileName,
+					source: duplicatedChunk.code
+				});
+				options.onEmitChunk?.(uniqueFileName, duplicatedChunk);
+				if (duplicatedChunk.map) {
+					const sourceMapFileName = reserveUniqueFileName(reservedFileNames, `${uniqueFileName}.map`);
+					this.emitFile({
+						type: "asset",
+						fileName: sourceMapFileName,
+						source: JSON.stringify(duplicatedChunk.map)
+					});
+				} else if (duplicatedChunk.code === chunk.code) {
+					const unchangedSourceMap = resolveSourceMapSource(chunk.map, sourceMapAssetInfo?.asset.source);
+					if (unchangedSourceMap) {
+						const sourceMapFileName = reserveUniqueFileName(reservedFileNames, `${uniqueFileName}.map`);
+						this.emitFile({
+							type: "asset",
+							fileName: sourceMapFileName,
+							source: cloneSourceLike(unchangedSourceMap)
+						});
+					}
+				}
+			}
+			for (const importerFile of importerFiles) importerToChunk.set(importerFile, uniqueFileName);
+			duplicates.push({
+				fileName: uniqueFileName,
+				importers: [...importerFiles]
+			});
+		}
+		updateImporters(bundle, importerToChunk, fileName, importerIndex);
+		const diagnostics = buildDuplicateDiagnostics({
+			chunk,
+			duplicates,
+			redundantDuplicateCount: duplicates.length,
+			sourceRoot
+		});
+		onDuplicate?.({
+			sharedFileName: fileName,
+			duplicates,
+			requiresRuntimeLocalization: diagnostics.requiresRuntimeLocalization,
+			chunkBytes: diagnostics.chunkBytes,
+			redundantBytes: diagnostics.redundantBytes,
+			retainedInMain: true
+		});
+	}
+}
+//#endregion
+//#region src/runtime/chunkStrategy/apply/shared.ts
+function applySharedChunkStrategy(bundle, options) {
+	if (options.strategy !== "duplicate" && !hasForceDuplicateSharedChunks()) return;
+	if (!this) throw new Error("applySharedChunkStrategy 需要 PluginContext。");
+	const subPackageRoots = Array.from(options.subPackageRoots).filter(Boolean);
+	const entries = Object.entries(bundle);
+	if (!shouldAnalyzeSharedChunkBundle(entries, subPackageRoots)) return;
+	const reservedFileNames = new Set(entries.map(([fileName]) => fileName));
+	const localizedDuplicateFileMap = /* @__PURE__ */ new Map();
+	const runtimeContext = {
+		onEmitChunk: options.onEmitChunk,
+		pluginContext: this,
+		bundle,
+		subPackageRoots,
+		reservedFileNames,
+		localizedDuplicateFileMap
+	};
+	const pendingLocalizedDuplicates = [];
+	const emittedLocalizedDuplicateFiles = /* @__PURE__ */ new Set();
+	const importerIndex = createChunkImporterIndex(bundle, entries);
+	for (const [fileName, output] of entries) {
+		if (!isSharedVirtualChunk(fileName, output)) continue;
+		const originalSharedFileName = fileName;
+		const chunk = output;
+		const importers = findChunkImporters(bundle, fileName, importerIndex);
+		if (importers.length === 0) continue;
+		const sourceMapKeys = collectSourceMapKeys(fileName, chunk);
+		const sourceMapAssetInfo = findSourceMapAsset(bundle, sourceMapKeys);
+		const resolvedSourceMap = resolveEncodedSourceMap(chunk.map, sourceMapAssetInfo?.asset.source);
+		if (resolvedSourceMap) chunk.map = resolvedSourceMap;
+		const importerMap = /* @__PURE__ */ new Map();
+		const mainImporters = [];
+		let hasMainImporter = false;
+		const shouldForceDuplicate = isForceDuplicateSharedChunk(originalSharedFileName);
+		for (const importerFile of importers) {
+			const root = resolveSubPackagePrefix(importerFile, subPackageRoots);
+			if (!root) {
+				hasMainImporter = true;
+				mainImporters.push(importerFile);
+				continue;
+			}
+			const duplicateBaseName = posix.basename(fileName);
+			const uniqueFileName = reserveUniqueFileName(reservedFileNames, posix.join(root, SUB_PACKAGE_SHARED_DIR, duplicateBaseName));
+			const existing = importerMap.get(root);
+			if (existing) existing.importers.push(importerFile);
+			else importerMap.set(root, {
+				newFileName: uniqueFileName,
+				importers: [importerFile]
+			});
+		}
+		const importerToChunk = /* @__PURE__ */ new Map();
+		const duplicates = [];
+		const diagnostics = consumeSharedChunkDiagnostics(originalSharedFileName);
+		const shouldRetainOriginalChunk = shouldForceDuplicate && hasMainImporter;
+		if ((hasMainImporter || importerMap.size === 0) && (!shouldForceDuplicate || importerMap.size === 0)) {
+			let finalFileName = chunk.fileName;
+			if (fileName.startsWith(`weapp_shared_virtual/`)) {
+				const newFileName = fileName.slice(21);
+				const codeRewritten = applyMagicStringChunkRewrite(chunk, createChunkImportSpecifiersRewrite(chunk.code ?? "", {
+					sourceFileNames: createChunkSourceFileNameCandidates(fileName),
+					targetFileName: newFileName,
+					imports: chunk.imports,
+					dynamicImports: chunk.dynamicImports,
+					runtimeFileName: ROLLDOWN_RUNTIME_FILE_NAME
+				}));
+				chunk.fileName = newFileName;
+				if (typeof chunk.sourcemapFileName === "string" && chunk.sourcemapFileName) chunk.sourcemapFileName = `${newFileName}.map`;
+				const targetKey = `${newFileName}.map`;
+				emitSourceMapAsset(this, targetKey, codeRewritten ? void 0 : sourceMapAssetInfo, resolveSourceMapSource(chunk.map, void 0));
+				for (const mapKey of sourceMapKeys) {
+					if (!mapKey || mapKey === targetKey) continue;
+					if (bundle[mapKey]) delete bundle[mapKey];
+				}
+				finalFileName = newFileName;
+			}
+			if (finalFileName !== originalSharedFileName) {
+				const fallbackImporterMap = /* @__PURE__ */ new Map();
+				for (const importerFile of importers) fallbackImporterMap.set(importerFile, finalFileName);
+				updateImporters(bundle, fallbackImporterMap, originalSharedFileName, importerIndex);
+			}
+			options.onFallback?.({
+				sharedFileName: originalSharedFileName,
+				finalFileName,
+				reason: hasMainImporter ? "main-package" : "no-subpackage",
+				importers: [...importers]
+			});
+			continue;
+		}
+		if (shouldRetainOriginalChunk && fileName.startsWith(`weapp_shared_virtual/`)) {
+			const newFileName = fileName.slice(21);
+			const codeRewritten = applyMagicStringChunkRewrite(chunk, createChunkImportSpecifiersRewrite(chunk.code ?? "", {
+				sourceFileNames: createChunkSourceFileNameCandidates(fileName),
+				targetFileName: newFileName,
+				imports: chunk.imports,
+				dynamicImports: chunk.dynamicImports,
+				runtimeFileName: ROLLDOWN_RUNTIME_FILE_NAME
+			}));
+			chunk.fileName = newFileName;
+			if (typeof chunk.sourcemapFileName === "string" && chunk.sourcemapFileName) chunk.sourcemapFileName = `${newFileName}.map`;
+			const targetKey = `${newFileName}.map`;
+			emitSourceMapAsset(this, targetKey, codeRewritten ? void 0 : sourceMapAssetInfo, resolveSourceMapSource(chunk.map, void 0));
+			for (const mapKey of sourceMapKeys) {
+				if (!mapKey || mapKey === targetKey) continue;
+				if (bundle[mapKey]) delete bundle[mapKey];
+			}
+			if (mainImporters.length) {
+				const mainImporterMap = /* @__PURE__ */ new Map();
+				for (const importerFile of mainImporters) mainImporterMap.set(importerFile, newFileName);
+				updateImporters(bundle, mainImporterMap, originalSharedFileName, importerIndex);
+			}
+			options.onFallback?.({
+				sharedFileName: originalSharedFileName,
+				finalFileName: newFileName,
+				reason: "main-package",
+				importers: [...importers]
+			});
+		}
+		for (const [root, { newFileName, importers: importerFiles }] of importerMap.entries()) {
+			emitDuplicatedChunkAsset({
+				runtimeContext,
+				pendingLocalizedDuplicates,
+				emittedLocalizedDuplicateFiles,
+				root,
+				sourceFileName: fileName,
+				targetFileName: newFileName,
+				chunk
+			});
+			for (const importerFile of importerFiles) importerToChunk.set(importerFile, newFileName);
+			duplicates.push({
+				fileName: newFileName,
+				importers: [...importerFiles]
+			});
+		}
+		updateImporters(bundle, importerToChunk, fileName, importerIndex);
+		if (!shouldRetainOriginalChunk) {
+			delete bundle[fileName];
+			removeChunkFromImporterIndex(importerIndex, fileName);
+			for (const mapKey of sourceMapKeys) if (mapKey && bundle[mapKey]) delete bundle[mapKey];
+		}
+		const duplicateDiagnostics = buildDuplicateDiagnostics({
+			chunk,
+			duplicates,
+			redundantDuplicateCount: Math.max(duplicates.length - 1, 0)
+		});
+		options.onDuplicate?.({
+			sharedFileName: originalSharedFileName,
+			duplicates,
+			ignoredMainImporters: diagnostics?.ignoredMainImporters,
+			requiresRuntimeLocalization: duplicateDiagnostics.requiresRuntimeLocalization,
+			chunkBytes: duplicateDiagnostics.chunkBytes,
+			redundantBytes: duplicateDiagnostics.redundantBytes,
+			retainedInMain: shouldRetainOriginalChunk
+		});
+	}
+	localizeCrossSubPackageChunkLeaks.call(this, bundle, {
+		onEmitChunk: options.onEmitChunk,
+		subPackageRoots,
+		reservedFileNames,
+		localizedDuplicateFileMap,
+		importerIndex,
+		onDuplicate: options.onDuplicate
+	});
+	for (const task of pendingLocalizedDuplicates) emitDuplicatedChunkAsset({
+		runtimeContext,
+		pendingLocalizedDuplicates,
+		emittedLocalizedDuplicateFiles,
+		...task
+	});
+}
+function isSharedVirtualChunk(fileName, output) {
+	return output?.type === "chunk" && fileName.startsWith(`weapp_shared_virtual/`);
+}
+function shouldAnalyzeSharedChunkBundle(entries, subPackageRoots) {
+	for (const [fileName, output] of entries) {
+		if (isSharedVirtualChunk(fileName, output)) return true;
+		if (subPackageRoots.length && output?.type === "chunk" && resolveSubPackagePrefix(fileName, subPackageRoots)) return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/runtime/chunkStrategy/naming.ts
+function resolveTakeSharedChunkName(options) {
+	const { ctx, relativeAbsoluteSrcRoot, subPackageRoots, importers } = options;
+	if (!importers.length) return;
+	const { summary } = summarizeImportPrefixes({
+		ctx,
+		importers,
+		relativeAbsoluteSrcRoot,
+		subPackageRoots
+	});
+	const keys = Object.keys(summary).filter(Boolean);
+	if (!keys.length) return;
+	const sharedName = createSharedChunkNameFromKeys(keys);
+	markForceDuplicateSharedChunk(sharedName);
+	return sharedName;
+}
+function createSharedChunkNameFromKeys(keys) {
+	const sanitize = (value) => value.replace(/[\\/]+/g, "_");
+	const combination = keys.filter(Boolean).map(sanitize).sort().join("+");
+	const combinationSegment = combination ? `${combination}/` : "";
+	return `${SHARED_CHUNK_VIRTUAL_PREFIX}/${combinationSegment}common`;
+}
+function resolveSharedChunkName(options) {
+	const { id, ctx, relativeAbsoluteSrcRoot, subPackageRoots, strategy, sharedMode, resolveSharedMode, resolveSharedPath, forceDuplicateTester } = options;
+	const cached = getCachedSharedChunkName(id);
+	if (cached !== void 0) return cached ?? void 0;
+	const subPackageRootList = Array.from(subPackageRoots);
+	const moduleInfo = ctx.getModuleInfo(id);
+	const relativeId = relativeAbsoluteSrcRoot(id);
+	const resolvedMode = resolveSharedMode?.(relativeId, id) ?? sharedMode ?? "common";
+	if (resolvedMode === "inline") {
+		setCachedSharedChunkName(id, void 0);
+		return;
+	}
+	if (resolvedMode === "path") {
+		if (!moduleInfo?.importers || moduleInfo.importers.length <= 1) {
+			setCachedSharedChunkName(id, void 0);
+			return;
+		}
+		const moduleRoot = resolveSubPackagePrefix(relativeId, subPackageRootList);
+		if (moduleRoot) assertModuleScopedToRoot({
+			moduleInfo,
+			moduleRoot,
+			relativeAbsoluteSrcRoot,
+			subPackageRoots: subPackageRootList,
+			moduleId: id
+		});
+		const candidate = resolveSharedPath?.(id, relativeId) ?? relativeId;
+		const normalized = normalizeRelativePath(candidate);
+		if (!normalized || normalized.startsWith("..")) {
+			setCachedSharedChunkName(id, void 0);
+			return;
+		}
+		const sharedName = removeExtensionDeep(normalized);
+		if (!sharedName || sharedName === ".") {
+			setCachedSharedChunkName(id, void 0);
+			return;
+		}
+		setCachedSharedChunkName(id, sharedName);
+		return sharedName;
+	}
+	const takeImporters = getTakeImporters(id);
+	if (takeImporters?.size) {
+		const takeSharedName = resolveTakeSharedChunkName({
+			id,
+			ctx,
+			relativeAbsoluteSrcRoot,
+			subPackageRoots: subPackageRootList,
+			importers: Array.from(takeImporters)
+		});
+		if (takeSharedName) {
+			setCachedSharedChunkName(id, takeSharedName);
+			return takeSharedName;
+		}
+	}
+	if (strategy === "hoist") {
+		const moduleRoot = resolveSubPackagePrefix(relativeId, subPackageRootList);
+		if (moduleRoot) {
+			assertModuleScopedToRoot({
+				moduleInfo,
+				moduleRoot,
+				relativeAbsoluteSrcRoot,
+				subPackageRoots: subPackageRootList,
+				moduleId: id
+			});
+			if (!moduleInfo?.importers || moduleInfo.importers.length <= 1) {
+				setCachedSharedChunkName(id, void 0);
+				return;
+			}
+			const sharedName = posix.join(moduleRoot, "common");
+			setCachedSharedChunkName(id, sharedName);
+			return sharedName;
+		}
+		if (!moduleInfo?.importers || moduleInfo.importers.length <= 1) {
+			setCachedSharedChunkName(id, void 0);
+			return;
+		}
+		setCachedSharedChunkName(id, "common");
+		return "common";
+	}
+	if (!moduleInfo?.importers || moduleInfo.importers.length <= 1) {
+		setCachedSharedChunkName(id, void 0);
+		return;
+	}
+	const { summary, ignoredMainImporters } = summarizeImportPrefixes({
+		ctx,
+		importers: moduleInfo.importers,
+		relativeAbsoluteSrcRoot,
+		subPackageRoots: subPackageRootList,
+		forceDuplicateTester
+	});
+	const keys = Object.keys(summary);
+	if (keys.length === 0) {
+		setCachedSharedChunkName(id, void 0);
+		return;
+	}
+	if (keys.length === 1) {
+		const prefix = keys[0];
+		const sharedName = prefix ? posix.join(prefix, "common") : "common";
+		setCachedSharedChunkName(id, sharedName);
+		return sharedName;
+	}
+	const hasMainImporter = keys.includes("");
+	if (strategy === "duplicate" && !hasMainImporter) {
+		const sharedName = createSharedChunkNameFromKeys(keys);
+		if (ignoredMainImporters.length) recordSharedChunkDiagnostics(sharedName, ignoredMainImporters);
+		setCachedSharedChunkName(id, sharedName);
+		return sharedName;
+	}
+	setCachedSharedChunkName(id, "common");
+	return "common";
+}
+//#endregion
+export { syncOutputChunkSourceMapAssets as _, SUB_PACKAGE_SHARED_DIR as a, normalizeEncodedSourceMapLike as b, resolveSubPackagePrefix as c, applyOutputChunkTransform as d, editOutputChunkCode as f, resolveOutputChunkTransformCode as g, replaceOutputChunkCodeRanges as h, SHARED_CHUNK_VIRTUAL_PREFIX as i, appendOutputChunkCode as l, replaceOutputChunkCode as m, applySharedChunkStrategy as n, applyRuntimeChunkLocalization as o, prependOutputChunkCode as p, DEFAULT_SHARED_CHUNK_STRATEGY as r, assertModuleScopedToRoot as s, resolveSharedChunkName as t, applyMagicStringChunkRewrite as u, composeSourceMaps as v, resetTakeImportRegistry as x, labelSourceMapInput as y };