@neuxnet/neux-cli 0.2.3

package/vendor/dimina-compiler/sourcemap-BgtIgqkC.cjs

@@ -0,0 +1,1377 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_process = require("node:process");
+node_process = __toESM(node_process, 1);
+let node_os = require("node:os");
+node_os = __toESM(node_os, 1);
+let oxc_parser = require("oxc-parser");
+let oxc_walker = require("oxc-walker");
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto, 1);
+let source_map_js = require("source-map-js");
+//#region src/common/dependency-graph.js
+function normalizeFilePath(filePath) {
+	return node_path.default.resolve(filePath);
+}
+function normalizeKinds(kinds) {
+	if (!kinds) return null;
+	return new Set(Array.isArray(kinds) ? kinds : [kinds]);
+}
+var DependencyGraph = class DependencyGraph {
+	constructor(snapshot) {
+		this.nodes = /* @__PURE__ */ new Map();
+		this.dependencies = /* @__PURE__ */ new Map();
+		this.dependents = /* @__PURE__ */ new Map();
+		this.fileOwners = /* @__PURE__ */ new Map();
+		this.fileKinds = /* @__PURE__ */ new Map();
+		if (snapshot) this.merge(snapshot);
+	}
+	addNode(id, metadata = {}) {
+		if (!id) return null;
+		const current = this.nodes.get(id) || {
+			id,
+			type: "module",
+			entry: false,
+			packageRoot: null,
+			files: /* @__PURE__ */ new Set()
+		};
+		if (metadata.type) current.type = metadata.type;
+		if (metadata.entry === true) current.entry = true;
+		if (metadata.packageRoot !== void 0) current.packageRoot = metadata.packageRoot;
+		this.nodes.set(id, current);
+		for (const filePath of metadata.files || []) this.addFile(id, filePath);
+		return current;
+	}
+	addFile(id, filePath, kind = "module") {
+		if (!id || !filePath) return;
+		const node = this.addNode(id);
+		const normalizedPath = normalizeFilePath(filePath);
+		node.files.add(normalizedPath);
+		const owners = this.fileOwners.get(normalizedPath) || /* @__PURE__ */ new Set();
+		owners.add(id);
+		this.fileOwners.set(normalizedPath, owners);
+		const ownerKinds = this.fileKinds.get(normalizedPath) || /* @__PURE__ */ new Map();
+		const kinds = ownerKinds.get(id) || /* @__PURE__ */ new Set();
+		kinds.add(kind);
+		ownerKinds.set(id, kinds);
+		this.fileKinds.set(normalizedPath, ownerKinds);
+	}
+	addDependency(from, to, kind = "module") {
+		if (!from || !to) return;
+		this.addNode(from);
+		this.addNode(to);
+		const outgoing = this.dependencies.get(from) || /* @__PURE__ */ new Map();
+		const kinds = outgoing.get(to) || /* @__PURE__ */ new Set();
+		kinds.add(kind);
+		outgoing.set(to, kinds);
+		this.dependencies.set(from, outgoing);
+		const incoming = this.dependents.get(to) || /* @__PURE__ */ new Map();
+		const reverseKinds = incoming.get(from) || /* @__PURE__ */ new Set();
+		reverseKinds.add(kind);
+		incoming.set(from, reverseKinds);
+		this.dependents.set(to, incoming);
+	}
+	getDirectDependencies(id, kinds) {
+		return this.#filterEdges(this.dependencies.get(id), kinds);
+	}
+	getDirectDependents(id, kinds) {
+		return this.#filterEdges(this.dependents.get(id), kinds);
+	}
+	getAffectedEntries(filePath) {
+		const pending = [...this.fileOwners.get(normalizeFilePath(filePath)) || /* @__PURE__ */ new Set()];
+		const visited = /* @__PURE__ */ new Set();
+		const entries = /* @__PURE__ */ new Set();
+		while (pending.length > 0) {
+			const id = pending.pop();
+			if (visited.has(id)) continue;
+			visited.add(id);
+			if (this.nodes.get(id)?.entry) entries.add(id);
+			for (const dependent of this.getDirectDependents(id)) pending.push(dependent);
+		}
+		return [...entries].sort();
+	}
+	hasFile(filePath) {
+		return this.fileOwners.has(normalizeFilePath(filePath));
+	}
+	getFileKinds(filePath) {
+		const ownerKinds = this.fileKinds.get(normalizeFilePath(filePath));
+		if (!ownerKinds) return [];
+		return [...new Set([...ownerKinds.values()].flatMap((kinds) => [...kinds]))].sort();
+	}
+	merge(snapshotOrGraph) {
+		const snapshot = snapshotOrGraph instanceof DependencyGraph ? snapshotOrGraph.toJSON() : snapshotOrGraph;
+		const fileEdges = snapshot?.fileEdges || [];
+		for (const node of snapshot?.nodes || []) {
+			this.addNode(node.id, {
+				...node,
+				files: []
+			});
+			if (fileEdges.length === 0) for (const filePath of node.files || []) this.addFile(node.id, filePath);
+		}
+		for (const fileEdge of fileEdges) for (const kind of fileEdge.kinds || ["module"]) this.addFile(fileEdge.owner, fileEdge.file, kind);
+		for (const edge of snapshot?.edges || []) for (const kind of edge.kinds || ["module"]) this.addDependency(edge.from, edge.to, kind);
+		return this;
+	}
+	toJSON() {
+		return {
+			nodes: [...this.nodes.values()].map((node) => ({
+				id: node.id,
+				type: node.type,
+				entry: node.entry,
+				packageRoot: node.packageRoot,
+				files: [...node.files].sort()
+			})).sort((a, b) => a.id.localeCompare(b.id)),
+			edges: [...this.dependencies.entries()].flatMap(([from, targets]) => [...targets.entries()].map(([to, kinds]) => ({
+				from,
+				to,
+				kinds: [...kinds].sort()
+			}))).sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to)),
+			fileEdges: [...this.fileKinds.entries()].flatMap(([file, owners]) => [...owners.entries()].map(([owner, kinds]) => ({
+				file,
+				owner,
+				kinds: [...kinds].sort()
+			}))).sort((a, b) => a.file.localeCompare(b.file) || a.owner.localeCompare(b.owner))
+		};
+	}
+	#filterEdges(edges, kinds) {
+		if (!edges) return [];
+		const acceptedKinds = normalizeKinds(kinds);
+		return [...edges.entries()].filter(([, edgeKinds]) => !acceptedKinds || [...edgeKinds].some((kind) => acceptedKinds.has(kind))).map(([id]) => id);
+	}
+};
+//#endregion
+//#region src/common/path-utils.js
+var WINDOWS_FS_PATH_RE = /^(?:[a-zA-Z]:[\\/]|\\\\)/;
+function isWindowsFsPath(targetPath) {
+	return typeof targetPath === "string" && (WINDOWS_FS_PATH_RE.test(targetPath) || targetPath.includes("\\"));
+}
+function getFsPathApi(targetPath) {
+	return isWindowsFsPath(targetPath) ? node_path.default.win32 : node_path.default.posix;
+}
+function normalizeToPosixPath(targetPath) {
+	return targetPath.replace(/\\/g, "/");
+}
+function resolveMiniProgramPath(workPath, importerPath, sourcePath) {
+	const pathApi = getFsPathApi(importerPath || workPath);
+	return sourcePath.startsWith("/") ? pathApi.join(workPath, sourcePath) : pathApi.resolve(pathApi.dirname(importerPath), sourcePath);
+}
+function toMiniProgramModuleId(resolvedPath, workPath) {
+	const normalizedResolvedPath = normalizeToPosixPath(resolvedPath);
+	const normalizedWorkPath = normalizeToPosixPath(workPath);
+	let moduleId = normalizedResolvedPath.startsWith(normalizedWorkPath) ? normalizedResolvedPath.slice(normalizedWorkPath.length) : normalizedResolvedPath;
+	moduleId = moduleId.replace(/\/+/g, "/");
+	if (!moduleId.startsWith("/")) moduleId = `/${moduleId}`;
+	return moduleId;
+}
+function getRelativePosixPath(targetPath, rootPath) {
+	return normalizeToPosixPath(targetPath).replace(normalizeToPosixPath(rootPath), "").replace(/^\//, "");
+}
+//#endregion
+//#region src/common/utils.js
+function hasCompileInfo(modulePath, list, preList) {
+	const mergeList = Array.isArray(preList) ? [...preList, ...list] : list;
+	for (const element of mergeList) if (element.path === modulePath) return true;
+	return false;
+}
+function getAbsolutePath(workPath, pagePath, src) {
+	if (src.startsWith("/")) return node_path.default.join(workPath, src);
+	if (pagePath.includes("/miniprogram_npm/")) {
+		const componentFullPath = workPath + pagePath.split("/").slice(0, -1).join("/");
+		return node_path.default.resolve(componentFullPath, src);
+	}
+	const relativePath = pagePath.split("/").filter((part) => part !== "").slice(0, -1).join("/");
+	return node_path.default.resolve(workPath, relativePath, src);
+}
+var assetsMap = {};
+function resetAssetCache() {
+	for (const assetPath of Object.keys(assetsMap)) delete assetsMap[assetPath];
+}
+function isPathInside(rootPath, targetPath) {
+	const relativePath = node_path.default.relative(rootPath, targetPath);
+	return relativePath === "" || !relativePath.startsWith(`..${node_path.default.sep}`) && relativePath !== ".." && !node_path.default.isAbsolute(relativePath);
+}
+function resolveAssetSourcePath(workPath, pagePath, src) {
+	const projectRoot = node_path.default.resolve(workPath);
+	if (src.startsWith("/")) return node_path.default.resolve(projectRoot, `.${src}`);
+	const normalizedPagePath = node_path.default.resolve(pagePath);
+	const pageDirectory = node_path.default.isAbsolute(pagePath) && isPathInside(projectRoot, normalizedPagePath) ? node_path.default.dirname(normalizedPagePath) : node_path.default.resolve(projectRoot, node_path.default.dirname(pagePath.replace(/^[/\\]+/, "")));
+	const resolvedPath = node_path.default.resolve(pageDirectory, src);
+	if (isPathInside(projectRoot, resolvedPath)) return resolvedPath;
+	return node_path.default.resolve(projectRoot, src.replace(/^(?:\.\.[/\\])+/, ""));
+}
+/**
+* 将静态资源存储到 static 文件夹
+*/
+function collectAssets(workPath, pagePath, src, targetPath, appId) {
+	if (src.startsWith("http") || src.startsWith("//")) return src;
+	if (!/\.(?:png|jpe?g|gif|svg|mp3|m4a|aac|wav)(?:\?.*)?$/.test(src)) return src;
+	const absolutePath = resolveAssetSourcePath(workPath, pagePath, src);
+	if (assetsMap[absolutePath]) return assetsMap[absolutePath];
+	try {
+		const ext = `.${src.split(".").pop()}`;
+		const dirPath = absolutePath.split(node_path.default.sep).slice(0, -1).join("/");
+		const prefix = uuid(node_path.default.relative(node_path.default.resolve(workPath), dirPath).split(node_path.default.sep).join("/") || ".");
+		const targetStatic = `${targetPath}/main/static`;
+		if (!node_fs.default.existsSync(targetStatic)) node_fs.default.mkdirSync(targetStatic, { recursive: true });
+		getFilesWithExtension(dirPath, ext).forEach((file) => {
+			node_fs.default.copyFileSync(node_path.default.resolve(dirPath, file), `${targetStatic}/${prefix}_${file}`);
+		});
+		const filename = src.split("/").pop();
+		assetsMap[absolutePath] = `${node_process.default.env.ASSETS_PATH_PREFIX ? "" : "/"}${appId}/main/static/${prefix}_${filename}`;
+	} catch (error) {
+		console.log(error);
+	}
+	return assetsMap[absolutePath] || src;
+}
+function getFilesWithExtension(directory, extension) {
+	return node_fs.default.readdirSync(directory).filter((file) => node_path.default.extname(file) === extension);
+}
+function isObjectEmpty(objectName) {
+	if (!objectName) return true;
+	return Object.keys(objectName).length === 0 && objectName.constructor === Object;
+}
+function isString(o) {
+	return Object.prototype.toString.call(o) === "[object String]";
+}
+function transformRpx(styleText) {
+	if (!isString(styleText)) return styleText;
+	return styleText.replace(/([+-]?\d+(?:\.\d+)?)rpx/g, (_, pixel) => {
+		const viewportWidth = Number((Number(pixel) / 7.5).toFixed(6));
+		return `${Object.is(viewportWidth, -0) ? 0 : viewportWidth}vw`;
+	});
+}
+function uuid(str) {
+	return node_crypto.default.createHash("sha256").update(str).digest().readBigUInt64BE(0).toString(36);
+}
+var tagWhiteList = [
+	"page",
+	"wrapper",
+	"audio",
+	"component-host",
+	"block",
+	"button",
+	"camera",
+	"checkbox-group",
+	"checkbox",
+	"cover-image",
+	"cover-view",
+	"form",
+	"icon",
+	"image",
+	"input",
+	"keyboard-accessory",
+	"label",
+	"map",
+	"movable-area",
+	"movable-view",
+	"navigation-bar",
+	"navigator",
+	"open-data",
+	"page-meta",
+	"page-container",
+	"picker-view-column",
+	"picker-view",
+	"picker",
+	"progress",
+	"radio-group",
+	"radio",
+	"rich-text",
+	"root-portal",
+	"scroll-view",
+	"slider",
+	"swiper-item",
+	"swiper",
+	"switch",
+	"template",
+	"text",
+	"textarea",
+	"video",
+	"view",
+	"web-view"
+];
+var miniProgramBuiltinTags = /* @__PURE__ */ new Set([
+	...tagWhiteList,
+	"canvas",
+	"match-media",
+	"page-container",
+	"share-element",
+	"editor",
+	"audio",
+	"channel-live",
+	"channel-video",
+	"live-player",
+	"live-pusher",
+	"voip-room",
+	"ad",
+	"ad-custom",
+	"official-account",
+	"xr-frame"
+]);
+//#endregion
+//#region src/common/npm-resolver.js
+/**
+* npm 组件解析器
+* 根据微信小程序 npm 支持规范实现组件寻址
+* https://developers.weixin.qq.com/miniprogram/dev/devtools/npm.html
+*/
+var NpmResolver = class {
+	constructor(workPath) {
+		this.workPath = workPath;
+		this.miniprogramNpmCache = /* @__PURE__ */ new Map();
+		this.packageCache = /* @__PURE__ */ new Map();
+	}
+	/**
+	* 解析组件路径，支持 npm 包组件
+	* @param {string} componentPath 组件路径
+	* @param {string} pageFilePath 页面文件路径
+	* @returns {string} 解析后的组件路径
+	*/
+	resolveComponentPath(componentPath, pageFilePath) {
+		if (componentPath.startsWith("./") || componentPath.startsWith("../") || componentPath.startsWith("/")) return this.resolveRelativePath(componentPath, pageFilePath);
+		const npmPath = this.resolveNpmComponent(componentPath, pageFilePath);
+		if (npmPath) return npmPath;
+		return this.resolveRelativePath(componentPath, pageFilePath);
+	}
+	/**
+	* 解析相对路径组件
+	* @param {string} componentPath 组件路径
+	* @param {string} pageFilePath 页面文件路径
+	* @returns {string} 解析后的路径
+	*/
+	resolveRelativePath(componentPath, pageFilePath) {
+		return toMiniProgramModuleId(resolveMiniProgramPath(this.workPath, pageFilePath, componentPath), this.workPath);
+	}
+	/**
+	* 解析 npm 组件
+	* @param {string} componentName 组件名称
+	* @param {string} pageFilePath 页面文件路径
+	* @returns {string|null} 解析后的组件路径，如果找不到返回 null
+	*/
+	resolveNpmComponent(componentName, pageFilePath) {
+		const searchPaths = this.generateSearchPaths(pageFilePath);
+		for (const searchPath of searchPaths) {
+			const componentPath = this.findComponentInMiniprogramNpm(componentName, searchPath);
+			if (componentPath) return componentPath;
+		}
+		return null;
+	}
+	/**
+	* 解析脚本模块路径，支持微信小程序 npm 逐级寻址和 package.json 入口
+	* @param {string} specifier 模块导入路径
+	* @param {string} modulePath 当前模块绝对文件路径
+	* @param {(moduleId: string) => string | null} resolveExistingModuleId 解析真实存在模块的回调
+	* @returns {string|null} 解析后的模块 id
+	*/
+	resolveScriptModule(specifier, modulePath, resolveExistingModuleId) {
+		if (!specifier || !resolveExistingModuleId) return null;
+		for (const searchPath of this.generateSearchPaths(modulePath)) {
+			const resolvedModuleId = resolveExistingModuleId(this.normalizeModuleId(`/${searchPath}/${specifier}`));
+			if (resolvedModuleId) return resolvedModuleId;
+		}
+		return null;
+	}
+	/**
+	* 生成 miniprogram_npm 搜索路径
+	* 按照微信小程序的寻址顺序生成搜索路径
+	* @param {string} pageFilePath 页面文件路径
+	* @returns {string[]} 搜索路径数组
+	*/
+	generateSearchPaths(pageFilePath) {
+		const pathParts = getRelativePosixPath(pageFilePath, this.workPath).split("/").slice(0, -1);
+		const searchPaths = [];
+		for (let i = pathParts.length; i >= 0; i--) {
+			const currentPath = pathParts.slice(0, i).join("/");
+			const miniprogramNpmPath = currentPath ? `${currentPath}/miniprogram_npm` : "miniprogram_npm";
+			searchPaths.push(miniprogramNpmPath);
+		}
+		return searchPaths;
+	}
+	/**
+	* 在指定的 miniprogram_npm 目录中查找组件
+	* @param {string} componentName 组件名称
+	* @param {string} miniprogramNpmPath miniprogram_npm 路径
+	* @returns {string|null} 组件路径，如果找不到返回 null
+	*/
+	findComponentInMiniprogramNpm(componentName, miniprogramNpmPath) {
+		const fullMiniprogramNpmPath = node_path.default.join(this.workPath, miniprogramNpmPath);
+		if (!node_fs.default.existsSync(fullMiniprogramNpmPath)) return null;
+		const cacheKey = `${miniprogramNpmPath}/${componentName}`;
+		if (this.miniprogramNpmCache.has(cacheKey)) return this.miniprogramNpmCache.get(cacheKey);
+		const candidatePaths = [componentName, `${componentName}/index`];
+		for (const candidatePath of candidatePaths) {
+			const componentDir = node_path.default.join(fullMiniprogramNpmPath, candidatePath);
+			if (this.isValidComponent(componentDir)) {
+				const resolvedPath = `/${miniprogramNpmPath}/${candidatePath}`.replace(/\/+/g, "/");
+				this.miniprogramNpmCache.set(cacheKey, resolvedPath);
+				return resolvedPath;
+			}
+		}
+		this.miniprogramNpmCache.set(cacheKey, null);
+		return null;
+	}
+	normalizeModuleId(moduleId) {
+		let normalized = moduleId.replace(/\.(js|ts)$/, "").replace(/\\/g, "/");
+		if (!normalized.startsWith("/")) normalized = `/${normalized}`;
+		return normalized;
+	}
+	/**
+	* 检查是否为有效的组件
+	* @param {string} componentPath 组件路径
+	* @returns {boolean} 是否为有效组件
+	*/
+	isValidComponent(componentPath) {
+		const requiredFiles = [".json", ".js"];
+		if (!requiredFiles.some((ext) => {
+			return node_fs.default.existsSync(`${componentPath}${ext}`);
+		})) {
+			if (!requiredFiles.some((ext) => {
+				return node_fs.default.existsSync(node_path.default.join(componentPath, `index${ext}`));
+			})) return false;
+			const indexJsonFile = node_path.default.join(componentPath, "index.json");
+			if (node_fs.default.existsSync(indexJsonFile)) try {
+				return JSON.parse(node_fs.default.readFileSync(indexJsonFile, "utf-8")).component === true;
+			} catch (e) {
+				return false;
+			}
+			return true;
+		}
+		const jsonFile = `${componentPath}.json`;
+		if (node_fs.default.existsSync(jsonFile)) try {
+			return JSON.parse(node_fs.default.readFileSync(jsonFile, "utf-8")).component === true;
+		} catch (e) {
+			return false;
+		}
+		return true;
+	}
+	/**
+	* 获取 npm 包信息
+	* @param {string} packageName 包名
+	* @param {string} searchPath 搜索路径
+	* @returns {object|null} 包信息，如果找不到返回 null
+	*/
+	getPackageInfo(packageName, searchPath) {
+		const cacheKey = `${searchPath}/${packageName}`;
+		if (this.packageCache.has(cacheKey)) return this.packageCache.get(cacheKey);
+		const packageJsonPath = node_path.default.join(this.workPath, searchPath, packageName, "package.json");
+		if (!node_fs.default.existsSync(packageJsonPath)) {
+			this.packageCache.set(cacheKey, null);
+			return null;
+		}
+		try {
+			const packageInfo = JSON.parse(node_fs.default.readFileSync(packageJsonPath, "utf-8"));
+			this.packageCache.set(cacheKey, packageInfo);
+			return packageInfo;
+		} catch (e) {
+			this.packageCache.set(cacheKey, null);
+			return null;
+		}
+	}
+	/**
+	* 清除缓存
+	*/
+	clearCache() {
+		this.miniprogramNpmCache.clear();
+		this.packageCache.clear();
+	}
+};
+//#endregion
+//#region src/env.js
+var pathInfo = {};
+var configInfo = {};
+var npmResolver = null;
+var dependencyGraph = new DependencyGraph();
+var DEFAULT_TEMPLATE_EXTS = [".wxml", ".ddml"];
+var DEFAULT_TEMPLATE_DIRECTIVE_PREFIXES = [
+	"wx",
+	"dd",
+	"a"
+];
+var DEFAULT_STYLE_EXTS = [
+	".wxss",
+	".ddss",
+	".less",
+	".scss",
+	".sass"
+];
+var DEFAULT_VIEW_SCRIPT_EXTS = [".wxs"];
+var DEFAULT_VIEW_SCRIPT_TAGS = ["wxs", "dds"];
+var CUSTOM_TAB_BAR_COMPONENT_PATH = "/custom-tab-bar/index";
+var STYLE_ISOLATION_VALUES = /* @__PURE__ */ new Set([
+	"isolated",
+	"apply-shared",
+	"shared"
+]);
+var RESERVED_EXTS = /* @__PURE__ */ new Set([
+	...DEFAULT_TEMPLATE_EXTS,
+	...DEFAULT_STYLE_EXTS,
+	...DEFAULT_VIEW_SCRIPT_EXTS,
+	".js",
+	".ts",
+	".json"
+]);
+var compilerOptions = normalizeFileTypes();
+/**
+* 将单项规范化为扩展名：去除首尾空白、转小写并补一个前导点。
+* 仅接受字母、数字、连字符和下划线；空字符串、路径分隔符或其他元字符
+* 均返回 null，由调用方丢弃。扩展名会用于生成尾部匹配正则和查找文件，
+* 放行元字符可能导致误匹配。
+*/
+function normalizeExt(raw) {
+	if (typeof raw !== "string") return null;
+	const v = raw.trim().toLowerCase().replace(/^\.+/, "");
+	if (!/^[a-z0-9_-]+$/.test(v)) return null;
+	return `.${v}`;
+}
+/**
+* 将单项规范化为内联标签名：去除首尾空白、转小写并移除前导点。
+* 标签名会用于拼接 Cheerio 选择器（如 transTagWxs），因此必须以字母开头，
+* 且只能包含字母、数字、连字符和下划线。拒绝选择器元字符，避免 'qds,view'
+* 误选并删除 <view>，破坏编译产物。
+*/
+function normalizeTag(raw) {
+	if (typeof raw !== "string") return null;
+	const v = raw.trim().toLowerCase().replace(/^\.+/, "");
+	if (!/^[a-z][a-z0-9_-]*$/.test(v)) return null;
+	return v;
+}
+/**
+* 合并并去重内置项和自定义项；内置项在前，顺序即同名文件的查找优先级。
+* 传入 reserved 时，落在其中的自定义项被丢弃（防止占用其他角色/逻辑/配置的扩展名）。
+*/
+function mergeUnique(builtins, custom, normalizer, reserved) {
+	const out = [...builtins];
+	const seen = new Set(builtins);
+	if (Array.isArray(custom)) for (const raw of custom) {
+		const n = normalizer(raw);
+		if (n && !seen.has(n) && !reserved?.has(n)) {
+			seen.add(n);
+			out.push(n);
+		}
+	}
+	return out;
+}
+/**
+* 根据 options.fileTypes 生成本次构建使用的自定义扩展名和标签。
+* viewScript 同时用于生成文件扩展名和内联标签。
+*/
+function normalizeFileTypes(fileTypes = {}) {
+	const ft = fileTypes || {};
+	const templateExts = mergeUnique(DEFAULT_TEMPLATE_EXTS, ft.template, normalizeExt, RESERVED_EXTS);
+	return {
+		templateExts,
+		templateDirectivePrefixes: [.../* @__PURE__ */ new Set([...DEFAULT_TEMPLATE_DIRECTIVE_PREFIXES, ...templateExts.map((extension) => {
+			const name = extension.slice(1);
+			return name.endsWith("ml") ? name.slice(0, -2) : name;
+		}).filter(Boolean)])],
+		styleExts: mergeUnique(DEFAULT_STYLE_EXTS, ft.style, normalizeExt, RESERVED_EXTS),
+		viewScriptExts: mergeUnique(DEFAULT_VIEW_SCRIPT_EXTS, ft.viewScript, normalizeExt, RESERVED_EXTS),
+		viewScriptTags: mergeUnique(DEFAULT_VIEW_SCRIPT_TAGS, ft.viewScript, normalizeTag)
+	};
+}
+/**
+* 持久化编译过程的上下文
+* @param {string} workPath 编译工作目录
+* @param {{ fileTypes?: { template?: string[], style?: string[], viewScript?: string[] } }} [options] 构建选项
+*/
+function storeInfo(workPath, options = {}) {
+	compilerOptions = normalizeFileTypes(options.fileTypes);
+	storePathInfo(workPath);
+	storeProjectConfig();
+	storeAppConfig();
+	storePageConfig();
+	dependencyGraph = createInitialDependencyGraph();
+	dependencyGraph.merge(options.dependencyGraph);
+	return {
+		pathInfo,
+		configInfo,
+		compilerOptions,
+		dependencyGraph: dependencyGraph.toJSON()
+	};
+}
+function resetStoreInfo(opts) {
+	pathInfo = opts.pathInfo;
+	configInfo = opts.configInfo;
+	compilerOptions = opts.compilerOptions || normalizeFileTypes();
+	dependencyGraph = new DependencyGraph(opts.dependencyGraph);
+	if (pathInfo.workPath) npmResolver = new NpmResolver(pathInfo.workPath);
+}
+function getTemplateExts() {
+	return compilerOptions.templateExts;
+}
+function getTemplateDirectivePrefixes() {
+	return compilerOptions.templateDirectivePrefixes || normalizeFileTypes({ template: compilerOptions.templateExts }).templateDirectivePrefixes;
+}
+function getStyleExts() {
+	return compilerOptions.styleExts;
+}
+function getViewScriptExts() {
+	return compilerOptions.viewScriptExts;
+}
+function getViewScriptTags() {
+	return compilerOptions.viewScriptTags;
+}
+function getDependencyGraph() {
+	return dependencyGraph;
+}
+function storePathInfo(workPath) {
+	pathInfo.workPath = workPath;
+	if (node_process.default.env.TARGET_PATH) pathInfo.targetPath = node_process.default.env.TARGET_PATH;
+	else {
+		const tempDir = node_process.default.env.GITHUB_WORKSPACE || node_os.default.tmpdir();
+		const targetDir = node_path.default.join(tempDir, `dimina-fe-dist-${Date.now()}`);
+		if (!node_fs.default.existsSync(targetDir)) node_fs.default.mkdirSync(targetDir, { recursive: true });
+		pathInfo.targetPath = targetDir;
+	}
+	npmResolver = new NpmResolver(workPath);
+}
+function storeProjectConfig() {
+	const privateConfigPath = `${pathInfo.workPath}/project.private.config.json`;
+	const defaultConfigPath = `${pathInfo.workPath}/project.config.json`;
+	let privateConfig = {};
+	let defaultConfig = {};
+	if (node_fs.default.existsSync(defaultConfigPath)) try {
+		defaultConfig = parseContentByPath(defaultConfigPath);
+	} catch (e) {
+		console.warn("Failed to parse project.config.json:", e.message);
+	}
+	if (node_fs.default.existsSync(privateConfigPath)) try {
+		privateConfig = parseContentByPath(privateConfigPath);
+	} catch (e) {
+		console.warn("Failed to parse project.private.config.json:", e.message);
+	}
+	configInfo.projectInfo = {
+		...defaultConfig,
+		...privateConfig
+	};
+}
+function getProjectConfig() {
+	return configInfo.projectInfo;
+}
+function storeAppConfig() {
+	const content = parseContentByPath(`${pathInfo.workPath}/app.json`);
+	const newObj = {};
+	for (const key in content) if (Object.prototype.hasOwnProperty.call(content, key)) if (key === "subpackages") newObj.subPackages = content[key];
+	else newObj[key] = content[key];
+	configInfo.appInfo = newObj;
+}
+function getContentByPath(path) {
+	return node_fs.default.readFileSync(path, { encoding: "utf-8" });
+}
+function parseContentByPath(path) {
+	return JSON.parse(getContentByPath(path));
+}
+/**
+* 收集页面 json 信息
+*/
+function storePageConfig() {
+	const { pages, subPackages } = configInfo.appInfo;
+	configInfo.pageInfo = {};
+	configInfo.componentInfo = {};
+	if (configInfo.appInfo.usingComponents) {
+		const appFilePath = `${pathInfo.workPath}/app.json`;
+		storeComponentConfig(configInfo.appInfo, appFilePath);
+	}
+	collectionPageJson(pages);
+	if (subPackages) subPackages.forEach((subPkg) => {
+		collectionPageJson(subPkg.pages, subPkg.root);
+	});
+	storeCustomTabBarConfig();
+}
+/**
+* 微信会把 custom-tab-bar/index 作为每个 tab 页的直属组件创建。业务页面
+* 不需要在 usingComponents 中显式声明它，因此编译阶段补一个内部组件引用，
+* 让逻辑、视图和样式三个编译器都能沿现有依赖图收集该组件。
+*/
+function storeCustomTabBarConfig() {
+	const tabBar = configInfo.appInfo?.tabBar;
+	if (tabBar?.custom !== true || !Array.isArray(tabBar.list)) return;
+	const componentJsonPath = node_path.default.join(pathInfo.workPath, "custom-tab-bar/index.json");
+	if (!node_fs.default.existsSync(componentJsonPath)) {
+		console.warn("[env] tabBar.custom 已启用，但找不到 custom-tab-bar/index.json");
+		return;
+	}
+	const dependencyName = `dimina-${uuid(CUSTOM_TAB_BAR_COMPONENT_PATH)}`;
+	storeComponentConfig({ usingComponents: { [dependencyName]: CUSTOM_TAB_BAR_COMPONENT_PATH } }, node_path.default.join(pathInfo.workPath, "app.json"));
+	const componentConfig = configInfo.componentInfo[CUSTOM_TAB_BAR_COMPONENT_PATH];
+	if (componentConfig) componentConfig.customTabBar = true;
+	for (const item of tabBar.list) {
+		const pagePath = typeof item?.pagePath === "string" ? item.pagePath.replace(/^\/+/, "") : "";
+		if (!pagePath || !configInfo.appInfo.pages?.includes(pagePath)) continue;
+		const pageConfig = configInfo.pageInfo[pagePath] ||= {};
+		pageConfig.usingComponents ||= {};
+		const declaredComponents = {
+			...configInfo.appInfo.usingComponents || {},
+			...pageConfig.usingComponents
+		};
+		let componentName = Object.entries(declaredComponents).find(([, componentPath]) => componentPath === CUSTOM_TAB_BAR_COMPONENT_PATH)?.[0] || dependencyName;
+		let suffix = 0;
+		while (declaredComponents[componentName] && declaredComponents[componentName] !== CUSTOM_TAB_BAR_COMPONENT_PATH) {
+			suffix++;
+			componentName = `${dependencyName}-${suffix}`;
+		}
+		pageConfig.usingComponents[componentName] = CUSTOM_TAB_BAR_COMPONENT_PATH;
+		pageConfig.customTabBar = { componentName };
+	}
+}
+/**
+* 匹配页面和对应的配置信息
+* @param {*} pages
+*/
+function collectionPageJson(pages, root) {
+	pages.forEach((pagePath) => {
+		let np = pagePath;
+		if (root) {
+			if (!root.endsWith("/")) root += "/";
+			np = root + np;
+		}
+		const pageFilePath = `${pathInfo.workPath}/${np}.json`;
+		if (node_fs.default.existsSync(pageFilePath)) {
+			const pageJsonContent = parseContentByPath(pageFilePath);
+			if (root) pageJsonContent.root = transSubDir(root);
+			configInfo.pageInfo[np] = pageJsonContent;
+			storeComponentConfig(pageJsonContent, pageFilePath);
+		}
+	});
+}
+/**
+* 按页面收集组件 json 信息
+* @param {*} pageJsonContent
+* @param {*} pageFilePath
+*/
+function storeComponentConfig(pageJsonContent, pageFilePath) {
+	if (isObjectEmpty(pageJsonContent.usingComponents)) return;
+	for (const [componentName, componentPath] of Object.entries(pageJsonContent.usingComponents)) {
+		const moduleId = getModuleId(componentPath, pageFilePath);
+		pageJsonContent.usingComponents[componentName] = moduleId;
+		if (configInfo.componentInfo[moduleId]) continue;
+		let componentFilePath = node_path.default.resolve(getWorkPath(), `./${moduleId}.json`);
+		let cContent = null;
+		if (node_fs.default.existsSync(componentFilePath)) cContent = parseContentByPath(componentFilePath);
+		else {
+			const indexJsonPath = node_path.default.resolve(getWorkPath(), `./${moduleId}/index.json`);
+			if (node_fs.default.existsSync(indexJsonPath)) {
+				componentFilePath = indexJsonPath;
+				cContent = parseContentByPath(componentFilePath);
+			} else if (moduleId.includes("/miniprogram_npm/")) {
+				console.log(`[env] 为 npm 组件创建默认配置: ${moduleId}`);
+				cContent = {
+					component: true,
+					usingComponents: {}
+				};
+			} else {
+				console.warn(`[env] 组件配置文件不存在: ${componentFilePath}`);
+				continue;
+			}
+		}
+		const cUsing = cContent.usingComponents || {};
+		const isComponent = cContent.component || false;
+		const styleIsolation = resolveComponentStyleIsolation(cContent, componentFilePath);
+		const cComponents = Object.keys(cUsing).reduce((acc, key) => {
+			acc[key] = getModuleId(cUsing[key], componentFilePath);
+			return acc;
+		}, {});
+		configInfo.componentInfo[moduleId] = {
+			id: uuid(moduleId),
+			path: moduleId,
+			component: isComponent,
+			styleIsolation,
+			usingComponents: cComponents,
+			componentPlaceholder: { ...cContent.componentPlaceholder || {} }
+		};
+		if (cContent.usingComponents && Object.keys(cContent.usingComponents).length > 0) storeComponentConfig(configInfo.componentInfo[moduleId], componentFilePath);
+	}
+}
+function getStaticProperty(objectExpression, propertyName) {
+	if (objectExpression?.type !== "ObjectExpression") return;
+	return objectExpression.properties?.find((property) => {
+		if (property.type !== "Property" || property.computed) return false;
+		return property.key?.name === propertyName || property.key?.value === propertyName;
+	})?.value;
+}
+function normalizeStyleIsolation(value) {
+	return STYLE_ISOLATION_VALUES.has(value) ? value : void 0;
+}
+/**
+* styleIsolation can be declared either in component.json or in
+* Component({ options }). The style compiler must know it before service
+* runtime starts, so only statically-declared literal options participate.
+* addGlobalClass is the legacy equivalent of apply-shared.
+*/
+function resolveComponentStyleIsolation(componentConfig, componentJsonPath) {
+	const jsonValue = normalizeStyleIsolation(componentConfig?.styleIsolation);
+	if (jsonValue) return jsonValue;
+	const basePath = componentJsonPath.replace(/\.json$/i, "");
+	const scriptPath = [".js", ".ts"].map((ext) => `${basePath}${ext}`).find((candidate) => node_fs.default.existsSync(candidate));
+	if (!scriptPath) return "isolated";
+	try {
+		const { program } = (0, oxc_parser.parseSync)(scriptPath, getContentByPath(scriptPath), { sourceType: "unambiguous" });
+		let extractedValue;
+		(0, oxc_walker.walk)(program, { enter(expression) {
+			if (extractedValue) return;
+			if (expression?.type !== "CallExpression" || expression.callee?.type !== "Identifier" || expression.callee.name !== "Component") return;
+			const definition = expression.arguments?.[0];
+			const options = getStaticProperty(definition, "options");
+			const styleIsolation = getStaticProperty(options, "styleIsolation")?.value;
+			const normalized = normalizeStyleIsolation(styleIsolation);
+			if (normalized) {
+				extractedValue = normalized;
+				return;
+			}
+			if (getStaticProperty(options, "addGlobalClass")?.value === true) extractedValue = "apply-shared";
+		} });
+		if (extractedValue) return extractedValue;
+	} catch (error) {
+		console.warn(`[env] 无法解析组件样式隔离配置 ${scriptPath}: ${error.message}`);
+	}
+	return "isolated";
+}
+/**
+* 转化为相对小程序根目录的绝对路径，作为模块唯一性 id
+* 支持 npm 组件解析
+* @param {string} src
+*/
+function getModuleId(src, pageFilePath) {
+	const resolvedAlias = resolveAppAlias(src);
+	if (resolvedAlias) return resolvedAlias;
+	if (!npmResolver) {
+		const workPath = getWorkPath();
+		return toMiniProgramModuleId(resolveMiniProgramPath(workPath, pageFilePath, src), workPath);
+	}
+	return npmResolver.resolveComponentPath(src, pageFilePath);
+}
+function resolveAppAlias(src) {
+	const resolveAlias = configInfo.appInfo?.resolveAlias;
+	if (!resolveAlias || typeof src !== "string") return null;
+	for (const [alias, target] of Object.entries(resolveAlias)) if (alias.endsWith("/*") && target.endsWith("/*")) {
+		const aliasPrefix = alias.slice(0, -1);
+		const targetPrefix = target.slice(0, -1);
+		if (src.startsWith(aliasPrefix)) return src.replace(aliasPrefix, targetPrefix);
+	} else if (src === alias) return target;
+	return null;
+}
+function getTargetPath() {
+	return pathInfo.targetPath;
+}
+function getComponent(src) {
+	return configInfo.componentInfo[src];
+}
+function getPageConfigInfo() {
+	return configInfo.pageInfo;
+}
+function getAppConfigInfo() {
+	return configInfo.appInfo;
+}
+function getWorkPath() {
+	return pathInfo.workPath;
+}
+function getNpmResolver() {
+	return npmResolver;
+}
+function getAppId() {
+	return configInfo.projectInfo.appid;
+}
+function getAppName() {
+	if (configInfo.projectInfo.projectname) return decodeURIComponent(configInfo.projectInfo.projectname);
+	return getAppId();
+}
+function transSubDir(name) {
+	return `sub_${name.replace(/\/$/, "")}`;
+}
+/**
+* 获取页面及其配置信息，并生成id（输出的 json 文件没有 id)
+*/
+function getPages() {
+	const { pages, subPackages = [], usingComponents: globalComponents = {} } = getAppConfigInfo();
+	const pageInfo = getPageConfigInfo();
+	const mainPages = pages.map((path) => {
+		const pageComponents = pageInfo[path]?.usingComponents || {};
+		const mergedComponents = {
+			...globalComponents,
+			...pageComponents
+		};
+		return {
+			id: uuid(path),
+			path,
+			appStyleScopeId: getAppStyleScopeId(),
+			sharedStyleScopeIds: collectSharedStyleScopeIds(mergedComponents),
+			usingComponents: mergedComponents,
+			componentPlaceholder: { ...pageInfo[path]?.componentPlaceholder || {} },
+			customTabBar: pageInfo[path]?.customTabBar
+		};
+	});
+	const subPages = {};
+	subPackages.forEach((subPkg) => {
+		const rootPath = subPkg.root.endsWith("/") ? subPkg.root : `${subPkg.root}/`;
+		const independent = subPkg.independent ? subPkg.independent : false;
+		subPages[transSubDir(rootPath)] = {
+			independent,
+			info: subPkg.pages.map((path) => {
+				const fullPath = rootPath + path;
+				const pageComponents = pageInfo[fullPath]?.usingComponents || {};
+				const mergedComponents = {
+					...globalComponents,
+					...pageComponents
+				};
+				return {
+					id: uuid(fullPath),
+					path: fullPath,
+					appStyleScopeId: getAppStyleScopeId(),
+					sharedStyleScopeIds: collectSharedStyleScopeIds(mergedComponents),
+					usingComponents: mergedComponents,
+					componentPlaceholder: { ...pageInfo[fullPath]?.componentPlaceholder || {} },
+					customTabBar: pageInfo[fullPath]?.customTabBar
+				};
+			})
+		};
+	});
+	return {
+		mainPages,
+		subPages
+	};
+}
+function addExistingModuleFiles(graph, moduleId) {
+	const relativeId = moduleId.replace(/^\/+/, "");
+	const basePath = node_path.default.resolve(getWorkPath(), relativeId);
+	const baseCandidates = [basePath, node_path.default.join(basePath, "index")];
+	const extensions = [
+		".json",
+		".js",
+		".ts",
+		...getTemplateExts(),
+		...getStyleExts(),
+		...getViewScriptExts()
+	];
+	for (const candidateBase of baseCandidates) for (const extension of extensions) {
+		const filePath = `${candidateBase}${extension}`;
+		if (node_fs.default.existsSync(filePath)) graph.addFile(moduleId, filePath, getFileDependencyKind(filePath));
+	}
+}
+function getFileDependencyKind(filePath) {
+	const extension = node_path.default.extname(filePath).toLowerCase();
+	if (extension === ".json") return "config";
+	if (extension === ".js" || extension === ".ts") return "logic";
+	if (getTemplateExts().includes(extension) || getViewScriptExts().includes(extension)) return "view";
+	if (getStyleExts().includes(extension)) return "style";
+	return "module";
+}
+function createInitialDependencyGraph() {
+	const graph = new DependencyGraph();
+	graph.addNode("app", { type: "app" });
+	for (const fileName of [
+		"app.json",
+		"app.js",
+		"app.ts",
+		"project.config.json",
+		"project.private.config.json"
+	]) {
+		const filePath = node_path.default.resolve(getWorkPath(), fileName);
+		if (node_fs.default.existsSync(filePath)) graph.addFile("app", filePath, getFileDependencyKind(filePath));
+	}
+	addExistingModuleFiles(graph, "app");
+	for (const item of getAppConfigInfo().tabBar?.list || []) for (const field of ["iconPath", "selectedIconPath"]) {
+		if (!item[field]) continue;
+		const assetPath = resolveAssetSourcePath(getWorkPath(), "", item[field]);
+		if (node_fs.default.existsSync(assetPath)) graph.addFile("app", assetPath, "config");
+	}
+	for (const component of Object.values(configInfo.componentInfo || {})) {
+		graph.addNode(component.path, { type: "component" });
+		addExistingModuleFiles(graph, component.path);
+	}
+	for (const component of Object.values(configInfo.componentInfo || {})) for (const dependencyPath of Object.values(component.usingComponents || {})) graph.addDependency(component.path, dependencyPath, "component");
+	const pages = getPages();
+	const addEntry = (page, packageRoot) => {
+		graph.addNode(page.path, {
+			type: "page",
+			entry: true,
+			packageRoot
+		});
+		addExistingModuleFiles(graph, page.path);
+		graph.addDependency(page.path, "app", "app");
+		for (const dependencyPath of Object.values(page.usingComponents || {})) graph.addDependency(page.path, dependencyPath, "component");
+	};
+	for (const page of pages.mainPages) addEntry(page, null);
+	for (const [packageRoot, subPackage] of Object.entries(pages.subPages)) for (const page of subPackage.info) addEntry(page, packageRoot);
+	return graph;
+}
+function collectSharedStyleScopeIds(usingComponents) {
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	const visit = (componentPath) => {
+		if (visited.has(componentPath)) return;
+		visited.add(componentPath);
+		const component = configInfo.componentInfo[componentPath];
+		if (!component) return;
+		if (component.styleIsolation === "shared") result.push(component.id);
+		for (const childPath of Object.values(component.usingComponents || {})) visit(childPath);
+	};
+	for (const componentPath of Object.values(usingComponents || {})) visit(componentPath);
+	return result;
+}
+function getAppStyleScopeId() {
+	return uuid("app");
+}
+//#endregion
+//#region src/core/sourcemap.js
+function wrapModDefine(module) {
+	const code = module.code.endsWith("\n") ? module.code : module.code + "\n";
+	const extraLine = module.extraInfoCode || "";
+	return {
+		header: `modDefine('${module.path}', function(require, module, exports) {\n${extraLine}`,
+		code,
+		footer: "});\n"
+	};
+}
+function appendSourceMap(smg, map, lineOffset, columnOffset) {
+	const mapObject = typeof map === "string" ? JSON.parse(map) : map;
+	new source_map_js.SourceMapConsumer(mapObject).eachMapping((mapping) => {
+		if (mapping.source == null || mapping.originalLine == null || mapping.originalColumn == null) return;
+		smg.addMapping({
+			generated: {
+				line: mapping.generatedLine + lineOffset,
+				column: mapping.generatedColumn + (mapping.generatedLine === 1 ? columnOffset : 0)
+			},
+			original: {
+				line: mapping.originalLine,
+				column: mapping.originalColumn
+			},
+			source: mapping.source,
+			name: mapping.name
+		});
+	});
+	if (mapObject.sourcesContent) mapObject.sources.forEach((source, index) => {
+		smg.setSourceContent(source, mapObject.sourcesContent[index]);
+	});
+}
+function advanceGeneratedPosition(position, code) {
+	const lines = code.split("\n");
+	if (lines.length === 1) {
+		position.column += code.length;
+		return;
+	}
+	position.line += lines.length - 1;
+	position.column = lines.at(-1).length;
+}
+function concatSourcemap(chunks, file = "") {
+	const smg = new source_map_js.SourceMapGenerator({ file });
+	const position = {
+		line: 1,
+		column: 0
+	};
+	let code = "";
+	for (const chunk of chunks) {
+		const chunkCode = typeof chunk === "string" ? chunk : chunk.code;
+		if (typeof chunk !== "string" && chunk.map) appendSourceMap(smg, chunk.map, position.line - 1, position.column);
+		code += chunkCode;
+		advanceGeneratedPosition(position, chunkCode);
+	}
+	return {
+		code,
+		sourcemap: smg.toString()
+	};
+}
+function createLineSourcemap(generatedCode, source, sourceContent, startLine = 1) {
+	const smg = new source_map_js.SourceMapGenerator({ file: source });
+	const generatedLineCount = generatedCode.split("\n").length;
+	const sourceLineCount = Math.max(1, sourceContent.split("\n").length);
+	for (let line = 1; line <= generatedLineCount; line++) smg.addMapping({
+		generated: {
+			line,
+			column: 0
+		},
+		original: {
+			line: Math.min(sourceLineCount, startLine + line - 1),
+			column: 0
+		},
+		source
+	});
+	smg.setSourceContent(source, sourceContent);
+	return JSON.parse(smg.toString());
+}
+function mergeSourcemap(compileRes, file = "logic.js") {
+	const chunks = [];
+	for (const module of compileRes) {
+		const { header, code, footer } = wrapModDefine(module);
+		chunks.push(header, {
+			code,
+			map: module.map
+		}, footer);
+	}
+	const { code: bundleCode, sourcemap } = concatSourcemap(chunks, file);
+	return {
+		bundleCode,
+		sourcemap
+	};
+}
+function remapSourcemap(nextMap, prevMap) {
+	if (!nextMap) return prevMap;
+	if (!prevMap) return nextMap;
+	const nextMapObj = typeof nextMap === "string" ? JSON.parse(nextMap) : nextMap;
+	const prevMapObj = typeof prevMap === "string" ? JSON.parse(prevMap) : prevMap;
+	const smg = new source_map_js.SourceMapGenerator({ file: nextMapObj.file || prevMapObj.file || "" });
+	const prevSmc = new source_map_js.SourceMapConsumer(prevMapObj);
+	new source_map_js.SourceMapConsumer(nextMapObj).eachMapping((mapping) => {
+		if (mapping.source == null || mapping.originalLine == null || mapping.originalColumn == null) return;
+		const original = prevSmc.originalPositionFor({
+			line: mapping.originalLine,
+			column: mapping.originalColumn
+		});
+		if (original.source == null || original.line == null || original.column == null) return;
+		smg.addMapping({
+			generated: {
+				line: mapping.generatedLine,
+				column: mapping.generatedColumn
+			},
+			original: {
+				line: original.line,
+				column: original.column
+			},
+			source: original.source,
+			name: original.name || mapping.name
+		});
+	});
+	if (prevMapObj.sourcesContent) prevMapObj.sources.forEach((src, i) => {
+		smg.setSourceContent(src, prevMapObj.sourcesContent[i]);
+	});
+	return smg.toString();
+}
+//#endregion
+Object.defineProperty(exports, "DependencyGraph", {
+	enumerable: true,
+	get: function() {
+		return DependencyGraph;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "collectAssets", {
+	enumerable: true,
+	get: function() {
+		return collectAssets;
+	}
+});
+Object.defineProperty(exports, "concatSourcemap", {
+	enumerable: true,
+	get: function() {
+		return concatSourcemap;
+	}
+});
+Object.defineProperty(exports, "createLineSourcemap", {
+	enumerable: true,
+	get: function() {
+		return createLineSourcemap;
+	}
+});
+Object.defineProperty(exports, "getAbsolutePath", {
+	enumerable: true,
+	get: function() {
+		return getAbsolutePath;
+	}
+});
+Object.defineProperty(exports, "getAppConfigInfo", {
+	enumerable: true,
+	get: function() {
+		return getAppConfigInfo;
+	}
+});
+Object.defineProperty(exports, "getAppId", {
+	enumerable: true,
+	get: function() {
+		return getAppId;
+	}
+});
+Object.defineProperty(exports, "getAppName", {
+	enumerable: true,
+	get: function() {
+		return getAppName;
+	}
+});
+Object.defineProperty(exports, "getAppStyleScopeId", {
+	enumerable: true,
+	get: function() {
+		return getAppStyleScopeId;
+	}
+});
+Object.defineProperty(exports, "getComponent", {
+	enumerable: true,
+	get: function() {
+		return getComponent;
+	}
+});
+Object.defineProperty(exports, "getContentByPath", {
+	enumerable: true,
+	get: function() {
+		return getContentByPath;
+	}
+});
+Object.defineProperty(exports, "getDependencyGraph", {
+	enumerable: true,
+	get: function() {
+		return getDependencyGraph;
+	}
+});
+Object.defineProperty(exports, "getNpmResolver", {
+	enumerable: true,
+	get: function() {
+		return getNpmResolver;
+	}
+});
+Object.defineProperty(exports, "getPageConfigInfo", {
+	enumerable: true,
+	get: function() {
+		return getPageConfigInfo;
+	}
+});
+Object.defineProperty(exports, "getPages", {
+	enumerable: true,
+	get: function() {
+		return getPages;
+	}
+});
+Object.defineProperty(exports, "getProjectConfig", {
+	enumerable: true,
+	get: function() {
+		return getProjectConfig;
+	}
+});
+Object.defineProperty(exports, "getStyleExts", {
+	enumerable: true,
+	get: function() {
+		return getStyleExts;
+	}
+});
+Object.defineProperty(exports, "getTargetPath", {
+	enumerable: true,
+	get: function() {
+		return getTargetPath;
+	}
+});
+Object.defineProperty(exports, "getTemplateDirectivePrefixes", {
+	enumerable: true,
+	get: function() {
+		return getTemplateDirectivePrefixes;
+	}
+});
+Object.defineProperty(exports, "getTemplateExts", {
+	enumerable: true,
+	get: function() {
+		return getTemplateExts;
+	}
+});
+Object.defineProperty(exports, "getViewScriptExts", {
+	enumerable: true,
+	get: function() {
+		return getViewScriptExts;
+	}
+});
+Object.defineProperty(exports, "getViewScriptTags", {
+	enumerable: true,
+	get: function() {
+		return getViewScriptTags;
+	}
+});
+Object.defineProperty(exports, "getWorkPath", {
+	enumerable: true,
+	get: function() {
+		return getWorkPath;
+	}
+});
+Object.defineProperty(exports, "hasCompileInfo", {
+	enumerable: true,
+	get: function() {
+		return hasCompileInfo;
+	}
+});
+Object.defineProperty(exports, "mergeSourcemap", {
+	enumerable: true,
+	get: function() {
+		return mergeSourcemap;
+	}
+});
+Object.defineProperty(exports, "miniProgramBuiltinTags", {
+	enumerable: true,
+	get: function() {
+		return miniProgramBuiltinTags;
+	}
+});
+Object.defineProperty(exports, "remapSourcemap", {
+	enumerable: true,
+	get: function() {
+		return remapSourcemap;
+	}
+});
+Object.defineProperty(exports, "resetAssetCache", {
+	enumerable: true,
+	get: function() {
+		return resetAssetCache;
+	}
+});
+Object.defineProperty(exports, "resetStoreInfo", {
+	enumerable: true,
+	get: function() {
+		return resetStoreInfo;
+	}
+});
+Object.defineProperty(exports, "resolveAppAlias", {
+	enumerable: true,
+	get: function() {
+		return resolveAppAlias;
+	}
+});
+Object.defineProperty(exports, "resolveAssetSourcePath", {
+	enumerable: true,
+	get: function() {
+		return resolveAssetSourcePath;
+	}
+});
+Object.defineProperty(exports, "storeInfo", {
+	enumerable: true,
+	get: function() {
+		return storeInfo;
+	}
+});
+Object.defineProperty(exports, "tagWhiteList", {
+	enumerable: true,
+	get: function() {
+		return tagWhiteList;
+	}
+});
+Object.defineProperty(exports, "toMiniProgramModuleId", {
+	enumerable: true,
+	get: function() {
+		return toMiniProgramModuleId;
+	}
+});
+Object.defineProperty(exports, "transformRpx", {
+	enumerable: true,
+	get: function() {
+		return transformRpx;
+	}
+});