@unmagic/vms 0.0.5 → 0.1.1

package/dist/cli-B7IxnuYZ.js

@@ -0,0 +1,4620 @@
+import { parse } from "@vue/compiler-sfc";
+import fs, { createReadStream, existsSync, readFileSync } from "node:fs";
+import path, { basename, dirname, join, relative, resolve } from "node:path";
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { parse as parse$1, parseExpression } from "@babel/parser";
+import * as t$1 from "@babel/types";
+import t from "@babel/types";
+import { generate } from "@babel/generator";
+import _traverse from "@babel/traverse";
+import { codeFrameColumns } from "@babel/code-frame";
+import { bold, green, red } from "kolorist";
+import { createTransformContext, traverseNode } from "@vue/compiler-dom";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import fs$1 from "fs-extra";
+import { NodeTypes } from "@vue/compiler-core";
+import { transformAsync, transformFileAsync, transformFromAstSync } from "@babel/core";
+import { createRequire } from "node:module";
+import chokidar from "chokidar";
+import { getPackageInfo } from "local-pkg";
+import os from "node:os";
+import process$1 from "node:process";
+import { rolldown } from "rolldown";
+import { minify } from "terser";
+import { performance } from "perf_hooks";
+//#endregion
+//#region src/babel.config.ts
+const config = {
+	targets: {
+		chrome: "60",
+		ios: "10"
+	},
+	assumptions: {
+		constantReexports: true,
+		constantSuper: true,
+		enumerableModuleMeta: true,
+		ignoreFunctionLength: true,
+		ignoreToPrimitiveHint: true,
+		mutableTemplateObject: true,
+		noClassCalls: true,
+		noDocumentAll: true,
+		noNewArrows: true,
+		objectRestNoSymbols: true,
+		privateFieldsAsProperties: true,
+		pureGetters: true,
+		setClassMethods: true,
+		setComputedProperties: true,
+		setPublicClassFields: true,
+		setSpreadProperties: true,
+		skipForOfIteratorClosing: true,
+		superIsCallableConstructor: true
+	},
+	presets: [["@babel/preset-env", {
+		bugfixes: true,
+		modules: "commonjs",
+		exclude: [
+			"@babel/plugin-transform-shorthand-properties",
+			"@babel/plugin-transform-arrow-functions",
+			"@babel/plugin-transform-template-literals",
+			"@babel/plugin-transform-spread",
+			"@babel/plugin-transform-destructuring",
+			"@babel/plugin-transform-parameters",
+			"@babel/plugin-transform-for-of"
+		]
+	}], ["@babel/preset-typescript", {
+		allowNamespaces: true,
+		allowDeclareFields: true,
+		optimizeConstEnums: true,
+		allExtensions: true,
+		isTSX: true
+	}]],
+	plugins: [
+		["@babel/plugin-transform-runtime", { version: "7.29.2" }],
+		"transform-inline-environment-variables",
+		["module-resolver", { alias: { "@": "./src" } }],
+		"autocomplete-index"
+	]
+};
+//#endregion
+//#region src/style/index.ts
+function parseStyles(styles) {
+	if (!styles || styles.length === 0) return "";
+	return styles.map((style) => {
+		if (style.scoped) return style.content.replace(/\[data-v-[a-zA-Z0-9]+\]/g, "");
+		return style.content;
+	}).join("\n");
+}
+//#endregion
+//#region src/utils/babelTraverse.ts
+/**
+* 统一的 @babel/traverse ESM 兼容处理
+*
+* @babel/traverse 的 ESM 导出在某些环境下需要手动解构 default 导出。
+* 此模块封装该兼容逻辑，避免在多个文件中重复相同的 hack。
+*/
+const traverse = _traverse.default || _traverse;
+//#endregion
+//#region src/utils/errorHandler.ts
+/**
+* 统一的错误处理工具
+* 使用 @babel/code-frame 输出友好的错误信息
+*/
+/**
+* 安全提取错误消息
+* 用于 catch (error: unknown) 场景，替代不安全的 (error as any).message
+*/
+function getErrorMessage(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string") return error;
+	return String(error);
+}
+/**
+* 获取干净的错误消息，剥离 babel 内嵌的 code-frame 和编译后文件路径
+* babel transformAsync 错误 message 格式为: "/path/to/file.js: description (line:col)\n\n> line | code\n"
+* 只保留 "description (line:col)" 部分
+*/
+function getCleanErrorMessage(error) {
+	const msg = error.message || String(error);
+	const firstLine = msg.split("\n")[0];
+	if (!firstLine) return msg;
+	const colonIndex = firstLine.indexOf(": ");
+	if (colonIndex > 0) return firstLine.slice(colonIndex + 2);
+	return firstLine;
+}
+/**
+* 从错误对象中提取位置信息
+* 支持两种格式：
+* 1. CompileError 格式：error.cause?.loc（start/end 结构）
+* 2. babel 标准格式：error.loc（line/column 结构）
+*/
+function extractErrorLoc(error) {
+	const err = error;
+	if (err.cause?.loc) return err.cause.loc;
+	if (err.loc && typeof err.loc.line === "number" && typeof err.loc.column === "number") return { start: {
+		line: err.loc.line,
+		column: err.loc.column + 1
+	} };
+	return null;
+}
+/**
+* 创建带有位置信息的错误
+* @param message 错误消息
+* @param loc 错误位置
+* @returns 错误对象
+*/
+function createCompileError(message, loc) {
+	const error = new Error(message);
+	if (loc) error.cause = { loc };
+	return error;
+}
+/**
+* 使用 code-frame 输出错误信息
+* @param source 源代码
+* @param error 错误对象
+* @param filePath 文件路径（可选）
+*/
+function printErrorWithCodeFrame(source, error, filePath) {
+	const prefix = filePath ? `\n❌ Error in ${filePath}:\n` : "\n❌ Error:\n";
+	const loc = extractErrorLoc(error);
+	if (loc && source) {
+		const codeFrame = codeFrameColumns(source, loc, {
+			highlightCode: true,
+			message: error.message
+		});
+		console.error(prefix + codeFrame);
+	} else console.error(prefix + error.message);
+	if (error.stack) console.error("\nStack trace:", error.stack);
+}
+/**
+* 处理并输出错误
+* 如果错误包含位置信息，使用 code-frame 输出；否则直接输出错误消息
+* @param source 源代码
+* @param error 错误对象
+* @param filePath 文件路径（可选）
+* @returns 是否成功处理了错误（有位置信息）
+*/
+function handleCompileError(source, error, filePath) {
+	const err = error;
+	if (extractErrorLoc(error) && source) {
+		printErrorWithCodeFrame(source, err, filePath);
+		return true;
+	}
+	const prefix = filePath ? `❌ Error in ${filePath}: ` : "❌ Error: ";
+	console.error(prefix + getCleanErrorMessage(err));
+	return false;
+}
+//#endregion
+//#region src/script/macro/expose.ts
+const EXPOSE_KEY = "__vmsExposed__";
+function createComponentExport(path, expression, returnValue) {
+	if (t$1.isIdentifier(expression.callee) && expression.callee.name === "defineExpose") if (expression.arguments && expression.arguments.length > 0) {
+		const arg = expression.arguments[0];
+		if (t$1.isObjectExpression(arg)) {
+			let exposeExistIndex = returnValue.properties.findIndex((item) => t$1.isObjectProperty(item) && t$1.isIdentifier(item.key) && item.key.name === EXPOSE_KEY);
+			if (exposeExistIndex === -1) exposeExistIndex = returnValue.properties.push(t$1.objectProperty(t$1.identifier(EXPOSE_KEY), t$1.objectExpression([]))) - 1;
+			const exposeObjectExpressionProperties = returnValue.properties[exposeExistIndex].value.properties;
+			const exposeExportExpression = t$1.objectExpression([]);
+			arg.properties.forEach((prop) => {
+				if ((t$1.isObjectProperty(prop) || t$1.isObjectMethod(prop)) && t$1.isIdentifier(prop.key)) {
+					const key = prop.key.name;
+					if (!exposeObjectExpressionProperties.some((p) => (t$1.isObjectProperty(p) || t$1.isObjectMethod(p)) && t$1.isIdentifier(p.key) && p.key.name === key)) {
+						exposeObjectExpressionProperties.push(prop);
+						exposeExportExpression.properties.push(t$1.objectProperty(prop.key, t$1.memberExpression(t$1.memberExpression(t$1.memberExpression(t$1.thisExpression(), t$1.identifier("data")), t$1.identifier(EXPOSE_KEY)), prop.key)));
+					}
+				} else throw createCompileError("defineExpose参数必须是对象且属性名必须为identity", prop.loc || void 0);
+			});
+			path.remove();
+			return exposeExportExpression;
+		} else {
+			console.log(bold(red("defineExpose中传入的参数必须为对象")));
+			path.remove();
+			return null;
+		}
+	} else {
+		path.remove();
+		return null;
+	}
+	return null;
+}
+//#endregion
+//#region src/script/macro/emits.ts
+function dealMacroEmits(path, decl, defineContextVarName) {
+	const eventNameIdentifier = t.identifier("eventName");
+	eventNameIdentifier.typeAnnotation = t.tsTypeAnnotation(t.tsStringKeyword());
+	const valueIdentifier = t.identifier("value");
+	valueIdentifier.typeAnnotation = t.tsTypeAnnotation(t.tsAnyKeyword());
+	const arrowFunction = t.arrowFunctionExpression([eventNameIdentifier, valueIdentifier], t.callExpression(t.memberExpression(t.identifier(defineContextVarName), t.identifier("triggerEvent")), [t.identifier("eventName"), t.identifier("value")]));
+	const newVarDecl = t.variableDeclaration("const", [t.variableDeclarator(t.identifier(decl.id.name), arrowFunction)]);
+	path.replaceWith(newVarDecl);
+}
+//#endregion
+//#region src/script/macro/props.ts
+/**
+* 处理 defineProps 宏
+* - 提取 props 变量名
+* - 收集解构的 props 信息（包括别名和默认值）
+* - 从类型参数中提取未解构的 props
+* - 移除 defineProps 声明
+*/
+function dealMacroProps(path, decl, sfcContext) {
+	if (t.isIdentifier(decl.id)) sfcContext.propsVarName = decl.id.name;
+	else if (t.isObjectPattern(decl.id)) for (const prop of decl.id.properties) {
+		if (t.isRestElement(prop)) {
+			if (t.isIdentifier(prop.argument)) sfcContext.propsVarRestName = prop.argument.name;
+			continue;
+		}
+		if (!t.isObjectProperty(prop) || !t.isIdentifier(prop.key)) continue;
+		const propName = prop.key.name;
+		if (t.isAssignmentPattern(prop.value) && t.isIdentifier(prop.value.left)) {
+			if (propName === "style" && prop.value.left.name !== "style") sfcContext.propsVarsMap.delete("style");
+			sfcContext.propsVarsMap.set(prop.value.left.name, {
+				defaultValue: prop.value.right,
+				originName: propName,
+				isDestructured: true
+			});
+		} else if (t.isIdentifier(prop.value)) {
+			if (propName === "style" && prop.value.name !== "style") sfcContext.propsVarsMap.delete("style");
+			sfcContext.propsVarsMap.set(prop.value.name, {
+				originName: propName,
+				isDestructured: true
+			});
+		}
+	}
+	const init = decl.init;
+	if (t.isCallExpression(init) && init.typeParameters?.params && init.typeParameters.params.length > 0) {
+		const typeParams = init.typeParameters.params[0];
+		if (t.isTSTypeLiteral(typeParams)) typeParams.members.forEach((member) => {
+			if (t.isTSPropertySignature(member) && t.isIdentifier(member.key)) {
+				const aliasName = member.key.name;
+				if (!sfcContext.propsVarsMap.has(aliasName)) {
+					if (![...sfcContext.propsVarsMap.values()].some((v) => v.originName === aliasName)) sfcContext.propsVarsMap.set(aliasName, {
+						originName: aliasName,
+						isDestructured: false
+					});
+				}
+			}
+		});
+	}
+	path.remove();
+}
+/**
+* 在 AST 中全局替换 props 变量
+* 将解构的 props 变量（如 record）替换为成员访问（如 __vmsProps.record）
+*
+* @param ast - 要处理的 AST（Program 或 BlockStatement）
+* @param sfcContext - SFC 上下文，包含 props 信息
+*
+* 处理规则：
+* 1. 跳过成员表达式的属性部分（obj.property 中的 property）
+* 2. 跳过对象属性的 key 部分（{ key: value } 中的 key）
+* 3. 跳过声明位置（let foo = 1 中的 foo）
+* 4. 保留有效的局部变量（函数内的同名变量）
+* 5. 处理对象简写属性（{ foo } → { foo: __vmsProps.foo }）
+*/
+function replacePropsVariablesInAST(ast, sfcContext) {
+	const vmsPropsIdentifier = t.identifier(sfcContext.propsVarName);
+	traverse(ast, { Identifier(path) {
+		const name = path.node.name;
+		const parentNode = path.parentPath.node;
+		if (t.isTSTypeLiteral(parentNode) || t.isTSPropertySignature(parentNode) || t.isTSTypeReference(parentNode) || t.isTSInterfaceBody(parentNode) || t.isTSTypeAliasDeclaration(parentNode) || t.isTSTypeParameterInstantiation(parentNode) || t.isTSTypeAnnotation(parentNode)) return;
+		if (sfcContext.propsVarRestName && name === sfcContext.propsVarRestName) {
+			if (path.parentPath.isMemberExpression() && path.parentPath.node.property === path.node && !path.parentPath.node.computed || path.parentPath.isObjectProperty() && path.parentPath.node.key === path.node && !path.parentPath.node.computed) return;
+			if (path.isBindingIdentifier() && (path.parentPath.isVariableDeclarator() || path.parentPath.isFunctionDeclaration() || path.parentPath.isClassDeclaration() || path.parentPath.isCatchClause())) return;
+			if (path.scope.hasBinding(name)) {
+				const binding = path.scope.getBinding(name);
+				if (binding.path) {
+					if (!(binding.scope.block === ast) && !binding.path.removed) return;
+				}
+			}
+			path.replaceWith(t.cloneNode(vmsPropsIdentifier));
+			return;
+		}
+		if (path.parentPath.isMemberExpression() && path.parentPath.node.property === path.node && !path.parentPath.node.computed || path.parentPath.isOptionalMemberExpression() && path.parentPath.node.property === path.node && !path.parentPath.node.computed || path.parentPath.isObjectProperty() && path.parentPath.node.key === path.node && !path.parentPath.node.computed) return;
+		const propInfo = sfcContext.propsVarsMap.get(name);
+		if (!propInfo?.isDestructured) return;
+		if (path.isBindingIdentifier() && (path.parentPath.isVariableDeclarator() || path.parentPath.isFunctionDeclaration() || path.parentPath.isClassDeclaration() || path.parentPath.isCatchClause())) return;
+		if (path.scope.hasBinding(name)) {
+			const binding = path.scope.getBinding(name);
+			if (binding.path) {
+				if (!(binding.scope.block === ast) && !binding.path.removed) return;
+			}
+		}
+		const replacement = t.memberExpression(t.cloneNode(vmsPropsIdentifier), t.identifier(propInfo.originName));
+		if (path.parentPath.isObjectProperty() && path.parentPath.node.value === path.node && path.parentPath.node.shorthand) path.parentPath.node.shorthand = false;
+		path.replaceWith(replacement);
+	} });
+}
+//#endregion
+//#region src/script/macro/options.ts
+/**
+* 将 Babel AST 节点转换为普通 JS 值（仅支持字面量、数组、对象）
+*/
+function astToValue(node) {
+	if (t$1.isStringLiteral(node) || t$1.isNumericLiteral(node) || t$1.isBooleanLiteral(node)) return node.value;
+	if (t$1.isNullLiteral(node)) return null;
+	if (t$1.isArrayExpression(node)) return node.elements.map((el) => {
+		if (!el) return null;
+		if (t$1.isSpreadElement(el)) throw createCompileError("defineOptions 数组中不支持展开运算符", el.loc || void 0);
+		return astToValue(el);
+	});
+	if (t$1.isObjectExpression(node)) {
+		const obj = {};
+		for (const prop of node.properties) {
+			if (!t$1.isObjectProperty(prop)) throw createCompileError("defineOptions 对象中不支持方法或展开属性", prop.loc || void 0);
+			const key = t$1.isIdentifier(prop.key) ? prop.key.name : t$1.isStringLiteral(prop.key) ? prop.key.value : null;
+			if (key === null) throw createCompileError("defineOptions 对象的属性名必须是标识符或字符串", prop.loc || void 0);
+			obj[key] = astToValue(prop.value);
+		}
+		return obj;
+	}
+	throw createCompileError(`defineOptions 不支持动态值（如变量、函数调用等），请使用字面量。节点类型：${node.type}`, node.loc || void 0);
+}
+/**
+* 处理 defineOptions 宏，提取参数对象并移除调用节点
+*/
+function dealMacroOptions(path, expression) {
+	if (!t$1.isIdentifier(expression.callee) || expression.callee.name !== "defineOptions") return null;
+	if (!expression.arguments || expression.arguments.length === 0) {
+		path.remove();
+		return null;
+	}
+	const arg = expression.arguments[0];
+	if (!t$1.isObjectExpression(arg)) {
+		console.log(bold(red("defineOptions 的参数必须是对象字面量")));
+		path.remove();
+		return null;
+	}
+	const result = astToValue(arg);
+	path.remove();
+	return result;
+}
+//#endregion
+//#region src/script/collectImports.ts
+function collectImports(path, sfcContext) {
+	const source = path.node.source.value;
+	if (!source.endsWith(".vue")) {
+		if (source.endsWith(".ts") || source.endsWith(".js")) {
+			if (source.startsWith("@/") || source.startsWith("./") || source.startsWith("/") || source.startsWith("../")) path.node.source.value = source.replace(/\.(ts|js)$/, "");
+		}
+		sfcContext.importAST.push(path.node);
+	} else path.node.specifiers.forEach((specifier) => {
+		sfcContext.vueComponentImports.push({
+			name: specifier.local.name,
+			path: source,
+			importWay: `${specifier.local.name}`
+		});
+	});
+	path.remove();
+}
+//#endregion
+//#region src/utils/globalWhitelist.ts
+/**
+* 全局变量白名单
+* 这些变量不会被收集到 __vmsRenderState 或 __vmsInternalState
+*
+* 仅包含微信小程序运行时实际存在的全局标识符，
+* 不包含任何 Web / DOM / Node.js 专属 API。
+*/
+const GLOBAL_WHITELIST = new Set([
+	"wx",
+	"getApp",
+	"getCurrentPages",
+	"Page",
+	"Component",
+	"App",
+	"console",
+	"Math",
+	"Date",
+	"JSON",
+	"Object",
+	"Array",
+	"String",
+	"Number",
+	"Boolean",
+	"RegExp",
+	"Error",
+	"Promise",
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet",
+	"Symbol",
+	"BigInt",
+	"Proxy",
+	"Reflect",
+	"Intl",
+	"undefined",
+	"null",
+	"true",
+	"false",
+	"NaN",
+	"Infinity",
+	"-Infinity",
+	"parseInt",
+	"parseFloat",
+	"isNaN",
+	"isFinite",
+	"encodeURI",
+	"encodeURIComponent",
+	"decodeURI",
+	"decodeURIComponent",
+	"escape",
+	"unescape",
+	"eval",
+	"setTimeout",
+	"setInterval",
+	"clearTimeout",
+	"clearInterval",
+	"requestAnimationFrame",
+	"cancelAnimationFrame",
+	"ArrayBuffer",
+	"SharedArrayBuffer",
+	"DataView",
+	"Float32Array",
+	"Float64Array",
+	"Int8Array",
+	"Int16Array",
+	"Int32Array",
+	"Uint8Array",
+	"Uint16Array",
+	"Uint32Array",
+	"Uint8ClampedArray",
+	"URL",
+	"URLSearchParams",
+	"TextEncoder",
+	"TextDecoder"
+]);
+/**
+* 检查变量名是否在全局白名单中
+*/
+function isGlobalVariable(name) {
+	return GLOBAL_WHITELIST.has(name);
+}
+//#endregion
+//#region src/script/scopeAnalyzer.ts
+/**
+* Script 阶段作用域分析器
+* 收集脚本中声明的所有变量及其来源
+*/
+/**
+* 创建空的 ScriptScope
+*/
+function createEmptyScriptScope() {
+	return {
+		props: /* @__PURE__ */ new Map(),
+		macros: /* @__PURE__ */ new Map(),
+		imports: /* @__PURE__ */ new Map(),
+		declarations: /* @__PURE__ */ new Map(),
+		globals: /* @__PURE__ */ new Set()
+	};
+}
+/**
+* 分析脚本作用域
+* @param scriptContent script 内容
+* @param filePath 文件路径（用于错误信息展示）
+* @returns ScriptScope
+*/
+function analyzeScriptScope(scriptContent, filePath) {
+	const scope = createEmptyScriptScope();
+	try {
+		traverse(parse$1(scriptContent, {
+			sourceType: "module",
+			plugins: ["typescript"]
+		}), {
+			ImportDeclaration(path) {
+				path.node.specifiers.forEach((spec) => {
+					if (t$1.isImportSpecifier(spec) && t$1.isIdentifier(spec.imported)) {
+						const name = spec.local.name;
+						scope.imports.set(name, {
+							name,
+							source: {
+								type: "import",
+								accessPath: name,
+								originalName: spec.imported.name
+							}
+						});
+					} else if (t$1.isImportDefaultSpecifier(spec) || t$1.isImportNamespaceSpecifier(spec)) {
+						const name = spec.local.name;
+						scope.imports.set(name, {
+							name,
+							source: {
+								type: "import",
+								accessPath: name
+							}
+						});
+					}
+				});
+			},
+			VariableDeclaration(path) {
+				path.node.declarations.forEach((decl) => {
+					if (!t$1.isIdentifier(decl.id)) return;
+					const name = decl.id.name;
+					if (decl.init && t$1.isCallExpression(decl.init)) switch (t$1.isIdentifier(decl.init.callee) ? decl.init.callee.name : "") {
+						case "defineProps":
+							handleDefineProps(decl, scope);
+							return;
+						case "defineEmits":
+							handleDefineEmits(decl, scope);
+							return;
+						case "defineContext":
+							handleDefineContext(decl, scope);
+							return;
+					}
+					scope.declarations.set(name, {
+						name,
+						source: {
+							type: "declaration",
+							accessPath: "__vmsProxyRefs"
+						}
+					});
+				});
+			},
+			FunctionDeclaration(path) {
+				if (path.node.id) {
+					const name = path.node.id.name;
+					scope.declarations.set(name, {
+						name,
+						source: {
+							type: "declaration",
+							accessPath: "__vmsProxyRefs"
+						}
+					});
+				}
+			}
+		});
+	} catch (error) {
+		const loc = extractErrorLoc(error);
+		if (loc) {
+			const compileError = createCompileError(getErrorMessage(error), loc);
+			handleCompileError(scriptContent, compileError, filePath);
+			throw compileError;
+		}
+		console.error(`❌ Failed to parse script${filePath ? ` in ${filePath}` : ""}: ${getErrorMessage(error)}`);
+		throw error;
+	}
+	return scope;
+}
+/**
+* 处理 defineProps
+*/
+function handleDefineProps(decl, scope) {
+	if (t$1.isIdentifier(decl.id)) {
+		scope.propsVarName = decl.id.name;
+		return;
+	}
+	if (t$1.isObjectPattern(decl.id)) decl.id.properties.forEach((prop) => {
+		if (t$1.isRestElement(prop) && t$1.isIdentifier(prop.argument)) scope.propsRestName = prop.argument.name;
+		else if (t$1.isObjectProperty(prop)) {
+			const keyName = t$1.isIdentifier(prop.key) ? prop.key.name : "";
+			const valueName = t$1.isIdentifier(prop.value) ? prop.value.name : "";
+			if (keyName && valueName) scope.props.set(valueName, {
+				name: valueName,
+				source: {
+					type: "props",
+					accessPath: "__vmsProps",
+					originalName: keyName
+				}
+			});
+		}
+	});
+}
+/**
+* 处理 defineEmits
+*/
+function handleDefineEmits(decl, scope) {
+	if (t$1.isIdentifier(decl.id)) {
+		const name = decl.id.name;
+		scope.macros.set(name, {
+			name,
+			source: {
+				type: "macro",
+				accessPath: name
+			}
+		});
+	}
+}
+/**
+* 处理 defineContext
+*/
+function handleDefineContext(decl, scope) {
+	if (t$1.isIdentifier(decl.id)) {
+		const name = decl.id.name;
+		scope.macros.set(name, {
+			name,
+			source: {
+				type: "macro",
+				accessPath: name
+			}
+		});
+	}
+}
+/**
+* 判断变量是否是 props
+*/
+function isPropsVariable(name, scope) {
+	return scope.props.has(name);
+}
+/**
+* 判断变量是否是宏变量
+*/
+function isMacroVariable(name, scope) {
+	return scope.macros.has(name);
+}
+/**
+* 判断变量是否是导入的变量
+*/
+function isImportVariable(name, scope) {
+	return scope.imports.has(name);
+}
+/**
+* 判断变量是否是全局变量
+*/
+function isGlobalVariableInScope(name, scope) {
+	return scope.globals.has(name) || isGlobalVariable(name);
+}
+//#endregion
+//#region src/script/index.ts
+function checkSlotsUsage(templateContent) {
+	if (!templateContent) return false;
+	return templateContent.includes("slot") || templateContent.includes("Slot");
+}
+/**
+* 确保 @unmagic/vue-mini 中导入了指定的 specifierName。
+* 如果已存在则跳过，否则追加到已有的 @unmagic/vue-mini import 或新建一个。
+*/
+function ensureCoreImport(sfcContext, specifierName) {
+	if (sfcContext.importAST.some((importNode) => importNode.source.value === "@unmagic/vue-mini" && importNode.specifiers.some((spec) => t$1.isImportSpecifier(spec) && t$1.isIdentifier(spec.imported) && spec.imported.name === specifierName))) return;
+	const vueImport = sfcContext.importAST.find((importNode) => t$1.isImportDeclaration(importNode) && importNode.source.value === "@unmagic/vue-mini");
+	if (vueImport && t$1.isImportDeclaration(vueImport)) vueImport.specifiers.push(t$1.importSpecifier(t$1.identifier(specifierName), t$1.identifier(specifierName)));
+	else sfcContext.importAST.push(t$1.importDeclaration([t$1.importSpecifier(t$1.identifier(specifierName), t$1.identifier(specifierName))], t$1.stringLiteral("@unmagic/vue-mini")));
+}
+async function extractSetupBodyUsingAST(scriptContent, returnValue, bridgedFunctions, internalVars, renderVars, needsProxyRefs, isPage, scriptScope) {
+	let ast;
+	try {
+		ast = parse$1(scriptContent ?? "", {
+			sourceType: "module",
+			plugins: ["typescript"],
+			ranges: true,
+			tokens: true,
+			errorRecovery: true
+		});
+	} catch (error) {
+		console.error(`❌ Failed to parse script content: ${getErrorMessage(error)}`);
+		ast = {
+			type: "File",
+			program: {
+				type: "Program",
+				sourceType: "module",
+				directives: [],
+				body: []
+			}
+		};
+	}
+	const sfcContext = {
+		importAST: [],
+		propsVarName: "__vmsProps",
+		propsVarRestName: void 0,
+		contextVarName: "__vmsContext",
+		exposeObject: null,
+		defineOptionsObject: null,
+		vueComponentImports: [],
+		functionVarsAndDecl: /* @__PURE__ */ new Set(),
+		propsVarsMap: isPage ? /* @__PURE__ */ new Map() : new Map([["style", {
+			defaultValue: null,
+			originName: "style"
+		}]]),
+		macroInfoList: []
+	};
+	traverse(ast, {
+		ImportDeclaration(path) {
+			collectImports(path, sfcContext);
+		},
+		VariableDeclaration(path) {
+			const decl = path.node.declarations[0];
+			if (decl && decl.init && t$1.isCallExpression(decl.init)) switch (t$1.isIdentifier(decl.init.callee) ? decl.init.callee.name : "") {
+				case "defineContext":
+					if (t$1.isIdentifier(decl.id)) sfcContext.contextVarName = decl.id.name;
+					sfcContext.macroInfoList.push({
+						path,
+						decl,
+						type: "defineContext"
+					});
+					break;
+				case "defineProps":
+					sfcContext.macroInfoList.push({
+						path,
+						decl,
+						type: "defineProps"
+					});
+					break;
+				case "defineEmits":
+					sfcContext.macroInfoList.push({
+						path,
+						decl,
+						type: "defineEmits"
+					});
+					break;
+			}
+		},
+		FunctionDeclaration(path) {
+			const nodeName = path.node.id?.name;
+			if (nodeName) sfcContext.functionVarsAndDecl.add(nodeName);
+		},
+		ExpressionStatement(path) {
+			const expression = path.node.expression;
+			if (t$1.isCallExpression(expression) && t$1.isIdentifier(expression.callee)) {
+				if (expression.callee.name === "defineExpose") sfcContext.macroInfoList.push({
+					path,
+					expression,
+					type: "defineExpose"
+				});
+				else if (expression.callee.name === "defineOptions") sfcContext.macroInfoList.push({
+					path,
+					expression,
+					type: "defineOptions"
+				});
+			}
+		}
+	});
+	sfcContext.macroInfoList.forEach((item) => {
+		switch (item.type) {
+			case "defineContext":
+				item.path.remove();
+				break;
+			case "defineProps":
+				dealMacroProps(item.path, item.decl, sfcContext);
+				break;
+			case "defineEmits":
+				dealMacroEmits(item.path, item.decl, sfcContext.contextVarName);
+				break;
+			case "defineExpose":
+				sfcContext.exposeObject = createComponentExport(item.path, item.expression, returnValue);
+				break;
+			case "defineOptions":
+				sfcContext.defineOptionsObject = dealMacroOptions(item.path, item.expression);
+				break;
+		}
+	});
+	if ([...sfcContext.propsVarsMap.values()].some((v) => v.isDestructured) || sfcContext.propsVarRestName) {
+		replacePropsVariablesInAST(ast.program, sfcContext);
+		const aliasPropsToAdd = [];
+		let needsComputedImport = false;
+		returnValue.properties = returnValue.properties.filter((prop) => {
+			if (t$1.isObjectProperty(prop) && t$1.isIdentifier(prop.key) && prop.shorthand) {
+				const propInfo = sfcContext.propsVarsMap.get(prop.key.name);
+				if (propInfo?.isDestructured) {
+					if (propInfo.originName !== prop.key.name) {
+						needsComputedImport = true;
+						aliasPropsToAdd.push(t$1.objectProperty(t$1.identifier(prop.key.name), t$1.callExpression(t$1.identifier("computed"), [t$1.arrowFunctionExpression([], t$1.memberExpression(t$1.identifier(sfcContext.propsVarName), t$1.identifier(propInfo.originName)))])));
+					}
+					return false;
+				} else if (sfcContext.propsVarRestName === prop.key.name) {
+					aliasPropsToAdd.push(t$1.objectProperty(t$1.identifier(prop.key.name), t$1.identifier(sfcContext.propsVarName)));
+					return false;
+				}
+			}
+			return true;
+		});
+		returnValue.properties.push(...aliasPropsToAdd);
+		sfcContext.propsVarsMap.forEach((_, varName) => {
+			renderVars.delete(varName);
+			internalVars.delete(varName);
+		});
+		if (needsComputedImport) ensureCoreImport(sfcContext, "computed");
+	}
+	const setupBody = ast.program.body;
+	const hasInlineFunctions = returnValue.properties.some((prop) => t$1.isObjectProperty(prop) && t$1.isIdentifier(prop.key) && prop.key.name.startsWith("__fun_"));
+	const inlineFunctions = [];
+	const renderProperties = [];
+	const internalProperties = [];
+	const importProperties = [];
+	if (hasInlineFunctions) {
+		if (needsProxyRefs) ensureCoreImport(sfcContext, "proxyRefs");
+		const renderKeys = /* @__PURE__ */ new Set();
+		returnValue.properties.forEach((prop) => {
+			if (t$1.isObjectProperty(prop) && t$1.isIdentifier(prop.key)) {
+				if (!prop.key.name.startsWith("__fun_") && renderVars.has(prop.key.name)) renderKeys.add(prop.key.name);
+			}
+		});
+		const allPropsVarNames = new Set([...sfcContext.propsVarsMap.keys(), ...sfcContext.propsVarRestName ? [sfcContext.propsVarRestName] : []]);
+		if (allPropsVarNames.size > 0) returnValue.properties.forEach((prop) => {
+			if (t$1.isObjectProperty(prop) && t$1.isIdentifier(prop.key) && prop.key.name.startsWith("__fun_") && (t$1.isFunctionExpression(prop.value) || t$1.isArrowFunctionExpression(prop.value))) replacePropsAccessInFunction(prop.value, allPropsVarNames, sfcContext.propsVarName);
+		});
+		returnValue.properties.forEach((prop) => {
+			if (t$1.isObjectProperty(prop) && t$1.isIdentifier(prop.key) && prop.key.name.startsWith("__fun_")) inlineFunctions.push(prop);
+			else if (t$1.isObjectProperty(prop) && t$1.isIdentifier(prop.key) && internalVars.has(prop.key.name) && !renderKeys.has(prop.key.name)) internalProperties.push(prop);
+			else if (t$1.isObjectProperty(prop) && t$1.isIdentifier(prop.key) && scriptScope && isImportVariable(prop.key.name, scriptScope)) importProperties.push(prop);
+			else renderProperties.push(prop);
+		});
+		setupBody.forEach((statement) => {
+			if (t$1.isFunctionDeclaration(statement) && statement.id) {
+				if (bridgedFunctions.has(statement.id.name)) return;
+				const prop = t$1.objectProperty(t$1.identifier(statement.id.name), t$1.identifier(statement.id.name), false, true);
+				if (internalVars.has(statement.id.name) && !renderKeys.has(statement.id.name)) internalProperties.push(prop);
+				else renderProperties.push(prop);
+			}
+		});
+		const setupStateDecl = t$1.variableDeclaration("const", [t$1.variableDeclarator(t$1.identifier("__vmsRenderState"), t$1.objectExpression(renderProperties))]);
+		const hasInternalState = internalProperties.length > 0;
+		const inlineFunctionDecls = [];
+		inlineFunctions.forEach((prop) => {
+			const funcValue = prop.value;
+			const isArrow = t$1.isArrowFunctionExpression(funcValue);
+			const isFuncExpr = t$1.isFunctionExpression(funcValue);
+			if (isArrow || isFuncExpr) {
+				const funcName = prop.key.name;
+				const params = funcValue.params;
+				const body = funcValue.body;
+				const isAsync = funcValue.async || false;
+				const funcDecl = t$1.functionDeclaration(t$1.identifier(funcName), params, t$1.isBlockStatement(body) ? body : t$1.blockStatement([t$1.returnStatement(body)]), false, isAsync);
+				inlineFunctionDecls.push(funcDecl);
+				inlineFunctionDecls.push(t$1.expressionStatement(t$1.assignmentExpression("=", t$1.memberExpression(t$1.identifier("__vmsRenderState"), t$1.identifier(funcName)), t$1.identifier(funcName))));
+			}
+		});
+		setupBody.push(setupStateDecl);
+		if (hasInternalState) setupBody.push(t$1.variableDeclaration("const", [t$1.variableDeclarator(t$1.identifier("__vmsInternalState"), t$1.objectExpression(internalProperties))]));
+		if (needsProxyRefs) {
+			const proxyRefsArg = hasInternalState ? t$1.objectExpression([t$1.spreadElement(t$1.identifier("__vmsRenderState")), t$1.spreadElement(t$1.identifier("__vmsInternalState"))]) : t$1.identifier("__vmsRenderState");
+			setupBody.push(t$1.variableDeclaration("const", [t$1.variableDeclarator(t$1.identifier("__vmsProxyRefs"), t$1.callExpression(t$1.identifier("proxyRefs"), [proxyRefsArg]))]));
+		}
+		setupBody.push(...inlineFunctionDecls);
+		if (importProperties.length > 0) {
+			const returnObject = t$1.objectExpression([t$1.spreadElement(t$1.identifier("__vmsRenderState")), ...importProperties]);
+			setupBody.push(t$1.returnStatement(returnObject));
+		} else setupBody.push(t$1.returnStatement(t$1.identifier("__vmsRenderState")));
+	} else if (importProperties.length > 0) {
+		const nonImportProperties = returnValue.properties.filter((prop) => {
+			if (t$1.isObjectProperty(prop) && t$1.isIdentifier(prop.key)) return !(scriptScope && isImportVariable(prop.key.name, scriptScope));
+			return true;
+		});
+		const newReturnValue = t$1.objectExpression([...nonImportProperties, ...importProperties]);
+		setupBody.push(t$1.returnStatement(newReturnValue));
+	} else setupBody.push(t$1.returnStatement(returnValue));
+	return {
+		sfcContext,
+		setupFunAst: t$1.objectMethod("method", t$1.identifier("setup"), [t$1.identifier(sfcContext.propsVarName), t$1.identifier(sfcContext.contextVarName)], t$1.blockStatement(setupBody))
+	};
+}
+async function parseScript(descriptor, returnValue, bridgedFunctions = /* @__PURE__ */ new Set(), internalVars = /* @__PURE__ */ new Set(), renderVars = /* @__PURE__ */ new Set(), needsProxyRefs = false, isPage = false, scriptScope) {
+	const script = descriptor.scriptSetup?.content;
+	const hasSlots = checkSlotsUsage(descriptor.template?.content);
+	const { sfcContext, setupFunAst } = await extractSetupBodyUsingAST(script, returnValue, bridgedFunctions, internalVars, renderVars, needsProxyRefs, isPage, scriptScope);
+	const programBody = [t$1.importDeclaration([t$1.importSpecifier(t$1.identifier("defineComponent"), t$1.identifier("defineComponent"))], t$1.stringLiteral("@unmagic/vue-mini")), ...sfcContext.importAST];
+	const defineComponentParams = [t$1.objectProperty(t$1.identifier("behaviors"), t$1.arrayExpression([t$1.stringLiteral("wx://component-export")]))];
+	if (sfcContext.propsVarsMap.size > 0) defineComponentParams.push(t$1.objectProperty(t$1.identifier("properties"), t$1.objectExpression([...sfcContext.propsVarsMap].map(([_aliasName, { defaultValue, originName }]) => {
+		return t$1.objectProperty(t$1.identifier(originName), t$1.objectExpression(defaultValue ? [t$1.objectProperty(t$1.identifier("type"), t$1.nullLiteral()), t$1.objectProperty(t$1.identifier("value"), defaultValue)] : [t$1.objectProperty(t$1.identifier("type"), t$1.nullLiteral())]));
+	}))));
+	const optionsProperties = [];
+	if (hasSlots) optionsProperties.push(t$1.objectProperty(t$1.identifier("multipleSlots"), t$1.booleanLiteral(true)));
+	let isPushVirtualHost = false;
+	if (sfcContext.defineOptionsObject) {
+		if (Object.hasOwn(sfcContext.defineOptionsObject, "virtualHost")) {
+			const virtualHostVal = sfcContext.defineOptionsObject.virtualHost;
+			optionsProperties.push(t$1.objectProperty(t$1.identifier("virtualHost"), typeof virtualHostVal === "boolean" ? t$1.booleanLiteral(virtualHostVal) : t$1.valueToNode(virtualHostVal)));
+			isPushVirtualHost = true;
+			const { virtualHost: _removed, ...rest } = sfcContext.defineOptionsObject;
+			sfcContext.defineOptionsObject = Object.keys(rest).length > 0 ? rest : null;
+		}
+	}
+	if (!isPushVirtualHost && !isPage) optionsProperties.push(t$1.objectProperty(t$1.identifier("virtualHost"), t$1.booleanLiteral(true)));
+	if (optionsProperties.length > 0) defineComponentParams.push(t$1.objectProperty(t$1.identifier("options"), t$1.objectExpression(optionsProperties)));
+	if (!isPage && ![...sfcContext.propsVarsMap.values()].some((v) => v.originName === "class")) defineComponentParams.push(t$1.objectProperty(t$1.identifier("externalClasses"), t$1.arrayExpression([t$1.stringLiteral("class")])));
+	if (sfcContext.exposeObject) defineComponentParams.push(t$1.objectMethod("method", t$1.identifier("export"), [], t$1.blockStatement([t$1.returnStatement(sfcContext.exposeObject)])));
+	defineComponentParams.push(setupFunAst);
+	programBody.push(t$1.expressionStatement(t$1.callExpression(t$1.identifier("defineComponent"), [t$1.objectExpression(defineComponentParams)])));
+	return {
+		script: generate(t$1.program(programBody)).code,
+		vueComponentImports: sfcContext.vueComponentImports,
+		hasSlots,
+		sfcContext,
+		defineOptionsObject: sfcContext.defineOptionsObject
+	};
+}
+/**
+* 替换函数中的 props 变量访问
+* 将 __vmsProxyRefs.propName 替换为 __vmsProps.propName
+* 使用 Babel VISITOR_KEYS 进行正确的 AST 遍历，
+* 只访问有意义的子节点，避免遍历 Babel 内部属性。
+*/
+function replacePropsAccessInFunction(func, propsVarNames, propsVarName) {
+	function traverseNode(node) {
+		if (!node || typeof node !== "object") return;
+		if (t$1.isMemberExpression(node)) {
+			if (t$1.isIdentifier(node.object, { name: "__vmsProxyRefs" }) && t$1.isIdentifier(node.property) && propsVarNames.has(node.property.name)) node.object = t$1.identifier(propsVarName);
+		}
+		const visitorKeys = t$1.VISITOR_KEYS[node.type];
+		if (!visitorKeys) return;
+		for (const key of visitorKeys) {
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (const child of value) if (child && typeof child === "object" && Object.hasOwn(child, "type")) traverseNode(child);
+			} else if (value && typeof value === "object" && Object.hasOwn(value, "type")) traverseNode(value);
+		}
+	}
+	traverseNode(func);
+}
+//#endregion
+//#region src/utils/configLoader.ts
+async function loadUserConfig() {
+	for (const configFile of [
+		"vms.config.js",
+		"vms.config.ts",
+		"vms.config.mjs"
+	]) {
+		const configPath = resolve(configFile);
+		if (fs$1.existsSync(configPath)) try {
+			const config = await import(pathToFileURL(configPath).href);
+			return config.default || config.config;
+		} catch (error) {
+			console.warn(`配置文件 ${configFile} 加载失败:`, getErrorMessage(error));
+		}
+	}
+	return Promise.reject("未找到配置文件");
+}
+//#endregion
+//#region src/utils/componentMatcher.ts
+var ComponentMatcher = class {
+	prefix = "";
+	pathPrefix = "";
+	exactMatches = /* @__PURE__ */ new Map();
+	isConfigPrefix = false;
+	isConfigMatch = false;
+	constructor(config) {
+		if (config) {
+			if (!config.prefix && config.pathPrefix || config.prefix && !config.pathPrefix) throw new Error("请设置组件匹配的前缀和路径前缀");
+			if (config.prefix && config.pathPrefix) {
+				this.prefix = config.prefix;
+				this.pathPrefix = config.pathPrefix;
+				this.isConfigPrefix = true;
+			}
+			if (config.match?.length) {
+				config.match.forEach((item) => {
+					this.exactMatches.set(item.name, item.path);
+				});
+				this.isConfigMatch = true;
+			}
+		}
+	}
+	/**
+	* 根据组件名称匹配组件路径
+	* @param componentName 组件名称
+	* @returns 匹配的组件路径，如果没有匹配则返回null
+	*/
+	match(componentName) {
+		if (this.exactMatches.has(componentName)) return this.exactMatches.get(componentName) || null;
+		if (this.isConfigPrefix && componentName.startsWith(this.prefix)) {
+			const relativePath = componentName.slice(this.prefix.length);
+			const path = `${this.pathPrefix}/${relativePath}/${relativePath}`;
+			if (!this.exactMatches.has(componentName)) {
+				this.exactMatches.set(componentName, path);
+				this.isConfigMatch = true;
+			}
+			return path;
+		}
+		return null;
+	}
+	/**
+	* 检查是否存在任何匹配配置
+	*/
+	hasConfig() {
+		return this.isConfigPrefix || this.isConfigMatch;
+	}
+};
+//#endregion
+//#region src/utils/constants.ts
+const userConfig = await loadUserConfig();
+if (!userConfig.wx) throw new Error("请在vms.config.*s中配置完整的wx");
+process.env.APP_VERSION = userConfig.wx.version;
+if (!userConfig.sourceDir) userConfig.sourceDir = "src";
+if (!userConfig.outputDir) userConfig.outputDir = "dist";
+const OUTPUT_DIR = path.resolve(userConfig.outputDir, "dev");
+const POLYFILL_OUTPUT_DIR = path.resolve(OUTPUT_DIR, "polyfill");
+const getComponentMatcher = new ComponentMatcher(userConfig.component);
+function findPolyfillDirectory(baseDir) {
+	let polyfillPath = path.resolve(baseDir, "polyfill");
+	if (fs.existsSync(polyfillPath)) return polyfillPath;
+	polyfillPath = path.resolve(baseDir, "../../polyfill");
+	if (fs.existsSync(polyfillPath)) return polyfillPath;
+	throw new Error("找不到Polyfill文件夹");
+}
+const POLYFILL_VMS_DIR = findPolyfillDirectory(path.dirname(fileURLToPath(import.meta.url)));
+const WX_TAG_MAP = new Map([
+	["div", "view"],
+	["img", "image"],
+	["template", "block"]
+]);
+const WXS_NAMESPACE = "wms_wxs";
+//#endregion
+//#region src/utils/ast.ts
+/**
+* 获取表达式的AST，可解析 Typescript 语法
+* @param expression
+*/
+function getExpressionTSAst(expression) {
+	return parseExpression(expression, { plugins: ["typescript"] });
+}
+/**
+* 获取AST中，非父级v-for的变量
+* @param ast
+* @param vForVars
+*/
+function getIdentifiersWithoutVForVariables(ast, vForVars) {
+	try {
+		const identifiers = /* @__PURE__ */ new Set();
+		collectVariablesFromAST(ast, identifiers);
+		vForVars.forEach((vForVar) => identifiers.delete(vForVar));
+		return identifiers;
+	} catch (error) {
+		console.error(`❌ 解析表达式时出错: ${getErrorMessage(error)}`);
+		return /* @__PURE__ */ new Set();
+	}
+}
+/**
+* 从AST中收集变量
+* @param node
+* @param variables
+* @param excludedVars
+*/
+function collectVariablesFromAST(node, variables, excludedVars) {
+	if (!node) return;
+	switch (node.type) {
+		case "Identifier":
+			if (!excludedVars || !excludedVars.has(node.name)) variables.add(node.name);
+			break;
+		case "MemberExpression":
+			if (node.object.type === "Identifier") {
+				if (!excludedVars || !excludedVars.has(node.object.name)) variables.add(node.object.name);
+			} else collectVariablesFromAST(node.object, variables, excludedVars);
+			if (node.computed) collectVariablesFromAST(node.property, variables, excludedVars);
+			break;
+		case "OptionalMemberExpression":
+			if (node.object.type === "Identifier") {
+				if (!excludedVars || !excludedVars.has(node.object.name)) variables.add(node.object.name);
+			} else collectVariablesFromAST(node.object, variables, excludedVars);
+			if (node.computed) collectVariablesFromAST(node.property, variables, excludedVars);
+			break;
+		case "BinaryExpression":
+		case "LogicalExpression":
+			collectVariablesFromAST(node.left, variables, excludedVars);
+			collectVariablesFromAST(node.right, variables, excludedVars);
+			break;
+		case "UnaryExpression":
+			collectVariablesFromAST(node.argument, variables, excludedVars);
+			break;
+		case "ConditionalExpression":
+			collectVariablesFromAST(node.test, variables, excludedVars);
+			collectVariablesFromAST(node.consequent, variables, excludedVars);
+			collectVariablesFromAST(node.alternate, variables, excludedVars);
+			break;
+		case "CallExpression":
+		case "OptionalCallExpression":
+			collectVariablesFromAST(node.callee, variables, excludedVars);
+			node.arguments.forEach((arg) => collectVariablesFromAST(arg, variables, excludedVars));
+			if (node.callee && node.callee.type === "Identifier") {}
+			break;
+		case "FunctionDeclaration":
+		case "FunctionExpression":
+		case "ArrowFunctionExpression": {
+			const paramNames = /* @__PURE__ */ new Set();
+			const localVariables = excludedVars ?? /* @__PURE__ */ new Set();
+			if (node.params) node.params.forEach((param) => {
+				if (param.type === "Identifier") paramNames.add(param.name);
+				else if (param.type === "ObjectPattern") collectPatternVariables(param, paramNames);
+				else if (param.type === "ArrayPattern") collectPatternVariables(param, paramNames);
+			});
+			if (node.body) {
+				const functionBodyVariables = /* @__PURE__ */ new Set();
+				collectVariablesFromAST(node.body, functionBodyVariables, localVariables);
+				functionBodyVariables.forEach((variable) => {
+					if (!paramNames.has(variable) && !localVariables.has(variable)) variables.add(variable);
+				});
+			}
+			if (node.type === "FunctionDeclaration" && node.id && node.id.name) variables.add(node.id.name);
+			break;
+		}
+		case "VariableDeclaration":
+			node.declarations.forEach((declaration) => {
+				const localVariables = excludedVars ?? /* @__PURE__ */ new Set();
+				if (declaration.id.type !== "VoidPattern") collectPatternVariables(declaration.id, localVariables);
+				if (declaration.init) collectVariablesFromAST(declaration.init, variables, localVariables);
+			});
+			break;
+		case "BlockStatement":
+			if (node.body) node.body.forEach((statement) => {
+				collectVariablesFromAST(statement, variables, excludedVars);
+			});
+			break;
+		case "ReturnStatement":
+			if (node.argument) collectVariablesFromAST(node.argument, variables, excludedVars);
+			break;
+		case "ObjectExpression":
+			if (node.properties) node.properties.forEach((property) => {
+				if (property.type === "ObjectProperty") {
+					if (property.computed) collectVariablesFromAST(property.key, variables, excludedVars);
+					collectVariablesFromAST(property.value, variables, excludedVars);
+				} else if (property.type === "ObjectMethod") {
+					if (property.body) collectVariablesFromAST(property.body, variables, excludedVars);
+				} else if (property.type === "SpreadElement") collectVariablesFromAST(property.argument, variables, excludedVars);
+			});
+			break;
+		case "TemplateLiteral":
+			if (node.expressions) node.expressions.forEach((expr) => {
+				collectVariablesFromAST(expr, variables, excludedVars);
+			});
+			break;
+		case "TSAsExpression":
+		case "TSTypeAssertion":
+			collectVariablesFromAST(node.expression, variables, excludedVars);
+			break;
+		case "TSNonNullExpression":
+			collectVariablesFromAST(node.expression, variables, excludedVars);
+			break;
+		case "TSEnumDeclaration":
+			if (node.id && node.id.type === "Identifier") variables.add(node.id.name);
+			if (node.members) node.members.forEach((member) => {
+				if (member.initializer) collectVariablesFromAST(member.initializer, variables, excludedVars);
+			});
+			break;
+		case "TSInterfaceDeclaration":
+		case "TSTypeAliasDeclaration":
+			if (node.id && node.id.type === "Identifier") variables.add(node.id.name);
+			break;
+	}
+}
+function collectPatternVariables(pattern, variables) {
+	switch (pattern.type) {
+		case "Identifier":
+			variables.add(pattern.name);
+			break;
+		case "ObjectPattern":
+			pattern.properties.forEach((prop) => {
+				if (prop.type === "ObjectProperty") collectPatternVariables(prop.value, variables);
+				else if (prop.type === "RestElement") collectPatternVariables(prop.argument, variables);
+			});
+			break;
+		case "ArrayPattern":
+			pattern.elements.forEach((element) => {
+				if (element) collectPatternVariables(element, variables);
+			});
+			break;
+		case "RestElement":
+			collectPatternVariables(pattern.argument, variables);
+			break;
+	}
+}
+/**
+* 从模板的表达式AST中提取变量
+* @param ast
+* @return {string[]}
+*/
+function extractVariablesFromExpressionAST(ast) {
+	try {
+		const variables = /* @__PURE__ */ new Set();
+		collectVariablesFromAST(ast, variables);
+		GLOBAL_WHITELIST.forEach((builtIn) => variables.delete(builtIn));
+		return Array.from(variables);
+	} catch (e) {
+		console.warn("Failed to extract variables from expression:", ast.loc?.source, e);
+		return [];
+	}
+}
+//#endregion
+//#region src/template/tools.ts
+/**
+* 创建编译期上下文，每次 parseTemplate 调用时新建，不跨编译复用
+* @param scriptScope 可选的 ScriptScope，用于变量来源分析
+*/
+function createVMSTransformContext(scriptScope) {
+	return {
+		vForInfoMap: /* @__PURE__ */ new WeakMap(),
+		bridgedFunctions: /* @__PURE__ */ new Set(),
+		internalVars: /* @__PURE__ */ new Set(),
+		renderVars: /* @__PURE__ */ new Set(),
+		needsProxyRefs: false,
+		scriptScope,
+		rootElementNode: null
+	};
+}
+function setVForInfoList(ctx, node, list) {
+	ctx.vForInfoMap.set(node, list);
+}
+function getVForInfoList(ctx, node) {
+	return ctx.vForInfoMap.get(node);
+}
+/**
+* 获取或创建节点的 codegenNode
+* 节点自身持有 codegenNode，不再通过 ctx 存储
+*/
+function getCodegenNode(node) {
+	return node.__vmsCodegenNode;
+}
+/**
+* 获取或创建节点的 codegenNode 下的 Props
+* 节点自身持有 codegenNode，不再通过 ctx 存储
+*/
+function getCodegenNodeProps(node) {
+	return getCodegenNode(node)?.props ?? /* @__PURE__ */ new Map();
+}
+/**
+* 设置节点的 codegenNode
+* @param forceUpdate 是否强制更新 codegenNode
+*/
+function setCodegenNode(node, codegenNode) {
+	const existingCodegen = getCodegenNode(node);
+	if (existingCodegen?.tag?.startsWith("_vms_")) {
+		node.__vmsCodegenNode = codegenNode;
+		if (codegenNode) node.__vmsCodegenNode.tag = existingCodegen.tag;
+	} else node.__vmsCodegenNode = codegenNode;
+}
+/**
+* 判断是否为 v-for 属性
+* @param prop
+*/
+function isVForProp(prop) {
+	return prop.type === NodeTypes.DIRECTIVE && prop.rawName === "v-for";
+}
+/**
+* 判断节点是否为 v-for 节点
+* @param node
+*/
+function isVForNode(node) {
+	return node.props?.find(isVForProp);
+}
+/**
+* 收集第三方组件及小程序原生的自定义组件库
+* @param node
+* @param thirdPartyComponents
+*/
+function collectThirdComponents(node, thirdPartyComponents) {
+	const tag = node.tag;
+	if (node.type === 1) {
+		if (tag) {
+			const path = getComponentMatcher.match(tag);
+			if (path) thirdPartyComponents.set(tag, path);
+		}
+	}
+}
+/**
+* 添加返回值变量（内部路径，不标记为渲染变量）
+* @param {ObjectExpression} returnValue
+* @param {string} key
+*/
+function addProperty(returnValue, key) {
+	if (!returnValue.properties.some((p) => p.key.name === key)) {
+		const bindingVarId = t$1.identifier(key);
+		returnValue.properties.push(t$1.objectProperty(bindingVarId, bindingVarId, false, true));
+	}
+}
+/**
+* 添加返回值变量，并标记为模板直接绑定的渲染变量
+* @param {ObjectExpression} returnValue
+* @param {string} key
+* @param {VMSTransformContext} ctx
+*/
+/**
+* 检查变量是否应该被收集到 render state
+* 使用 scriptScope 进行变量来源分析
+* @returns 'render' | 'import' | 'skip' - 分别表示：收集到 renderVars、是导入变量、跳过
+*/
+function shouldCollectVariable(varName, scriptScope) {
+	if (!scriptScope) return "render";
+	if (isPropsVariable(varName, scriptScope)) return "skip";
+	if (isMacroVariable(varName, scriptScope)) return "skip";
+	if (isGlobalVariableInScope(varName, scriptScope)) return "skip";
+	if (isImportVariable(varName, scriptScope)) return "import";
+	return "render";
+}
+function addRenderProperty(returnValue, key, ctx) {
+	const collectType = shouldCollectVariable(key, ctx.scriptScope);
+	if (collectType === "skip") return;
+	addProperty(returnValue, key);
+	if (collectType === "render") ctx.renderVars.add(key);
+}
+/**
+* 根据表达式，收集setup的返回值变量，并排除掉指定的变量名称
+*/
+function collectBindingVarsWithExpression(expression, node, returnValue, ctx, excludedBindingVars = []) {
+	const extraBindingVars = getIdentifiersWithoutVForVariables(getExpressionTSAst(expression), getVForVariables(ctx, node));
+	excludedBindingVars.forEach((item) => extraBindingVars.delete(item));
+	extraBindingVars.forEach((bindingVar) => {
+		addRenderProperty(returnValue, bindingVar, ctx);
+	});
+}
+/**
+* 根据AST，收集setup的返回值变量，并排除掉指定的变量名称
+* 现在使用 scriptScope 进行更精确的变量来源分析
+*/
+function collectBindingVarsWithAST(ast, node, returnValue, ctx, excludedBindingVars = []) {
+	const extraBindingVars = getIdentifiersWithoutVForVariables(ast, getVForVariables(ctx, node));
+	excludedBindingVars.forEach((item) => extraBindingVars.delete(item));
+	extraBindingVars.forEach((varName) => {
+		if (shouldCollectVariable(varName, ctx.scriptScope) === "skip") return;
+		addRenderProperty(returnValue, varName, ctx);
+	});
+}
+/**
+* 根据变量名，收集setup的返回值变量
+*/
+function collectBindingVarsWithVarName(varName, node, returnValue, ctx) {
+	if (getVForVariables(ctx, node).has(varName)) return;
+	addRenderProperty(returnValue, varName, ctx);
+}
+/**
+* 根据变量名列表，收集setup的返回值变量
+*/
+function collectBindingVarsWithVarNameList(varNameList, node, returnValue, ctx) {
+	const vForVars = getVForVariables(ctx, node);
+	varNameList.filter((item) => !vForVars.has(item)).forEach((varName) => addRenderProperty(returnValue, varName, ctx));
+}
+/**
+* WXS 环境中可安全调用的全局标识符白名单
+*/
+const WXS_SAFE_GLOBALS = new Set([
+	"String",
+	"Number",
+	"Boolean",
+	"parseInt",
+	"parseFloat",
+	"isNaN",
+	"isFinite",
+	"Math",
+	"Date",
+	"JSON"
+]);
+/**
+* 检查调用表达式是否包含外部函数调用
+* @param node
+* @returns {boolean}
+*/
+function containsExternalFunctionCall(node) {
+	if (node.callee?.type === "Identifier") {
+		if (WXS_SAFE_GLOBALS.has(node.callee.name)) return false;
+		return true;
+	}
+	return false;
+}
+/**
+* 检查表达式AST中是否包含外部函数调用
+* @param ast
+* @returns {boolean}
+*/
+function containsExternalFunctionInExpression(ast) {
+	if (!ast) return false;
+	let hasExternalFunction = false;
+	function traverse(node) {
+		if (!node || hasExternalFunction) return;
+		if (node.type === "CallExpression") {
+			if (containsExternalFunctionCall(node)) {
+				hasExternalFunction = true;
+				return;
+			}
+		}
+		for (const key in node) if (Object.prototype.hasOwnProperty.call(node, key)) {
+			const child = node[key];
+			if (typeof child === "object" && child !== null) if (Array.isArray(child)) child.forEach(traverse);
+			else traverse(child);
+		}
+	}
+	traverse(ast);
+	return hasExternalFunction;
+}
+/**
+* 检查表达式是否为复杂表达式
+* @param ast
+* @returns {boolean}
+*/
+function isComplexExpression(ast) {
+	if (!ast) return false;
+	switch (ast.type) {
+		case "StringLiteral":
+		case "NumericLiteral":
+		case "BooleanLiteral":
+		case "Identifier":
+		case "NullLiteral": return false;
+		case "ConditionalExpression": return true;
+		case "UnaryExpression":
+			if (ast.operator === "typeof") return true;
+			return isComplexExpression(ast.argument);
+		case "BinaryExpression": return isComplexExpression(ast.left) || isComplexExpression(ast.right);
+		case "MemberExpression": return isComplexExpression(ast.object) || isComplexExpression(ast.property);
+		case "OptionalMemberExpression": return true;
+		case "CallExpression": return true;
+		default: return true;
+	}
+}
+/**
+* 获取v-for变量集合（从 WeakMap context 读取）
+*/
+function getVForVariables(ctx, node) {
+	const variables = /* @__PURE__ */ new Set();
+	const list = ctx.vForInfoMap.get(node);
+	if (!list) return variables;
+	for (const vForInfo of list) {
+		const parseResult = vForInfo.forParseResult;
+		if (parseResult.value?.type === NodeTypes.SIMPLE_EXPRESSION) variables.add(parseResult.value.content);
+		if (parseResult.key?.type === NodeTypes.SIMPLE_EXPRESSION) variables.add(parseResult.key.content);
+	}
+	return variables;
+}
+/**
+* 极简内存优化的v-for信息分配，写入 WeakMap 而非原始 AST 节点
+*
+* ⚠️  **必须在 `traverseNode` 之前调用**（即在 createTransformContext/traverseNode 之前）。
+*
+* 原因：此函数对整棵 AST 树做一次前序遍历，将每个节点的祖先 v-for 上下文信息
+* 预填充到 `ctx.vForInfoMap` 中。后续的 nodeTransforms（如 transformVForProp、
+* transformKeyProp 等）在运行时会通过 `getVForInfoList(ctx, node)` 读取这些信息。
+*
+* 如果在 `traverseNode` 之后调用，或根本未调用，v-for 相关的转换器将读取到空数据，
+* 导致嵌套 v-for 的 item/index 变量名计算错误。
+*
+* 调用示例（正确顺序）：
+* ```ts
+* assignVForInfoListMinimal(templateAST, ctx)  // ← 必须第一步
+* const context = createTransformContext(templateAST, { nodeTransforms })
+* traverseNode(templateAST, context)
+* ```
+*/
+function assignVForInfoListMinimal(rootNode, ctx) {
+	if (!rootNode) return;
+	const stack = [];
+	stack.push({
+		node: rootNode,
+		parentVForInfoList: void 0,
+		hasVForInAncestry: false
+	});
+	while (stack.length > 0) {
+		const { node, parentVForInfoList, hasVForInAncestry } = stack.pop();
+		const vFor = isVForNode(node);
+		if (vFor && vFor.type === NodeTypes.DIRECTIVE && vFor.forParseResult) {
+			const vForInfo = {
+				forParseResult: vFor.forParseResult,
+				depth: parentVForInfoList ? parentVForInfoList.length : 0,
+				parent: parentVForInfoList?.length ? parentVForInfoList[parentVForInfoList.length - 1] : void 0
+			};
+			const newVForInfoList = parentVForInfoList ? [...parentVForInfoList, vForInfo] : [vForInfo];
+			setVForInfoList(ctx, node, newVForInfoList);
+			const children = node.children;
+			if (Array.isArray(children)) for (let i = children.length - 1; i >= 0; i--) stack.push({
+				node: children[i],
+				parentVForInfoList: newVForInfoList,
+				hasVForInAncestry: true
+			});
+		} else {
+			if (hasVForInAncestry && parentVForInfoList) setVForInfoList(ctx, node, parentVForInfoList);
+			const children = node.children;
+			if (Array.isArray(children)) for (let i = children.length - 1; i >= 0; i--) stack.push({
+				node: children[i],
+				parentVForInfoList,
+				hasVForInAncestry
+			});
+		}
+	}
+}
+function isNotMergeProps(prop) {
+	return prop.name !== "style" && prop.name !== "class";
+}
+//#endregion
+//#region src/template/generator.ts
+function createAttr(prop, key) {
+	return typeof prop?.content === "undefined" ? ` ${key}` : ` ${key}="${prop.content}"`;
+}
+var WXMLGenerator = class {
+	code;
+	indentLevel;
+	indent;
+	constructor() {
+		this.code = [];
+		this.indentLevel = 0;
+		this.indent = "  ";
+	}
+	generate(wxsScripts, ast) {
+		this.code.splice(0, this.code.length);
+		if (wxsScripts) this.code.push(wxsScripts);
+		this.indentLevel = 0;
+		const rootCodegen = getCodegenNode(ast);
+		if (rootCodegen?.children) rootCodegen.children.forEach((child, index) => {
+			this.traverseCodegenNode(child);
+			if (index < rootCodegen.children.length - 1) this.code.push("\n");
+		});
+		return this.code.join("");
+	}
+	/**
+	* 遍历 codegenNode 生成 WXML
+	*/
+	traverseCodegenNode(node) {
+		if (!node) return;
+		switch (node.type) {
+			case NodeTypes.ELEMENT:
+				this.generateElement(node);
+				break;
+			case NodeTypes.TEXT:
+			case NodeTypes.COMMENT:
+			case NodeTypes.INTERPOLATION:
+				this.generateLeafNode(node);
+				break;
+			default: break;
+		}
+	}
+	/**
+	* 生成元素节点（基于 codegenNode）
+	*/
+	generateElement(node) {
+		const indentation = this.indent.repeat(this.indentLevel);
+		const tag = node.tag && WX_TAG_MAP.has(node.tag) ? WX_TAG_MAP.get(node.tag) : node.tag || "";
+		if (tag === "block" && (!node.props || node.props.size === 0)) {
+			node.children?.forEach((child) => {
+				this.traverseCodegenNode(child);
+			});
+			return;
+		}
+		this.code.push(`${indentation}<${tag}`);
+		this.generateProps(node.props);
+		if (node.children && node.children.length > 0) {
+			this.code.push(">");
+			const isNeedIndent = this.shouldIndentChildren(node);
+			if (isNeedIndent) {
+				this.code.push("\n");
+				this.indentLevel++;
+			}
+			node.children.forEach((child, index) => {
+				this.traverseCodegenNode(child);
+				if (isNeedIndent && index < node.children.length - 1) this.code.push("\n");
+			});
+			if (isNeedIndent) {
+				this.indentLevel--;
+				this.code.push(`\n${indentation}`);
+			}
+			this.code.push(`</${tag}>`);
+		} else this.code.push(" />");
+	}
+	/**
+	* 生成属性列表
+	*/
+	generateProps(props) {
+		if (!props) return;
+		props.forEach((prop, key) => {
+			this.code.push(createAttr(prop, key));
+		});
+	}
+	generateLeafNode(node) {
+		this.code.push(node.content || "");
+	}
+	shouldIndentChildren(node) {
+		return !node.children?.every((child) => child.type === NodeTypes.TEXT || child.type === NodeTypes.INTERPOLATION);
+	}
+};
+function generateWxml(wxsScripts, ast) {
+	return new WXMLGenerator().generate(wxsScripts, ast);
+}
+//#endregion
+//#region src/template/nodeProps/slot.ts
+function transformSlotsAndTemplate(node) {
+	if (node.type !== NodeTypes.ELEMENT || node.tag !== "template" || !node.props) return;
+	const templateNode = node;
+	const slotProp = templateNode.props.find((p) => p.type === NodeTypes.DIRECTIVE && p.name === "slot");
+	if (slotProp) {
+		if (slotProp.exp) throw createCompileError("暂不支持作用域插槽(v-slot)编译为小程序，请改为在父组件中直接使用数据渲染列表 / 条件。", slotProp.loc);
+		if (slotProp.arg?.type === NodeTypes.SIMPLE_EXPRESSION) {
+			const slotName = slotProp.arg.content;
+			processNamedSlot(templateNode, slotName, slotProp);
+		}
+	} else transformToBlock(templateNode);
+}
+function processNamedSlot(node, slotName, slotProp) {
+	if (node.children.length === 0) {
+		setCodegenNode(node, {
+			type: NodeTypes.COMMENT,
+			content: `因${slotName}插槽下没有子节点，已被替换为注释节点`
+		});
+		return;
+	}
+	for (const child of node.children) if (child.type === NodeTypes.TEXT) throw createCompileError(`插槽${slotName}下需使用div等标签元素作为子节点！`, slotProp.loc);
+	else if (child.type === NodeTypes.ELEMENT) createChildWithMergedProps(child, slotName);
+	transformToBlock(node);
+}
+function transformToBlock(node) {
+	const forDirective = isVForNode(node);
+	if (!forDirective || forDirective.type !== NodeTypes.DIRECTIVE || !forDirective.forParseResult) {
+		const filteredProps = new Map(node.props.filter((item) => item.type === NodeTypes.ATTRIBUTE && item.name !== "slot").map((p) => [p.name, p.value]));
+		setCodegenNode(node, {
+			type: NodeTypes.ELEMENT,
+			tag: node.tag,
+			props: filteredProps,
+			children: [],
+			loc: node.loc
+		});
+	}
+}
+function createChildWithMergedProps(childNode, slotName) {
+	const mergedProps = childNode.props ? new Map(childNode.props?.filter((p) => p.type === NodeTypes.ATTRIBUTE && isNotMergeProps(p)).map((p) => [p.name, p.value])) : /* @__PURE__ */ new Map();
+	if (slotName !== "default") mergedProps.set("slot", { content: slotName });
+	setCodegenNode(childNode, {
+		type: childNode.type,
+		tag: childNode.tag,
+		props: mergedProps,
+		children: [],
+		loc: childNode.loc
+	});
+}
+//#endregion
+//#region src/utils/tools.ts
+/**
+* 从 VForInfo 中提取 item 名称
+*/
+function getVForItemName(vForInfo) {
+	const forParseResult = vForInfo.forParseResult;
+	if (forParseResult.value && forParseResult.value.type === NodeTypes.SIMPLE_EXPRESSION) return forParseResult.value.content;
+	return "";
+}
+/**
+* 从 VForInfo 中提取 index 名称
+*/
+function getVForIndexName(vForInfo) {
+	const forParseResult = vForInfo.forParseResult;
+	if (forParseResult.key && forParseResult.key.type === NodeTypes.SIMPLE_EXPRESSION) return forParseResult.key.content;
+}
+/**
+* 从 VForInfo 中提取源表达式
+*/
+function getVForSourceExpression(vForInfo) {
+	const forParseResult = vForInfo.forParseResult;
+	if (forParseResult.source && forParseResult.source.type === NodeTypes.SIMPLE_EXPRESSION) return forParseResult.source.content;
+	return "";
+}
+/**
+* 添加polyfill文件复制功能
+*/
+async function copyPolyfillFiles() {
+	try {
+		if (await fs$1.pathExists(POLYFILL_VMS_DIR)) {
+			if (await fs$1.pathExists(POLYFILL_OUTPUT_DIR)) return;
+			await fs$1.copy(POLYFILL_VMS_DIR, POLYFILL_OUTPUT_DIR);
+		} else console.log(red("Polyfill源文件夹不存在：" + POLYFILL_VMS_DIR));
+	} catch (error) {
+		console.error(red("❌ 复制polyfill文件失败：" + getErrorMessage(error)));
+	}
+}
+/**
+* 获取polyfill文件在当前文件的相对路径
+* @param polyfillFileName polyfill文件名
+* @param filePath 当前文件路径
+*/
+function getPolyfillFileRelativePath(polyfillFileName, filePath) {
+	return path.relative(path.dirname(filePath.replace(userConfig.sourceDir, OUTPUT_DIR)), path.join(OUTPUT_DIR, "polyfill", polyfillFileName)).split(path.sep).join("/");
+}
+function copyProjectConfigFile() {
+	return fs$1.readJson(path.join(process.cwd(), "project.config.json")).then((config) => {
+		Reflect.deleteProperty(config, "miniprogramRoot");
+		Reflect.deleteProperty(config, "srcMiniprogramRoot");
+		config.projectName = config.projectName + "-dev";
+		return fs$1.writeFile(path.join(OUTPUT_DIR, "project.config.json"), JSON.stringify(config, null, 2));
+	});
+}
+//#endregion
+//#region src/template/nodeProps/eventHelpers.ts
+const EVENT_PARAM_NAME = "__vms_event";
+/**
+* 生成函数索引字符
+*/
+function getFunctionIndexChar(index) {
+	let result = "";
+	let num = index;
+	while (num >= 0) {
+		result = String.fromCharCode(97 + num % 26) + result;
+		num = Math.floor(num / 26) - 1;
+		if (num < 0) break;
+	}
+	return result;
+}
+/**
+* 构建从 __vmsProxyRefs 或 __vmsProps 访问 v-for item 的表达式
+* 例：__vmsProxyRefs.statCards[_statCards_index]
+* 嵌套 v-for 例：__vmsProxyRefs.props.fields[_fields_index].stringKey[_stringKey__index]
+* 复杂 source 例：__vmsProxyRefs.groupedSelectedItemsMap[field.stringKey][_stringKey__index]
+*
+* 对于复杂的 source 表达式（如 groupedSelectedItemsMap[field.stringKey]），
+* 返回的表达式会依赖之前已声明的 v-for item 变量
+* 现在支持 scriptScope 来判断 source 中的变量是否是 props
+*/
+function buildProxyRefsItemAccess(vForInfoList, targetItemIndex, scriptScope, useProxyRefsBase = false) {
+	const indices = vForInfoList.map((info) => getVForIndexName(info) || "index");
+	const targetInfo = vForInfoList[targetItemIndex];
+	const sourceExpr = getVForSourceExpression(targetInfo);
+	const outerVForItems = vForInfoList.slice(0, targetItemIndex);
+	const outerVForItemNames = new Set(outerVForItems.map((info) => getVForItemName(info)));
+	const bracketParts = sourceExpr.split("[");
+	const firstPart = bracketParts[0];
+	const firstPartProps = firstPart ? firstPart.split(".") : [];
+	const firstProp = firstPartProps[0];
+	let expr;
+	if (useProxyRefsBase) {
+		expr = t.identifier("__vmsProxyRefs");
+		for (const prop of firstPartProps) expr = t.memberExpression(expr, t.identifier(prop));
+	} else if (firstProp && outerVForItemNames.has(firstProp)) {
+		expr = t.identifier(firstProp);
+		for (let i = 1; i < firstPartProps.length; i++) expr = t.memberExpression(expr, t.identifier(firstPartProps[i]));
+	} else if (firstProp && scriptScope?.props.has(firstProp)) {
+		const propsVarName = scriptScope.propsVarName || "__vmsProps";
+		expr = t.identifier(propsVarName);
+		for (const prop of firstPartProps) expr = t.memberExpression(expr, t.identifier(prop));
+	} else {
+		expr = t.identifier("__vmsProxyRefs");
+		for (const prop of firstPartProps) expr = t.memberExpression(expr, t.identifier(prop));
+	}
+	for (let i = 1; i < bracketParts.length; i++) {
+		const part = bracketParts[i];
+		const indexContent = part.endsWith("]") ? part.slice(0, -1) : part;
+		const indexParts = indexContent.split(".");
+		const firstIndexPart = indexParts[0];
+		if (outerVForItemNames.has(firstIndexPart)) {
+			let indexExpr = t.identifier(firstIndexPart);
+			for (let j = 1; j < indexParts.length; j++) indexExpr = t.memberExpression(indexExpr, t.identifier(indexParts[j]));
+			expr = t.memberExpression(expr, indexExpr, true);
+		} else expr = t.memberExpression(expr, t.identifier(indexContent), true);
+	}
+	expr = t.memberExpression(expr, t.identifier(indices[targetItemIndex]), true);
+	return expr;
+}
+/**
+* 将一个调用参数 AST 节点转换为桥接函数内的访问表达式：
+* - v-for item 标识符 → __vmsProxyRefs.list[index]
+* - v-for item 成员表达式（card.id）→ __vmsProxyRefs.list[index].id
+* - props 变量 → __vmsProps.varName
+* - 外部变量标识符 → __vmsProxyRefs.varName
+* - $event / __vms_event → __vms_event
+* - 字面量 / 其他 → 原样保留
+* 现在支持 scriptScope 进行变量来源分析
+*/
+function buildProxyRefsArgument(arg, vForInfoList, vForItemNames, arrowFunctionArgumentNames, localVarNames, scriptScope) {
+	if (t.isSpreadElement(arg)) return arg;
+	if (t.isIdentifier(arg)) {
+		if (arg.name === "$event" || arg.name === "__vms_event") return t.identifier(EVENT_PARAM_NAME);
+		if (localVarNames && localVarNames.has(arg.name)) return arg;
+		if (vForInfoList && vForItemNames.has(arg.name)) {
+			const itemIndex = vForInfoList.findIndex((info) => getVForItemName(info) === arg.name);
+			if (itemIndex !== -1) return buildProxyRefsItemAccess(vForInfoList, itemIndex, scriptScope);
+		}
+		if (arrowFunctionArgumentNames && arrowFunctionArgumentNames.has(arg.name)) return t.memberExpression(t.identifier(EVENT_PARAM_NAME), t.identifier("detail"));
+		if (vForInfoList) {
+			if (vForInfoList.map((info) => getVForIndexName(info) || "index").includes(arg.name)) return arg;
+		}
+		if (scriptScope?.props.has(arg.name)) {
+			const propsVarName = scriptScope.propsVarName || "__vmsProps";
+			return t.memberExpression(t.identifier(propsVarName), t.identifier(arg.name));
+		}
+		return t.memberExpression(t.identifier("__vmsProxyRefs"), t.identifier(arg.name));
+	}
+	if (t.isOptionalMemberExpression(arg)) {
+		const processedObject = buildProxyRefsArgument(arg.object, vForInfoList, vForItemNames, arrowFunctionArgumentNames, localVarNames, scriptScope);
+		return t.optionalMemberExpression(processedObject, arg.property, arg.computed, arg.optional);
+	}
+	if (t.isMemberExpression(arg)) {
+		const processedObject = buildProxyRefsArgument(arg.object, vForInfoList, vForItemNames, arrowFunctionArgumentNames, localVarNames, scriptScope);
+		return t.memberExpression(processedObject, arg.property, arg.computed);
+	}
+	if (t.isObjectExpression(arg)) {
+		const processedProperties = arg.properties.map((prop) => {
+			if (t.isObjectProperty(prop)) {
+				const processedValue = buildProxyRefsArgument(prop.value, vForInfoList, vForItemNames, arrowFunctionArgumentNames, localVarNames);
+				return t.objectProperty(prop.key, processedValue, prop.computed);
+			}
+			return prop;
+		});
+		return t.objectExpression(processedProperties);
+	}
+	if (t.isTSAsExpression(arg)) {
+		const processedExpression = buildProxyRefsArgument(arg.expression, vForInfoList, vForItemNames, arrowFunctionArgumentNames, localVarNames, scriptScope);
+		return t.tsAsExpression(processedExpression, arg.typeAnnotation);
+	}
+	if (t.isTSNonNullExpression(arg)) {
+		const processedExpression = buildProxyRefsArgument(arg.expression, vForInfoList, vForItemNames, arrowFunctionArgumentNames, localVarNames, scriptScope);
+		return t.tsNonNullExpression(processedExpression);
+	}
+	if (t.isArrayExpression(arg)) {
+		const processedElements = arg.elements.map((el) => {
+			if (el === null) return null;
+			return buildProxyRefsArgument(el, vForInfoList, vForItemNames, arrowFunctionArgumentNames, localVarNames, scriptScope);
+		});
+		return t.arrayExpression(processedElements);
+	}
+	if (t.isConditionalExpression(arg)) return t.conditionalExpression(buildProxyRefsArgument(arg.test, vForInfoList, vForItemNames, arrowFunctionArgumentNames, localVarNames, scriptScope), buildProxyRefsArgument(arg.consequent, vForInfoList, vForItemNames, arrowFunctionArgumentNames, localVarNames, scriptScope), buildProxyRefsArgument(arg.alternate, vForInfoList, vForItemNames, arrowFunctionArgumentNames, localVarNames, scriptScope));
+	if (t.isLogicalExpression(arg)) return t.logicalExpression(arg.operator, buildProxyRefsArgument(arg.left, vForInfoList, vForItemNames, arrowFunctionArgumentNames, localVarNames, scriptScope), buildProxyRefsArgument(arg.right, vForInfoList, vForItemNames, arrowFunctionArgumentNames, localVarNames, scriptScope));
+	return arg;
+}
+/**
+* 解析需要声明为局部变量的 v-for item 集合
+* 从种子 item 出发，递归检查每个 item 的 source 是否依赖其他 v-for item，
+* 将所有依赖项也加入集合（确保声明顺序正确）
+*/
+function resolveItemsToDeclare(seedItems, vForInfoList) {
+	const itemsToDeclare = new Set(seedItems);
+	let changed = true;
+	while (changed) {
+		changed = false;
+		vForInfoList.forEach((info) => {
+			const name = getVForItemName(info);
+			if (name && itemsToDeclare.has(name)) {
+				const sourceFirstPart = getVForSourceExpression(info).split(/[.[]/)[0];
+				if (sourceFirstPart) {
+					if (vForInfoList.find((i) => getVForItemName(i) === sourceFirstPart) && !itemsToDeclare.has(sourceFirstPart)) {
+						itemsToDeclare.add(sourceFirstPart);
+						changed = true;
+					}
+				}
+			}
+		});
+	}
+	return itemsToDeclare;
+}
+/**
+* 按 v-for 嵌套顺序将需要的 item 声明推入 statements
+* 外层先声明，确保内层可以引用外层 item
+*/
+function declareVForItems(itemsToDeclare, vForInfoList, statements, scriptScope) {
+	vForInfoList.forEach((info, idx) => {
+		const name = getVForItemName(info);
+		if (name && itemsToDeclare.has(name)) {
+			const expr = buildProxyRefsItemAccess(vForInfoList, idx, scriptScope);
+			statements.push(t.variableDeclaration("const", [t.variableDeclarator(t.identifier(name), expr)]));
+		}
+	});
+}
+/**
+* 从 dataset 解构 v-for 索引并推入 statements
+*/
+function declareDatasetIndices(dataKey, vForInfoList, statements) {
+	const indexVars = vForInfoList.map((info) => getVForIndexName(info) || "index").map((idx) => t.identifier(idx));
+	statements.push(t.variableDeclaration("const", [t.variableDeclarator(t.objectPattern([t.objectProperty(t.identifier(dataKey), t.arrayPattern(indexVars), false, false)]), t.memberExpression(t.memberExpression(t.identifier(EVENT_PARAM_NAME), t.identifier("currentTarget")), t.identifier("dataset")))]));
+}
+/**
+* 生成通过 __vmsProxyRefs 访问 v-for item 方法的桥接函数体
+* data-a 只传 v-for 索引，item 和参数均从 __vmsProxyRefs 取
+* 现在支持 scriptScope 来判断变量是否是 props
+*/
+function getASTWithVForItemFromProxyRefs(dataKey, calleeAst, argumentsAst, vForInfoList, arrowFunctionArgumentNames, scriptScope) {
+	const vForItemNames = new Set(vForInfoList.map((info) => getVForItemName(info)).filter(Boolean));
+	const itemName = calleeAst.object.name;
+	const statements = [];
+	declareDatasetIndices(dataKey, vForInfoList, statements);
+	declareVForItems(resolveItemsToDeclare([itemName], vForInfoList), vForInfoList, statements, scriptScope);
+	const localVarNames = new Set([itemName]);
+	let callArgs;
+	if (!argumentsAst || argumentsAst.length === 0) callArgs = [t.identifier(EVENT_PARAM_NAME)];
+	else callArgs = argumentsAst.map((arg) => buildProxyRefsArgument(arg, vForInfoList, vForItemNames, arrowFunctionArgumentNames, localVarNames, scriptScope));
+	statements.push(t.returnStatement(t.callExpression(t.memberExpression(t.identifier(itemName), calleeAst.property, calleeAst.computed), callArgs)));
+	return t.blockStatement(statements);
+}
+/**
+* 生成通过 __vmsProxyRefs 访问外部变量的桥接函数体（非 v-for 场景）
+* 如果在 v-for 中，data-a 传递索引，桥接函数中需要从 dataset 解构索引
+* 现在支持 scriptScope 来判断变量是否是 props
+*/
+function getASTWithoutVForItemFromProxyRefs(calleeAst, argumentsAst, arrowFunctionArgumentNames, vForInfoList, vForItemNames, dataKey, shouldPassIndices, scriptScope) {
+	const effectiveVForItemNames = vForItemNames || /* @__PURE__ */ new Set();
+	const statements = [];
+	const usedVForItems = /* @__PURE__ */ new Set();
+	function collectVForItems(node) {
+		if (!node) return;
+		if (t.isIdentifier(node) && effectiveVForItemNames.has(node.name)) usedVForItems.add(node.name);
+		else if (t.isMemberExpression(node)) collectVForItems(node.object);
+		else if (t.isObjectExpression(node)) node.properties.forEach((prop) => {
+			if (t.isObjectProperty(prop)) collectVForItems(prop.value);
+		});
+		else if (t.isArrayExpression(node)) node.elements.forEach((el) => collectVForItems(el));
+	}
+	if (argumentsAst && vForInfoList && effectiveVForItemNames.size > 0) argumentsAst.forEach((arg) => collectVForItems(arg));
+	if (shouldPassIndices && vForInfoList && vForInfoList.length > 0 && dataKey) {
+		declareDatasetIndices(dataKey, vForInfoList, statements);
+		declareVForItems(resolveItemsToDeclare(usedVForItems, vForInfoList), vForInfoList, statements, scriptScope);
+	}
+	const localVarNames = new Set(usedVForItems);
+	let callArgs;
+	if (!argumentsAst || argumentsAst.length === 0) callArgs = [t.identifier(EVENT_PARAM_NAME)];
+	else callArgs = argumentsAst.map((arg) => buildProxyRefsArgument(arg, vForInfoList, effectiveVForItemNames, arrowFunctionArgumentNames, localVarNames, scriptScope));
+	statements.push(t.returnStatement(t.callExpression(calleeAst, callArgs)));
+	return t.blockStatement(statements);
+}
+/**
+* 检查是否应该创建局部引用
+*/
+function shouldCreateLocalReference(usages) {
+	if (usages.length <= 1) return false;
+	if (usages.some((u) => u.isReassignment)) return false;
+	if (usages.some((u) => u.isUpdate && !u.isMemberExpression)) return false;
+	return true;
+}
+//#endregion
+//#region src/template/wxsPolyfill.ts
+const WXS_POLYFILL_REGISTRY = {
+	find: { type: "instance" },
+	findLast: { type: "instance" },
+	findIndex: { type: "instance" },
+	findLastIndex: { type: "instance" },
+	includes: { type: "instance" },
+	filter: { type: "instance" },
+	map: { type: "instance" },
+	reduce: { type: "instance" },
+	reduceRight: { type: "instance" },
+	some: { type: "instance" },
+	every: { type: "instance" },
+	flat: { type: "instance" },
+	flatMap: { type: "instance" },
+	at: { type: "instance" },
+	padStart: { type: "instance" },
+	padEnd: { type: "instance" },
+	trimStart: { type: "instance" },
+	trimEnd: { type: "instance" },
+	replaceAll: { type: "instance" },
+	entries: {
+		type: "static",
+		object: "Object"
+	},
+	fromEntries: {
+		type: "static",
+		object: "Object"
+	},
+	assign: {
+		type: "static",
+		object: "Object"
+	},
+	isNaN: {
+		type: "static",
+		object: "Number"
+	},
+	isFinite: {
+		type: "static",
+		object: "Number"
+	},
+	isInteger: {
+		type: "static",
+		object: "Number"
+	}
+};
+const WXS_UTILS_NAMESPACE = "__vmsWXSUtils";
+function walkChildren(node, callback) {
+	if (!node || typeof node !== "object") return node;
+	for (const key of Object.keys(node)) {
+		if (key === "type" || key === "start" || key === "end" || key === "loc") continue;
+		const child = node[key];
+		if (Array.isArray(child)) {
+			for (let i = 0; i < child.length; i++) if (child[i] && typeof child[i] === "object" && child[i].type) {
+				const result = callback(child[i], key, i);
+				if (result !== void 0) child[i] = result;
+			}
+		} else if (child && typeof child === "object" && child.type) {
+			const result = callback(child, key);
+			if (result !== void 0) node[key] = result;
+		}
+	}
+}
+/**
+* 简单递归遍历 AST 节点，对每个节点调用 visitor
+* 不依赖 @babel/traverse 的 scope 机制，避免 "Couldn't find a Program" 错误
+*/
+function walkNode(node, visitor) {
+	if (!node || typeof node !== "object") return;
+	visitor(node);
+	walkChildren(node, (child) => {
+		walkNode(child, visitor);
+	});
+}
+/**
+* 检测 AST 中使用了哪些需要 polyfill 的方法（只读，不修改 AST）
+*/
+function detectPolyfillMethods(ast) {
+	const detected = /* @__PURE__ */ new Set();
+	walkNode(ast, (node) => {
+		if (node.type === "CallExpression") {
+			const callee = node.callee;
+			if (callee && callee.type === "MemberExpression" && !callee.computed && callee.property && callee.property.type === "Identifier") {
+				const methodName = callee.property.name;
+				if (methodName in WXS_POLYFILL_REGISTRY) detected.add(methodName);
+			}
+		} else if (node.type === "UnaryExpression" && node.operator === "typeof") detected.add("__typeof__");
+	});
+	return detected;
+}
+/**
+* 在 AST 上原地替换所有 polyfill 方法调用（应在深拷贝上调用）
+* 使用迭代方式处理，支持链式调用和嵌套回调
+*/
+function applyPolyfillTransform(node) {
+	if (!node || typeof node !== "object") return node;
+	walkChildren(node, (child) => applyPolyfillTransform(child));
+	if (node.type === "CallExpression") {
+		const callee = node.callee;
+		if (callee && callee.type === "MemberExpression" && !callee.computed) {
+			const property = callee.property;
+			if (property && property.type === "Identifier") {
+				const methodName = property.name;
+				const entry = WXS_POLYFILL_REGISTRY[methodName];
+				if (entry) {
+					if (entry.type === "instance") {
+						if (callee.object && callee.object.type === "Identifier" && callee.object.name === WXS_UTILS_NAMESPACE) return node;
+						return t$1.callExpression(t$1.memberExpression(t$1.identifier(WXS_UTILS_NAMESPACE), t$1.identifier(methodName)), [callee.object, ...node.arguments]);
+					} else if (entry.type === "static" && entry.object) {
+						const objectNode = callee.object;
+						if (objectNode && objectNode.type === "Identifier" && objectNode.name === entry.object) {
+							const wxsName = entry.object.toLowerCase() + methodName[0].toUpperCase() + methodName.slice(1);
+							return t$1.callExpression(t$1.memberExpression(t$1.identifier(WXS_UTILS_NAMESPACE), t$1.identifier(wxsName)), [...node.arguments]);
+						}
+					}
+				}
+			}
+		}
+	}
+	return node;
+}
+//#endregion
+//#region src/template/expression.ts
+/**
+* 对 babel 输出的代码进行 WXS 兼容性清理
+* - $ → _（WXS 不支持 $ 标识符）
+* - void 0 → undefined（WXS 不支持 void 关键字）
+*/
+function sanitizeWxsCode(code) {
+	return code.replace(/[_a-zA-Z][$\w]*/g, (match) => match.replace(/[$]/g, "_")).replace(/void\s+0/g, "undefined");
+}
+function makeBabelOptions() {
+	return {
+		filename: "temp.ts",
+		presets: ["@babel/preset-env", "@babel/preset-typescript"],
+		plugins: ["@babel/plugin-transform-arrow-functions", "@babel/plugin-transform-template-literals"],
+		generatorOpts: { jsescOption: { minimal: true } }
+	};
+}
+/**
+* 将表达式 AST 节点通过 babel 降级为 ES5 兼容的代码字符串
+* 处理可选链(?.)、箭头函数、模板字符串等现代语法
+*
+* 返回代码字符串而非 AST 节点，因为 @babel/generator 会在输出时
+* 将降级后的条件表达式反向优化回 ?. 等简写形式。
+*
+* 后处理：$ → _（WXS 不支持 $）、void 0 → undefined（WXS 不支持 void）
+*/
+function downlevelExpressionCode(expr) {
+	const result = transformFromAstSync(t$1.program([t$1.expressionStatement(expr)]), void 0, makeBabelOptions());
+	if (!result?.code) throw createCompileError("无法将表达式转换为 WXS 兼容语法", expr.loc);
+	const lines = result.code.trim().split("\n");
+	const declarations = [];
+	const exprLines = [];
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (/^\s*var\s+/.test(trimmed)) declarations.push(trimmed);
+		else if (trimmed) exprLines.push(trimmed);
+	}
+	return {
+		code: sanitizeWxsCode(exprLines.join("\n").trim().replace(/;?\s*$/, "")),
+		declarations: declarations.join("\n")
+	};
+}
+/**
+* 将降级后的代码字符串解析为 AST 语句列表
+* parse 回 AST 是为了锁定展开形式，避免 @babel/generator 反向优化回 ?. 等简写
+*/
+function parseDownleveledCode(code) {
+	return parse$1(code, { sourceType: "script" }).program.body;
+}
+/**
+* Vue compiler 解析失败时的 fallback：用 babel 重新解析表达式
+*
+* prop.exp.ast 有四种值：
+*   null  — Vue compiler 判定为简单标识符，无需解析
+*   false — Vue compiler 解析失败（语法错误），需要 fallback 重新解析
+*   undefined — 静态节点或 filter 语法（极少见）
+*   Program | Expression — 正常解析结果
+*
+* 当 rawAst === false 时，尝试用 @babel/parser 重新解析。
+* 返回解析后的 AST 表达式节点，或 null（解析也失败）。
+*/
+function fallbackParseExpression(rawAst, expression) {
+	if (rawAst !== false) return rawAst;
+	try {
+		const stmt = parse$1(expression, {
+			sourceType: "script",
+			plugins: ["typescript"]
+		}).program.body[0];
+		return stmt?.type === "ExpressionStatement" ? stmt.expression : null;
+	} catch {
+		return null;
+	}
+}
+function getTemplateNodeProp(node, prop, returnValue, counter, wxsExpressionStatements, ctx, wxsStatementsFun) {
+	if (prop.exp?.type !== NodeTypes.SIMPLE_EXPRESSION) return { content: "" };
+	const originalExpression = prop.exp.content;
+	const rawAst = prop.exp.ast;
+	const ast = fallbackParseExpression(rawAst, originalExpression);
+	const notSupportMethodsSet = ast ? detectPolyfillMethods(ast) : /* @__PURE__ */ new Set();
+	if (ast) if (isComplexExpression(ast) || notSupportMethodsSet.size > 0) if (!containsExternalFunctionInExpression(ast)) {
+		const wxsFunctionName = counter.generateWxsFunctionName();
+		const variables = extractVariablesFromExpressionAST(ast);
+		const clonedAst = t$1.cloneNode(ast);
+		const programAST = t$1.program([t$1.expressionStatement(clonedAst)]);
+		if (notSupportMethodsSet.size > 0) applyPolyfillTransform(programAST);
+		const result = transformFromAstSync(programAST, originalExpression, makeBabelOptions());
+		if (result?.code) {
+			const statements = parseDownleveledCode(sanitizeWxsCode(result.code));
+			const lastIndex = statements.length - 1;
+			const wxsStmt = t$1.expressionStatement(t$1.assignmentExpression("=", t$1.memberExpression(t$1.memberExpression(t$1.identifier("module"), t$1.identifier("exports")), t$1.identifier(wxsFunctionName)), t$1.functionExpression(null, variables.map((item) => t$1.identifier(item)), t$1.blockStatement(typeof wxsStatementsFun === "function" ? wxsStatementsFun(statements, lastIndex) : statements.map((item, index) => {
+				if (index === lastIndex) return item.type === "ExpressionStatement" ? t$1.returnStatement(item.expression) : item;
+				return item;
+			})))));
+			wxsExpressionStatements.push(wxsStmt);
+			const wxsCallParams = variables.length > 0 ? `${variables.join(", ")}` : "";
+			collectBindingVarsWithVarNameList(variables, node, returnValue, ctx);
+			return {
+				content: `{{${WXS_NAMESPACE}.${wxsFunctionName}(${wxsCallParams})}}`,
+				wxsStatement: wxsStmt
+			};
+		} else throw createCompileError("无法将表达式转换为es5语法", prop.loc);
+	} else throw createCompileError("无法处理表达式", prop.loc);
+	else {
+		collectBindingVarsWithAST(ast, node, returnValue, ctx);
+		return { content: `{{${originalExpression}}}` };
+	}
+	else if (originalExpression === "true" || originalExpression === "false") return { content: `{{${originalExpression}}}` };
+	else {
+		collectBindingVarsWithVarName(originalExpression, node, returnValue, ctx);
+		return { content: `{{${originalExpression}}}` };
+	}
+}
+//#endregion
+//#region src/template/nodeProps/eventProcessor.ts
+/**
+* 将 BlockStatement "重生"为完整 AST（File 节点）。
+*
+* 因为 traverse 需要一个顶层 Program/File 才能提供 scope 信息，
+* 而 BlockStatement 本身缺少顶层作用域，所以需要：
+* 1. generate(code) — 序列化为字符串
+* 2. babelParse(code) — 重新解析为完整 AST
+*
+* 注意：isAsync 必须正确传递，否则 babel 无法解析 await 关键字。
+*/
+function reparseBodyAsAST(body, isAsync) {
+	const code = generate(t.arrowFunctionExpression([], body, isAsync), { compact: true }).code;
+	return parse$1(code, {
+		sourceType: "module",
+		plugins: ["typescript"]
+	});
+}
+/**
+* 检查变量是否应该被跳过（不收集到 internalVars）
+* 统一封装 scriptScope 变量来源分析，避免散布在多处的四连判断
+*/
+function shouldSkipVariable(name, scriptScope) {
+	if (!scriptScope) return false;
+	return isPropsVariable(name, scriptScope) || isMacroVariable(name, scriptScope) || isImportVariable(name, scriptScope) || isGlobalVariableInScope(name, scriptScope);
+}
+/**
+* 扫描调用参数中的外部变量（非 v-for item、非字面量、非 $event），
+* 注册到 returnValue 和 ctx.internalVars，确保 __vmsProxyRefs 能访问到
+* 现在使用 scriptScope 进行更精确的变量来源分析
+*/
+function collectExternalVarsFromArgs(args, vForItemNames, vForInfoList, returnValue, ctx, arrowFunctionArgumentNames) {
+	const vForIndices = new Set(vForInfoList ? vForInfoList.map((info) => getVForIndexName(info) || "index") : []);
+	function scanNode(node) {
+		if (t.isIdentifier(node)) {
+			const name = node.name;
+			if (name === "__vms_event" || name === "$event" || vForItemNames.has(name) || vForIndices.has(name) || GLOBAL_WHITELIST.has(name) || arrowFunctionArgumentNames && arrowFunctionArgumentNames.has(name)) return;
+			if (shouldSkipVariable(name, ctx.scriptScope)) return;
+			addProperty(returnValue, name);
+			ctx.internalVars.add(name);
+		} else if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) scanNode(node.object);
+		else if (t.isObjectExpression(node)) node.properties.forEach((prop) => {
+			if (t.isObjectProperty(prop)) scanNode(prop.value);
+		});
+		else if (t.isArrayExpression(node)) node.elements.forEach((el) => el && scanNode(el));
+		else if (t.isSpreadElement(node)) scanNode(node.argument);
+	}
+	args.forEach((arg) => scanNode(arg));
+}
+/**
+* 处理事件属性
+*/
+function processEventProperty(prop, node, counter, callExpressionWithArgs, returnValue, ctx) {
+	if (prop.type !== 7 || prop.name !== "on") return null;
+	const exp = prop.exp;
+	if (!exp) return null;
+	let content = "";
+	const excludeBindingVars = [];
+	const vForInfoList = getVForInfoList(ctx, node);
+	const vForItemName = /* @__PURE__ */ new Set();
+	if (vForInfoList) for (const info of vForInfoList) {
+		const name = getVForItemName(info);
+		if (name) vForItemName.add(name);
+	}
+	const expContent = exp.type === NodeTypes.SIMPLE_EXPRESSION ? exp.content : "";
+	let ast = fallbackParseExpression(exp.ast, expContent);
+	if (!ast) {
+		if (exp.type === NodeTypes.SIMPLE_EXPRESSION) {
+			content = exp.content;
+			collectBindingVarsWithAST(t.identifier(content), node, returnValue, ctx);
+		}
+	} else {
+		if (t.isProgram(ast) && ast.body.length > 0) {
+			const firstStatement = ast.body[0];
+			if (t.isExpressionStatement(firstStatement)) ast = firstStatement.expression;
+		}
+		content = processASTExpression(ast, counter, callExpressionWithArgs, excludeBindingVars, vForItemName, node, returnValue, ctx);
+		const allExcluded = [...excludeBindingVars, ...ctx.internalVars];
+		collectBindingVarsWithAST(ast, node, returnValue, ctx, allExcluded);
+		excludeBindingVars.forEach((name) => ctx.bridgedFunctions.add(name));
+	}
+	return processEventName(prop, content);
+}
+/**
+* 处理AST表达式
+*/
+function processASTExpression(ast, counter, callExpressionWithArgs, excludeBindingVars, vForItemName, node, returnValue, ctx) {
+	const vForInfoList = getVForInfoList(ctx, node);
+	if (t.isCallExpression(ast)) return processCallableExpression(ast.callee, ast.arguments, counter, callExpressionWithArgs, excludeBindingVars, vForItemName, vForInfoList, ctx, returnValue);
+	else if (t.isMemberExpression(ast)) return processCallableExpression(ast, null, counter, callExpressionWithArgs, excludeBindingVars, vForItemName, vForInfoList, ctx, returnValue);
+	else if (t.isArrowFunctionExpression(ast)) return processArrowFunctionExpression(ast, counter, callExpressionWithArgs, excludeBindingVars, vForItemName, node, returnValue, ctx);
+	return "";
+}
+/**
+* 统一处理所有可调用表达式的事件绑定：
+* - onClick(args)          → callee=Identifier, argumentsAst=args
+* - card.onClick(args)     → callee=MemberExpression, argumentsAst=args
+* - card.onClick           → callee=MemberExpression, argumentsAst=null
+* - (e) => onClick(args)   → 同上，加 arrowFunctionArgumentNames
+*/
+function processCallableExpression(callee, argumentsAst, counter, callExpressionWithArgs, excludeBindingVars, vForItemName, vForInfoList, ctx, returnValue, arrowFunctionArgumentNames) {
+	const content = counter.generateFunctionPropertyName();
+	const dataKey = getFunctionIndexChar(counter.nodeDataKeyIndex++);
+	const args = argumentsAst ?? [];
+	if (t.isIdentifier(callee)) handleIdentifierCallee(callee, args, content, dataKey, callExpressionWithArgs, excludeBindingVars, vForItemName, vForInfoList, ctx, returnValue, arrowFunctionArgumentNames);
+	else if (t.isMemberExpression(callee) && t.isIdentifier(callee.object)) handleMemberExpressionCallee(callee, argumentsAst, args, content, dataKey, callExpressionWithArgs, excludeBindingVars, vForItemName, vForInfoList, ctx, returnValue, arrowFunctionArgumentNames);
+	ctx.needsProxyRefs = true;
+	return content;
+}
+/** Identifier callee：onClick(args) */
+function handleIdentifierCallee(callee, args, content, dataKey, callExpressionWithArgs, excludeBindingVars, vForItemName, vForInfoList, ctx, returnValue, arrowFunctionArgumentNames) {
+	const effectiveVForItemName = vForItemName || /* @__PURE__ */ new Set();
+	collectExternalVarsFromArgs(args, effectiveVForItemName, vForInfoList, returnValue, ctx, arrowFunctionArgumentNames);
+	const indices = vForInfoList ? vForInfoList.map((info) => getVForIndexName(info) || "index") : [];
+	const shouldPassIndices = vForInfoList && vForInfoList.length > 0;
+	callExpressionWithArgs.set(content, {
+		dataKey,
+		dataArgsAst: shouldPassIndices ? indices.map((idx) => t.identifier(idx)) : null,
+		returnValueBodyAst: getASTWithoutVForItemFromProxyRefs(callee, args, arrowFunctionArgumentNames, vForInfoList, effectiveVForItemName, dataKey, shouldPassIndices, ctx.scriptScope),
+		isAsync: false
+	});
+	excludeBindingVars.push(callee.name);
+}
+/** MemberExpression callee：card.onClick(args) 或 obj.method(args) */
+function handleMemberExpressionCallee(callee, argumentsAst, args, content, dataKey, callExpressionWithArgs, excludeBindingVars, vForItemName, vForInfoList, ctx, returnValue, arrowFunctionArgumentNames) {
+	const calleeName = callee.object.name;
+	collectExternalVarsFromArgs(args, vForItemName, vForInfoList, returnValue, ctx, arrowFunctionArgumentNames);
+	if (vForItemName.has(calleeName) && vForInfoList && vForInfoList.length > 0) {
+		const indices = vForInfoList.map((info) => getVForIndexName(info) || "index");
+		callExpressionWithArgs.set(content, {
+			dataKey,
+			dataArgsAst: indices.map((idx) => t.identifier(idx)),
+			returnValueBodyAst: getASTWithVForItemFromProxyRefs(dataKey, callee, argumentsAst, vForInfoList, arrowFunctionArgumentNames, ctx.scriptScope),
+			isAsync: false
+		});
+	} else {
+		if (!GLOBAL_WHITELIST.has(calleeName) && !shouldSkipVariable(calleeName, ctx.scriptScope)) {
+			addProperty(returnValue, calleeName);
+			ctx.internalVars.add(calleeName);
+		}
+		callExpressionWithArgs.set(content, {
+			dataKey,
+			dataArgsAst: null,
+			returnValueBodyAst: getASTWithoutVForItemFromProxyRefs(callee, argumentsAst, arrowFunctionArgumentNames, vForInfoList, vForItemName, void 0, false, ctx.scriptScope),
+			isAsync: false
+		});
+	}
+	excludeBindingVars.push(calleeName);
+}
+/**
+* 处理箭头函数表达式
+*/
+function processArrowFunctionExpression(ast, counter, callExpressionWithArgs, excludeBindingVars, vForItemName, node, returnValue, ctx) {
+	const arrowFunctionArguments = ast.params;
+	const body = ast.body;
+	const isAsync = ast.async || false;
+	const vForInfoList = getVForInfoList(ctx, node);
+	const arrowFunctionArgumentNames = arrowFunctionArguments.length > 0 ? new Set(arrowFunctionArguments.map((p) => t.isIdentifier(p) ? p.name : "").filter(Boolean)) : void 0;
+	if (t.isBlockStatement(body)) return processInlineArrowFunction(body, arrowFunctionArguments, counter, callExpressionWithArgs, excludeBindingVars, node, returnValue, ctx, isAsync);
+	else if (t.isCallExpression(body)) return processCallableExpression(body.callee, body.arguments, counter, callExpressionWithArgs, excludeBindingVars, vForItemName, vForInfoList, ctx, returnValue, arrowFunctionArgumentNames);
+	else if (t.isAssignmentExpression(body)) return processInlineArrowFunction(t.blockStatement([t.expressionStatement(body)]), arrowFunctionArguments, counter, callExpressionWithArgs, excludeBindingVars, node, returnValue, ctx, isAsync);
+	else if (t.isConditionalExpression(body) || t.isLogicalExpression(body)) return createShortExprHandler(body, arrowFunctionArguments, callExpressionWithArgs, getVForInfoList(ctx, node), getVForVariables(ctx, node), ctx, counter, returnValue, isAsync);
+	return "";
+}
+function collectExternalVarsFromExpression(body, arrowFunctionArgumentNames, vForVars) {
+	const varsToCollect = /* @__PURE__ */ new Set();
+	const collectVarsFromNode = (node) => {
+		if (t.isIdentifier(node)) {
+			const name = node.name;
+			if (name !== "__vms_event" && name !== "$event" && !GLOBAL_WHITELIST.has(name) && !(arrowFunctionArgumentNames && arrowFunctionArgumentNames.has(name)) && !vForVars.has(name)) varsToCollect.add(name);
+		} else if (t.isMemberExpression(node)) collectVarsFromNode(node.object);
+		else if (t.isCallExpression(node)) {
+			collectVarsFromNode(node.callee);
+			node.arguments.forEach((arg) => collectVarsFromNode(arg));
+		} else if (t.isConditionalExpression(node)) {
+			collectVarsFromNode(node.test);
+			collectVarsFromNode(node.consequent);
+			collectVarsFromNode(node.alternate);
+		} else if (t.isLogicalExpression(node) || t.isBinaryExpression(node)) {
+			collectVarsFromNode(node.left);
+			collectVarsFromNode(node.right);
+		} else if (t.isUnaryExpression(node)) collectVarsFromNode(node.argument);
+	};
+	if (t.isConditionalExpression(body)) {
+		collectVarsFromNode(body.test);
+		collectVarsFromNode(body.consequent);
+		collectVarsFromNode(body.alternate);
+	} else {
+		collectVarsFromNode(body.left);
+		collectVarsFromNode(body.right);
+	}
+	return varsToCollect;
+}
+/**
+* 重写表达式中的变量引用
+* 将外部变量、props、箭头函数参数替换为正确的访问路径
+*/
+function rewriteExpressionVars(expr, varsToCollect, arrowFunctionArgumentNames, ctx) {
+	const processExpr = (node) => {
+		if (t.isIdentifier(node)) {
+			const name = node.name;
+			if (arrowFunctionArgumentNames && arrowFunctionArgumentNames.has(name)) return t.memberExpression(t.identifier(EVENT_PARAM_NAME), t.identifier("detail"));
+			if (ctx.scriptScope?.props.has(name)) {
+				const propsVarName = ctx.scriptScope.propsVarName || "__vmsProps";
+				return t.memberExpression(t.identifier(propsVarName), t.identifier(name));
+			}
+			if (varsToCollect.has(name)) return t.memberExpression(t.identifier("__vmsProxyRefs"), t.identifier(name));
+			return node;
+		} else if (t.isMemberExpression(node)) return t.memberExpression(processExpr(node.object), node.property, node.computed);
+		else if (t.isCallExpression(node)) return t.callExpression(processExpr(node.callee), node.arguments.map((arg) => processExpr(arg)));
+		else if (t.isConditionalExpression(node)) return t.conditionalExpression(processExpr(node.test), processExpr(node.consequent), processExpr(node.alternate));
+		else if (t.isLogicalExpression(node)) return t.logicalExpression(node.operator, processExpr(node.left), processExpr(node.right));
+		else if (t.isBinaryExpression(node)) return t.binaryExpression(node.operator, processExpr(node.left), processExpr(node.right));
+		else if (t.isUnaryExpression(node)) return t.unaryExpression(node.operator, processExpr(node.argument));
+		return node;
+	};
+	return processExpr(expr);
+}
+/**
+* 创建简短表达式（条件/逻辑表达式）的箭头函数处理器
+* 供 processArrowFunctionExpression 中条件表达式和逻辑表达式分支复用
+*/
+function createShortExprHandler(body, arrowFunctionArguments, callExpressionWithArgs, vForInfoList, vForVars, ctx, counter, returnValue, isAsync) {
+	const arrowFunctionArgumentNames = arrowFunctionArguments.length > 0 ? new Set(arrowFunctionArguments.map((p) => t.isIdentifier(p) ? p.name : "").filter(Boolean)) : void 0;
+	const varsToCollect = collectExternalVarsFromExpression(body, arrowFunctionArgumentNames, vForVars);
+	varsToCollect.forEach((varName) => {
+		if (!shouldSkipVariable(varName, ctx.scriptScope)) {
+			addProperty(returnValue, varName);
+			ctx.internalVars.add(varName);
+		}
+	});
+	if (varsToCollect.size > 0) ctx.needsProxyRefs = true;
+	const functionName = counter.generateFunctionPropertyName();
+	const dataKey = vForInfoList && vForInfoList.length > 0 ? getFunctionIndexChar(counter.nodeDataKeyIndex++) : "";
+	const statements = [];
+	if (arrowFunctionArguments.length > 0) {
+		const param = arrowFunctionArguments[0];
+		if (t.isIdentifier(param) && param.name !== "$event" && param.name !== "__vms_event") statements.push(t.variableDeclaration("const", [t.variableDeclarator(param, t.memberExpression(t.identifier(EVENT_PARAM_NAME), t.identifier("detail")))]));
+	}
+	if (vForInfoList && vForInfoList.length > 0) {
+		const indexVars = vForInfoList.map((info) => getVForIndexName(info) || "index").map((idx) => t.identifier(idx));
+		statements.push(t.variableDeclaration("const", [t.variableDeclarator(t.objectPattern([t.objectProperty(t.identifier(dataKey), t.arrayPattern(indexVars), false, false)]), t.memberExpression(t.memberExpression(t.identifier(EVENT_PARAM_NAME), t.identifier("currentTarget")), t.identifier("dataset")))]));
+	}
+	const processedBody = rewriteExpressionVars(body, varsToCollect, arrowFunctionArgumentNames, ctx);
+	statements.push(t.returnStatement(processedBody));
+	const functionBody = t.blockStatement(statements);
+	const dataArgsAst = vForInfoList && vForInfoList.length > 0 ? vForInfoList.map((info) => t.identifier(getVForIndexName(info) || "index")) : null;
+	callExpressionWithArgs.set(functionName, {
+		dataKey,
+		dataArgsAst,
+		returnValueBodyAst: functionBody,
+		isAsync
+	});
+	return functionName;
+}
+/**
+* 处理事件名转换
+* 规则：
+* 1. 事件名原样保留，不做 click -> tap 转换
+* 2. .stop 转为 catch:
+* 3. .mut 转为 mut-bind:
+* 4. .capture 转为 capture-bind:
+* 5. .capture-stop 转为 capture-catch:
+*/
+function processEventName(prop, content) {
+	if (prop.type !== NodeTypes.DIRECTIVE) return null;
+	const arg = prop.arg;
+	if (!arg) return null;
+	if (arg.type === NodeTypes.SIMPLE_EXPRESSION) {
+		const eventName = arg.content;
+		const modifiers = prop.modifiers || [];
+		const hasMutModifier = modifiers.some((item) => item.content === "mut");
+		const hasCaptureModifier = modifiers.some((item) => item.content === "capture");
+		const hasCaptureStopModifier = modifiers.some((item) => item.content === "capture-stop");
+		const hasStopModifier = modifiers.some((item) => item.content === "stop");
+		let bindType;
+		if (hasCaptureStopModifier) bindType = "capture-catch";
+		else if (hasCaptureModifier) bindType = "capture-bind";
+		else if (hasMutModifier) bindType = "mut-bind";
+		else if (hasStopModifier) bindType = "catch";
+		else bindType = "bind";
+		return {
+			name: `${bindType}:${eventName}`,
+			content
+		};
+	} else throw createCompileError("事件名必须是简单表达式：" + prop.arg, prop.loc);
+}
+/**
+* 添加生成的函数到returnValue
+* 返回生成的 data- 属性列表
+*/
+function addGeneratedFunctions(callExpressionWithArgs, _props, returnValue) {
+	const dataProps = [];
+	callExpressionWithArgs.forEach(({ dataKey, dataArgsAst, returnValueBodyAst, isAsync }, funName) => {
+		const propName = `data-${dataKey}`;
+		if (Array.isArray(dataArgsAst) && dataArgsAst.length > 0) {
+			const content = `{{[${dataArgsAst.map((arg) => generate(arg, { compact: true }).code).join(",")}]}}`;
+			dataProps.push({
+				name: propName,
+				content
+			});
+		}
+		if (returnValueBodyAst) {
+			let functionExpression;
+			const body = t.isBlockStatement(returnValueBodyAst) ? returnValueBodyAst : t.blockStatement([t.returnStatement(returnValueBodyAst)]);
+			if (isAsync) functionExpression = t.functionExpression(null, [t.identifier(EVENT_PARAM_NAME)], body, false, true);
+			else functionExpression = t.arrowFunctionExpression([t.identifier(EVENT_PARAM_NAME)], body);
+			returnValue.properties.push(t.objectProperty(t.identifier(funName), functionExpression));
+		}
+	});
+	return dataProps;
+}
+/**
+* 处理内联箭头函数
+*/
+function processInlineArrowFunction(body, arrowFunctionArguments, counter, callExpressionWithArgs, excludeBindingVars, node, returnValue, ctx, isAsync = false) {
+	const functionName = counter.generateFunctionPropertyName();
+	const vForInfoList = getVForInfoList(ctx, node);
+	const usedVars = collectUsedVariables(body, arrowFunctionArguments, vForInfoList, isAsync);
+	const vForVars = getVForVariables(ctx, node);
+	usedVars.forEach((varName) => {
+		if (!vForVars.has(varName) && !GLOBAL_WHITELIST.has(varName) && !shouldSkipVariable(varName, ctx.scriptScope)) {
+			addProperty(returnValue, varName);
+			ctx.internalVars.add(varName);
+		}
+	});
+	let vForItemUsage = null;
+	if (vForInfoList && vForInfoList.length > 0) {
+		vForItemUsage = analyzeVForItemUsage(body, vForInfoList, isAsync);
+		const lastVForInfo = vForInfoList[vForInfoList.length - 1];
+		const itemName = getVForItemName(lastVForInfo);
+		if (itemName) excludeBindingVars.push(itemName);
+	}
+	if (usedVars.size > 0 || vForItemUsage?.shouldCreateReference) ctx.needsProxyRefs = true;
+	const functionIndex = counter.functionPropertyCounter - 1;
+	const dataKey = vForInfoList && vForInfoList.length > 0 ? getFunctionIndexChar(functionIndex) : "";
+	const functionBody = createInlineHandlerBody(body, arrowFunctionArguments, usedVars, vForInfoList, vForItemUsage, isAsync, dataKey);
+	const dataArgsAst = vForInfoList && vForInfoList.length > 0 ? vForInfoList.map((info) => {
+		const indexName = getVForIndexName(info) || "index";
+		return t.identifier(indexName);
+	}) : null;
+	callExpressionWithArgs.set(functionName, {
+		dataKey,
+		dataArgsAst,
+		returnValueBodyAst: functionBody,
+		isAsync
+	});
+	return functionName;
+}
+/**
+* 创建局部变量声明收集 visitor
+* 将 AST 遍历中重复的变量声明收集逻辑（VariableDeclarator、FunctionDeclaration、
+* CatchClause、ForStatement）提取为可复用的 visitor 工厂
+*/
+function createLocalVarCollector(localVars) {
+	return {
+		VariableDeclarator(path) {
+			const id = path.node.id;
+			if (t.isIdentifier(id)) localVars.add(id.name);
+			else if (t.isObjectPattern(id)) id.properties.forEach((prop) => {
+				if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) localVars.add(prop.value.name);
+				else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) localVars.add(prop.argument.name);
+			});
+			else if (t.isArrayPattern(id)) id.elements.forEach((elem) => {
+				if (elem && t.isIdentifier(elem)) localVars.add(elem.name);
+			});
+		},
+		FunctionDeclaration(path) {
+			if (path.node.id) localVars.add(path.node.id.name);
+			path.node.params.forEach((param) => {
+				if (t.isIdentifier(param)) localVars.add(param.name);
+			});
+		},
+		CatchClause(path) {
+			if (path.node.param && t.isIdentifier(path.node.param)) localVars.add(path.node.param.name);
+		},
+		ForStatement(path) {
+			const init = path.node.init;
+			if (t.isVariableDeclaration(init)) init.declarations.forEach((decl) => {
+				if (t.isIdentifier(decl.id)) localVars.add(decl.id.name);
+			});
+		}
+	};
+}
+/**
+* 收集函数体中使用的外部变量
+*/
+function collectUsedVariables(body, arrowFunctionArguments, vForInfoList, isAsync = false) {
+	const usedVars = /* @__PURE__ */ new Set();
+	const localVars = /* @__PURE__ */ new Set();
+	arrowFunctionArguments.forEach((param) => {
+		if (t.isIdentifier(param)) localVars.add(param.name);
+		else if (t.isObjectPattern(param)) param.properties.forEach((prop) => {
+			if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) localVars.add(prop.value.name);
+		});
+		else if (t.isAssignmentPattern(param)) {
+			if (t.isIdentifier(param.left)) localVars.add(param.left.name);
+		} else if (t.isRestElement(param)) {
+			if (t.isIdentifier(param.argument)) localVars.add(param.argument.name);
+		}
+	});
+	if (vForInfoList && vForInfoList.length > 0) vForInfoList.forEach((info) => {
+		const itemName = getVForItemName(info);
+		const indexName = getVForIndexName(info) || "index";
+		if (itemName) localVars.add(itemName);
+		localVars.add(indexName);
+	});
+	traverse(reparseBodyAsAST(body, isAsync), {
+		...createLocalVarCollector(localVars),
+		Identifier(path) {
+			const name = path.node.name;
+			if (!localVars.has(name) && !GLOBAL_WHITELIST.has(name) && !path.scope.hasBinding(name, true)) {
+				const parent = path.parent;
+				if (t.isObjectProperty(parent) && parent.key === path.node && !parent.computed) return;
+				if (t.isMemberExpression(parent) && parent.property === path.node && !parent.computed) return;
+				if (t.isOptionalMemberExpression(parent) && parent.property === path.node && !parent.computed) return;
+				usedVars.add(name);
+			}
+		}
+	});
+	return usedVars;
+}
+/**
+* 分析 v-for item 的使用情况
+*/
+function analyzeVForItemUsage(body, vForInfoList, isAsync = false) {
+	const lastVForInfo = vForInfoList[vForInfoList.length - 1];
+	const itemName = getVForItemName(lastVForInfo);
+	const usages = [];
+	const ast = reparseBodyAsAST(body, isAsync);
+	const localVars = /* @__PURE__ */ new Set();
+	let hasLocalItemVar = false;
+	traverse(ast, {
+		...createLocalVarCollector(localVars),
+		VariableDeclarator(path) {
+			const id = path.node.id;
+			if (t.isIdentifier(id) && id.name === itemName) hasLocalItemVar = true;
+		},
+		FunctionDeclaration(path) {
+			if (path.node.id && path.node.id.name === itemName) hasLocalItemVar = true;
+			path.node.params.forEach((param) => {
+				if (t.isIdentifier(param) && param.name === itemName) hasLocalItemVar = true;
+			});
+		},
+		Identifier(path) {
+			if (path.node.name !== itemName) return;
+			const parent = path.parent;
+			if (t.isVariableDeclarator(parent) && parent.id === path.node) return;
+			const usage = {
+				type: parent.type,
+				isMemberExpression: t.isMemberExpression(parent) && parent.object === path.node,
+				isReassignment: t.isAssignmentExpression(parent) && parent.left === path.node && parent.operator === "=",
+				isUpdate: t.isUpdateExpression(parent) && parent.argument === path.node
+			};
+			usages.push(usage);
+		}
+	});
+	if (hasLocalItemVar) return {
+		itemName,
+		usageCount: 0,
+		usages: [],
+		shouldCreateReference: false
+	};
+	const shouldCreate = shouldCreateLocalReference(usages);
+	return {
+		itemName,
+		usageCount: usages.length,
+		usages,
+		shouldCreateReference: shouldCreate
+	};
+}
+/**
+* 创建内联处理函数的函数体
+*/
+function createInlineHandlerBody(body, arrowFunctionArguments, externalVars, vForInfoList, vForItemUsage, isAsync = false, dataKey = "a") {
+	const statements = [];
+	const paramNameMapping = /* @__PURE__ */ new Map();
+	if (arrowFunctionArguments.length > 0) {
+		const param = arrowFunctionArguments[0];
+		if (t.isIdentifier(param)) {
+			if (param.name !== "$event" && param.name !== "__vms_event") statements.push(t.variableDeclaration("const", [t.variableDeclarator(param, t.memberExpression(t.identifier(EVENT_PARAM_NAME), t.identifier("detail")))]));
+			else if (param.name === "$event") paramNameMapping.set("$event", EVENT_PARAM_NAME);
+		} else if (t.isObjectPattern(param)) statements.push(t.variableDeclaration("const", [t.variableDeclarator(param, t.memberExpression(t.identifier(EVENT_PARAM_NAME), t.identifier("detail")))]));
+	}
+	if (vForInfoList && vForInfoList.length > 0) {
+		const indexVars = vForInfoList.map((info) => getVForIndexName(info) || "index").map((idx) => t.identifier(idx));
+		statements.push(t.variableDeclaration("const", [t.variableDeclarator(t.objectPattern([t.objectProperty(t.identifier(dataKey), t.arrayPattern(indexVars), false, false)]), t.memberExpression(t.memberExpression(t.identifier(EVENT_PARAM_NAME), t.identifier("currentTarget")), t.identifier("dataset")))]));
+		if (vForItemUsage?.shouldCreateReference) statements.push(createLocalReference(vForInfoList, vForItemUsage));
+	}
+	const transformedBody = replaceVariableAccess(t.cloneNode(body, true), externalVars, vForInfoList, vForItemUsage, paramNameMapping, isAsync);
+	statements.push(...transformedBody.body);
+	return t.blockStatement(statements);
+}
+/**
+* 创建局部引用语句
+* 注意：这里需要从 __vmsProxyRefs 而不是外层 item 标识符开始构建路径，
+* 因为 createInlineHandlerBody 中外层 item 会被 replaceVariableAccess 替换，
+* 而不会先声明为局部变量
+*/
+function createLocalReference(vForInfoList, vForItemUsage) {
+	const itemName = vForItemUsage.itemName;
+	const accessExpression = buildProxyRefsItemAccess(vForInfoList, vForInfoList.findIndex((info) => getVForItemName(info) === itemName), void 0, true);
+	return t.variableDeclaration("const", [t.variableDeclarator(t.identifier(itemName), accessExpression)]);
+}
+/**
+* 替换变量访问
+*/
+function replaceVariableAccess(body, externalVars, vForInfoList, vForItemUsage, paramNameMapping, isAsync = false) {
+	const localVars = /* @__PURE__ */ new Set();
+	const ast = reparseBodyAsAST(body, isAsync);
+	traverse(ast, { ...createLocalVarCollector(localVars) });
+	traverse(ast, { Identifier(path) {
+		const name = path.node.name;
+		if (paramNameMapping && paramNameMapping.has(name)) {
+			const mappedName = paramNameMapping.get(name);
+			path.replaceWith(t.identifier(mappedName));
+			return;
+		}
+		if (localVars.has(name)) return;
+		const parent = path.parent;
+		if (t.isObjectProperty(parent) && parent.key === path.node && !parent.computed) return;
+		if (t.isMemberExpression(parent) && parent.property === path.node && !parent.computed) return;
+		if (t.isOptionalMemberExpression(parent) && parent.property === path.node && !parent.computed) return;
+		if (vForInfoList && vForInfoList.length > 0) {
+			let isVForItem = false;
+			let itemIndex = -1;
+			for (let i = 0; i < vForInfoList.length; i++) {
+				const vForInfo = vForInfoList[i];
+				if (name === getVForItemName(vForInfo)) {
+					isVForItem = true;
+					itemIndex = i;
+					break;
+				}
+			}
+			if (isVForItem) if (itemIndex === vForInfoList.length - 1 && vForItemUsage?.shouldCreateReference) return;
+			else {
+				const accessExpression = buildProxyRefsItemAccess(vForInfoList, itemIndex);
+				path.replaceWith(accessExpression);
+				return;
+			}
+			if (vForInfoList.map((info) => getVForIndexName(info) || "index").includes(name)) return;
+		}
+		if (externalVars.has(name)) path.replaceWith(t.memberExpression(t.identifier("__vmsProxyRefs"), t.identifier(name)));
+	} });
+	return ast.program.body[0].expression.body;
+}
+//#endregion
+//#region src/template/nodeProps/event.ts
+function transformEventHandlers(node, returnValue, counter, ctx) {
+	if (node.type !== NodeTypes.ELEMENT) return;
+	counter.nodeDataKeyIndex = 0;
+	const callExpressionWithArgs = /* @__PURE__ */ new Map();
+	const props = node.props || [];
+	const eventProps = [];
+	for (const prop of props) {
+		const result = processEventProperty(prop, node, counter, callExpressionWithArgs, returnValue, ctx);
+		if (result) eventProps.push(result);
+	}
+	const dataProps = addGeneratedFunctions(callExpressionWithArgs, props, returnValue);
+	if (eventProps.length > 0 || dataProps.length > 0) {
+		const existingCodegenProps = getCodegenNodeProps(node);
+		[...eventProps, ...dataProps].forEach((prop) => {
+			existingCodegenProps.set(prop.name, { content: prop.content });
+		});
+		setCodegenNode(node, {
+			type: node.type,
+			tag: node.tag,
+			props: existingCodegenProps,
+			loc: node.loc
+		});
+	}
+}
+//#endregion
+//#region src/template/nodeProps/clazz.ts
+function transformTemplateClass(node, returnValue, counter, wxsExpressionStatements, ctx, isPage = false) {
+	if (node.type === NodeTypes.ROOT) {
+		const rootChildren = node.children.filter((child) => child.type === NodeTypes.ELEMENT);
+		if (!isPage && rootChildren.length === 1) ctx.rootElementNode = rootChildren[0];
+		return;
+	}
+	if (node.type !== NodeTypes.ELEMENT) return;
+	const props = node.props;
+	const isPushParentClass = !isPage && ctx.rootElementNode === node;
+	const classPropContent = [];
+	if (props) {
+		const classBindProp = props.find((prop) => prop.type === NodeTypes.DIRECTIVE && prop.rawName === ":class");
+		const classStaticProp = props.find((prop) => prop.type === NodeTypes.ATTRIBUTE && prop.name === "class");
+		if (classStaticProp && classStaticProp.value) classPropContent.push(classStaticProp.value.content.replace(/\s+/g, " ").trim());
+		if (isPushParentClass) classPropContent.push("class");
+		if (classBindProp) {
+			const exp = classBindProp.exp;
+			if (exp && exp.type === NodeTypes.SIMPLE_EXPRESSION) {
+				const classBindPropExpContent = exp.content;
+				const rawAst = exp.ast;
+				const ast = fallbackParseExpression(rawAst, classBindPropExpContent);
+				if (ast) {
+					const allElements = transformClassAst(ast);
+					const dynamicElements = allElements.filter((item) => !t$1.isStringLiteral(item));
+					const stringLiteralElements = allElements.filter((item) => t$1.isStringLiteral(item));
+					if (stringLiteralElements.length > 0) classPropContent.push(...stringLiteralElements.map((item) => item.value));
+					if (dynamicElements.length > 0) {
+						const variables = extractVariablesFromArrayElements(dynamicElements);
+						const functionName = counter.generateWxsFunctionName();
+						const downleveled = dynamicElements.map((el) => downlevelExpressionCode(el));
+						const allDeclarations = [...new Set(downleveled.map((d) => d.declarations).filter(Boolean))];
+						const declarationsBlock = allDeclarations.length > 0 ? allDeclarations.join(" ") + " " : "";
+						const funcAst = parse$1(`module.exports.${functionName} = function (${variables.join(", ")}) { ${declarationsBlock}return ${downleveled.length === 1 ? downleveled[0].code : `[${downleveled.map((d) => d.code).join(", ")}].filter(function (v) { return v; }).join(' ')`}; }`, { sourceType: "script" }).program.body[0];
+						if (funcAst?.type === "ExpressionStatement") wxsExpressionStatements.push(funcAst);
+						collectBindingVarsWithVarNameList(variables, node, returnValue, ctx);
+						const wxsCallParams = variables.length > 0 ? `${variables.join(", ")}` : "";
+						classPropContent.push(`{{${WXS_NAMESPACE}.${functionName}(${wxsCallParams})}}`);
+					}
+				} else {
+					classPropContent.push(`{{${classBindPropExpContent}}}`);
+					collectBindingVarsWithExpression(classBindPropExpContent, node, returnValue, ctx);
+				}
+			}
+		}
+	} else if (isPushParentClass) classPropContent.push("class");
+	if (classPropContent.length > 0) {
+		const existingCodegenProps = getCodegenNodeProps(node);
+		existingCodegenProps.set("class", { content: classPropContent.join(" ") });
+		setCodegenNode(node, {
+			type: node.type,
+			tag: node.tag,
+			props: existingCodegenProps,
+			loc: node.loc
+		});
+	}
+}
+function extractVariablesFromArrayElements(arrayElements) {
+	const allVariables = /* @__PURE__ */ new Set();
+	arrayElements.forEach((element) => {
+		extractVariablesFromExpressionAST(element).forEach((v) => allVariables.add(v));
+	});
+	return Array.from(allVariables);
+}
+function isConditionEqualTo(condition, expectedValue) {
+	return t$1.isBooleanLiteral(condition) && condition.value === expectedValue;
+}
+/**
+* 将模板字符串（TemplateLiteral）转换为字符串拼接表达式（BinaryExpression）
+* 例：`stat-card--${card.color}` → "stat-card--" + card.color
+*/
+function templateLiteralToConcat(node) {
+	const parts = [];
+	node.quasis.forEach((quasi, i) => {
+		const raw = quasi.value.cooked ?? quasi.value.raw;
+		if (raw) parts.push(t$1.stringLiteral(raw));
+		if (i < node.expressions.length) parts.push(node.expressions[i]);
+	});
+	if (parts.length === 0) return t$1.stringLiteral("");
+	return parts.reduce((acc, cur) => t$1.binaryExpression("+", acc, cur));
+}
+function transformClassAst(ast) {
+	const arrayElements = [];
+	if (ast.type === "ArrayExpression") ast.elements.forEach((element) => {
+		if (!element) return;
+		if (t$1.isConditionalExpression(element)) {
+			if (isConditionEqualTo(element.test, false)) return;
+			if (isConditionEqualTo(element.test, true)) {
+				arrayElements.push(element.consequent);
+				return;
+			}
+			arrayElements.push(element);
+		} else if (t$1.isStringLiteral(element)) arrayElements.push(element);
+		else if (t$1.isIdentifier(element)) arrayElements.push(element);
+		else if (t$1.isTemplateLiteral(element)) arrayElements.push(templateLiteralToConcat(element));
+		else if (t$1.isObjectExpression(element)) transformObjectProperties(element, arrayElements);
+		else arrayElements.push(element);
+	});
+	else if (t$1.isObjectExpression(ast)) transformObjectProperties(ast, arrayElements);
+	else {
+		const expr = ast;
+		arrayElements.push(t$1.isTemplateLiteral(expr) ? templateLiteralToConcat(expr) : expr);
+	}
+	return arrayElements;
+}
+/**
+* 将 ObjectExpression 的属性展开为条件表达式数组
+* 提取自 transformClassAst 中两处重复的对象属性处理逻辑
+*/
+function transformObjectProperties(objExpr, arrayElements) {
+	objExpr.properties.forEach((property) => {
+		if (!t$1.isObjectProperty(property)) return;
+		const condition = property.value;
+		if (!t$1.isExpression(condition)) return;
+		if (isConditionEqualTo(condition, false)) return;
+		let classNameExpression;
+		if (property.computed && t$1.isExpression(property.key)) classNameExpression = property.key;
+		else if (t$1.isIdentifier(property.key)) classNameExpression = t$1.stringLiteral(property.key.name);
+		else if (t$1.isStringLiteral(property.key)) classNameExpression = property.key;
+		else return;
+		if (isConditionEqualTo(condition, true)) {
+			arrayElements.push(classNameExpression);
+			return;
+		}
+		arrayElements.push(t$1.conditionalExpression(condition, classNameExpression, t$1.stringLiteral("")));
+	});
+}
+//#endregion
+//#region src/template/nodeProps/style.ts
+function toKebabCase(keyName) {
+	if (keyName.includes("-")) return keyName;
+	return keyName.replace(/([A-Z])/g, (_, c) => `-${c.toLowerCase()}`).replace(/^-/, "");
+}
+function buildStyleStringFromObject(objectExpression) {
+	const keyValueExpressions = [];
+	objectExpression.properties.forEach((prop) => {
+		if (prop.type !== "ObjectProperty") return;
+		const valueExpression = prop.value;
+		if (t$1.isRestElement(valueExpression) || t$1.isAssignmentPattern(valueExpression) || t$1.isArrayPattern(valueExpression) || t$1.isObjectPattern(valueExpression) || t$1.isVoidPattern(valueExpression)) return;
+		if (prop.computed && t$1.isExpression(prop.key)) keyValueExpressions.push(t$1.binaryExpression("+", t$1.binaryExpression("+", prop.key, t$1.stringLiteral(":")), valueExpression));
+		else if (prop.key.type === "Identifier" || prop.key.type === "StringLiteral") {
+			const kebabKey = toKebabCase(prop.key.type === "Identifier" ? prop.key.name : prop.key.value);
+			keyValueExpressions.push(t$1.binaryExpression("+", t$1.stringLiteral(`${kebabKey}:`), valueExpression));
+		}
+	});
+	if (keyValueExpressions.length === 0) return null;
+	return keyValueExpressions.reduce((acc, cur) => t$1.binaryExpression("+", t$1.binaryExpression("+", acc, t$1.stringLiteral(";")), cur));
+}
+function buildStyleStringFromArray(arrayExpression) {
+	const parts = [];
+	arrayExpression.elements.forEach((element) => {
+		if (!element) return;
+		if (t$1.isObjectExpression(element)) {
+			const expr = buildStyleStringFromObject(element);
+			if (expr) parts.push(expr);
+		} else if (t$1.isStringLiteral(element) || t$1.isTemplateLiteral(element)) parts.push(element);
+		else if (t$1.isIdentifier(element) || t$1.isMemberExpression(element)) parts.push(t$1.callExpression(t$1.memberExpression(t$1.identifier("__vmsWXSUtils"), t$1.identifier("styleToString")), [element]));
+		else if (t$1.isExpression(element)) parts.push(element);
+	});
+	if (parts.length === 0) return null;
+	return parts.reduce((acc, cur) => t$1.binaryExpression("+", t$1.binaryExpression("+", acc, t$1.stringLiteral(";")), cur));
+}
+function transformTemplateStyle(node, returnValue, counter, wxsExpressionStatements, ctx, isPage = false) {
+	if (node.type !== NodeTypes.ELEMENT) return;
+	const parentStyleContent = !isPage && ctx.rootElementNode === node ? "{{style}}" : null;
+	const props = node.props;
+	const styleContentList = [];
+	if (props) {
+		const styleBindProp = props.find((prop) => prop.type === NodeTypes.DIRECTIVE && prop.rawName === ":style");
+		const styleStaticProp = props.find((prop) => prop.type === NodeTypes.ATTRIBUTE && prop.name === "style");
+		if (!styleBindProp && !styleStaticProp && !parentStyleContent) return;
+		if (styleStaticProp && styleStaticProp.value) {
+			const styleStaticPropValue = styleStaticProp.value.content.replace(/\s+/g, " ").replace(/;\s+/g, ";").trim();
+			styleContentList.push(styleStaticPropValue.endsWith(";") ? styleStaticPropValue.slice(0, -1) : styleStaticPropValue);
+		}
+		if (parentStyleContent) styleContentList.push(parentStyleContent);
+		if (styleBindProp) {
+			const { content } = getTemplateNodeProp(node, styleBindProp, returnValue, counter, wxsExpressionStatements, ctx, (statements, lastIndex) => {
+				return statements.map((item, index) => {
+					if (index !== lastIndex) return item;
+					if (item.type !== "ExpressionStatement") return item;
+					const expr = item.expression;
+					if (expr.type === "ObjectExpression") {
+						const finalExpr = buildStyleStringFromObject(expr);
+						if (finalExpr) return t$1.returnStatement(finalExpr);
+					}
+					if (expr.type === "ArrayExpression") {
+						const finalExpr = buildStyleStringFromArray(expr);
+						if (finalExpr) return t$1.returnStatement(finalExpr);
+					}
+					if (expr.type === "StringLiteral" || expr.type === "TemplateLiteral") return t$1.returnStatement(expr);
+					if (t$1.isExpression(expr)) return t$1.returnStatement(expr);
+					return item;
+				});
+			});
+			styleContentList.push(content);
+		}
+	}
+	if (!props && parentStyleContent) styleContentList.push(parentStyleContent);
+	const attributePropContent = styleContentList.join(";");
+	if (attributePropContent) {
+		const codegenProps = getCodegenNodeProps(node);
+		codegenProps.set("style", { content: attributePropContent });
+		setCodegenNode(node, {
+			type: node.type,
+			tag: node.tag,
+			props: codegenProps,
+			loc: node.loc
+		});
+	}
+}
+//#endregion
+//#region src/template/propTransformers.ts
+/**
+* 属性转换器 - 将 Vue 模板属性转换为小程序 WXML 属性
+*
+* 每个转换器接收一个属性，返回转换结果或 undefined（表示不处理）
+* 所有转换器在统一节点转换器中被调用，结果按优先级合并
+*/
+/**
+* 属性优先级常量
+*/
+const PROP_PRIORITIES = {
+	"wx:for": 100,
+	"wx:for-item": 100,
+	"wx:for-index": 100,
+	"wx:key": 100,
+	"wx:if": 100,
+	"wx:elif": 100,
+	"wx:else": 100,
+	hidden: 90,
+	class: 50,
+	style: 50,
+	id: 10,
+	src: 10,
+	href: 10,
+	_default: 0
+};
+/**
+* 获取属性优先级
+*/
+function getPriority(key) {
+	return Object.hasOwn(PROP_PRIORITIES, key) ? PROP_PRIORITIES[key] : PROP_PRIORITIES._default;
+}
+/**
+* 创建转换结果辅助函数
+*/
+function createResult(key, content, priority) {
+	return {
+		key,
+		value: { content },
+		priority: priority ?? getPriority(key)
+	};
+}
+/**
+* 从 v-for 指令中提取 forItem 和 forIndex
+* 公共逻辑，供 transformVForProp 共用
+*/
+function parseForVariables(prop, counter) {
+	const directive = prop;
+	if (!directive.forParseResult) return;
+	const forItem = directive.forParseResult.value?.type === NodeTypes.SIMPLE_EXPRESSION ? directive.forParseResult.value.content : "item";
+	return {
+		forItem,
+		forIndex: directive.forParseResult.key?.type === NodeTypes.SIMPLE_EXPRESSION ? directive.forParseResult.key.content : counter.generateVForIndexName(forItem)
+	};
+}
+/**
+* v-for 转换器
+* v-for="(item, index) in items" → wx:for="{{items}}" wx:for-item="item" wx:for-index="index" wx:key="..."
+*/
+function transformVForProp(prop, context) {
+	if (prop.type !== NodeTypes.DIRECTIVE || prop.name !== "for") return;
+	const directive = prop;
+	if (!directive.forParseResult) return;
+	const { content: arrayName } = getTemplateNodeProp(context.node, {
+		loc: directive.loc,
+		exp: directive.forParseResult.source
+	}, context.returnValue, context.counter, context.wxsExpressionStatements, context.ctx);
+	const forVars = parseForVariables(prop, context.counter);
+	if (!forVars) return void 0;
+	if (!(directive.forParseResult.key?.type === NodeTypes.SIMPLE_EXPRESSION)) directive.forParseResult.key = {
+		type: NodeTypes.SIMPLE_EXPRESSION,
+		content: forVars.forIndex,
+		isStatic: false,
+		constType: 0,
+		loc: directive.loc
+	};
+	const results = [createResult("wx:for", arrayName, PROP_PRIORITIES["wx:for"])];
+	if (forVars.forItem !== "item") results.push(createResult("wx:for-item", forVars.forItem, PROP_PRIORITIES["wx:for-item"]));
+	if (forVars.forIndex !== "index") results.push(createResult("wx:for-index", forVars.forIndex, PROP_PRIORITIES["wx:for-index"]));
+	return results;
+}
+/**
+* :key 转换器（配合 v-for 使用）
+* :key="item.id" → wx:key="id"
+*
+* 注意：wx:key 只支持 item 的直接属性名（如 "id"），不支持嵌套路径（如 "subRow.id"）。
+* 对于嵌套路径，输出 *this 作为回退并发出警告。
+*/
+function transformKeyProp(prop) {
+	if (prop.type === NodeTypes.DIRECTIVE && prop.name === "bind" && prop.arg?.type === NodeTypes.SIMPLE_EXPRESSION && prop.arg.content === "key") {
+		const rawKeyContent = prop.exp?.type === NodeTypes.SIMPLE_EXPRESSION ? prop.exp.content : void 0;
+		if (!rawKeyContent) return createResult("wx:key", void 0, PROP_PRIORITIES["wx:key"]);
+		if (/^\w+$/.test(rawKeyContent)) return createResult("wx:key", rawKeyContent, PROP_PRIORITIES["wx:key"]);
+		const simpleKeyMatch = rawKeyContent.match(/^(\w+)\.(\w+)$/);
+		if (simpleKeyMatch) return createResult("wx:key", simpleKeyMatch[2], PROP_PRIORITIES["wx:key"]);
+		console.warn(`[vms] wx:key 不支持复杂表达式 "${rawKeyContent}"，已回退为 "*this"。wx:key 仅支持 item 的直接属性名（如 "id"）。`);
+		return createResult("wx:key", "*this", PROP_PRIORITIES["wx:key"]);
+	}
+}
+/**
+* v-if/v-else-if/v-else 转换器
+*/
+function transformVIfProp(prop, context) {
+	if (prop.type !== NodeTypes.DIRECTIVE) return;
+	if (prop.name === "if") {
+		const { content } = getTemplateNodeProp(context.node, {
+			loc: prop.loc,
+			exp: prop.exp
+		}, context.returnValue, context.counter, context.wxsExpressionStatements, context.ctx);
+		return createResult("wx:if", content, PROP_PRIORITIES["wx:if"]);
+	}
+	if (prop.name === "else-if") {
+		const { content } = getTemplateNodeProp(context.node, {
+			loc: prop.loc,
+			exp: prop.exp
+		}, context.returnValue, context.counter, context.wxsExpressionStatements, context.ctx);
+		return createResult("wx:elif", content, PROP_PRIORITIES["wx:elif"]);
+	}
+	if (prop.name === "else") return createResult("wx:else", void 0, PROP_PRIORITIES["wx:else"]);
+}
+/**
+* v-show 转换器
+* v-show="condition" → hidden="{{!condition}}"
+*/
+function transformVShowProp(prop, context) {
+	if (prop.type !== NodeTypes.DIRECTIVE || prop.name !== "show") return;
+	const { content } = getTemplateNodeProp(context.node, {
+		loc: prop.loc,
+		exp: prop.exp
+	}, context.returnValue, context.counter, context.wxsExpressionStatements, context.ctx);
+	return createResult("hidden", `{{!(${content?.slice(2, -2) || ""})}}`, PROP_PRIORITIES["hidden"]);
+}
+const SPECIAL_ATTRS_BIND = [
+	"class",
+	"style",
+	"key"
+];
+/**
+* 普通属性绑定转换器
+* :id="dynamicId" → id="{{dynamicId}}"
+* 复杂表达式会生成 WXS 函数
+*/
+function transformBindProp(prop, context) {
+	if (prop.type === NodeTypes.DIRECTIVE && prop.name === "bind" && prop.arg?.type === NodeTypes.SIMPLE_EXPRESSION) {
+		const attrName = prop.arg.content;
+		if (SPECIAL_ATTRS_BIND.includes(attrName)) return;
+		if (prop.exp?.type === NodeTypes.SIMPLE_EXPRESSION) {
+			const { content } = getTemplateNodeProp(context.node, {
+				exp: prop.exp,
+				loc: prop.loc
+			}, context.returnValue, context.counter, context.wxsExpressionStatements, context.ctx);
+			return createResult(attrName, content, 20);
+		}
+	}
+}
+const SPECIAL_ATTRS_STATIC = ["class", "style"];
+/**
+* 静态属性转换器
+* id="foo" → id="foo"
+*/
+function transformStaticProp(prop) {
+	if (prop.type === NodeTypes.ATTRIBUTE) {
+		if (SPECIAL_ATTRS_STATIC.includes(prop.name)) return;
+		return createResult(prop.name, prop.value?.content, getPriority(prop.name));
+	}
+}
+/**
+* 所有属性转换器列表（按优先级排序）
+*/
+const propTransformers = [
+	transformVForProp,
+	transformKeyProp,
+	transformVIfProp,
+	transformVShowProp,
+	transformBindProp,
+	transformStaticProp
+];
+/**
+* 按优先级合并属性转换结果
+* 高优先级覆盖低优先级
+*/
+function mergePropResults(results) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const result of results) {
+		const existing = grouped.get(result.key) || [];
+		existing.push(result);
+		grouped.set(result.key, existing);
+	}
+	const merged = /* @__PURE__ */ new Map();
+	for (const [key, group] of grouped) {
+		const highest = group.reduce((max, current) => current.priority > max.priority ? current : max);
+		merged.set(key, highest.value);
+	}
+	return merged;
+}
+//#endregion
+//#region src/template/index.ts
+function parseTemplate(templateAST, filePath, isPage = false, scriptScope) {
+	const ctx = createVMSTransformContext(scriptScope);
+	const counter = {
+		wxsFunctionCounter: 0,
+		functionPropertyCounter: 0,
+		nodeDataKeyIndex: 0,
+		vForIndexCounter: 0,
+		generateWxsFunctionName() {
+			return `__wxs_${this.wxsFunctionCounter++}`;
+		},
+		generateFunctionPropertyName() {
+			return `__fun_${this.functionPropertyCounter++}`;
+		},
+		generateVForIndexName(forItem) {
+			return `_${forItem}_${this.vForIndexCounter++}_index`;
+		}
+	};
+	const wxsExpressionStatements = [];
+	const returnValue = t$1.objectExpression([]);
+	const thirdPartyComponents = /* @__PURE__ */ new Map();
+	assignVForInfoListMinimal(templateAST, ctx);
+	const unifiedTransform = createUnifiedNodeTransform(returnValue, counter, wxsExpressionStatements, ctx);
+	traverseNode(templateAST, createTransformContext(templateAST, { nodeTransforms: [
+		...getComponentMatcher.hasConfig() ? [(node) => collectThirdComponents(node, thirdPartyComponents)] : [],
+		(node) => transformSlotsAndTemplate(node),
+		(node) => transformTemplateClass(node, returnValue, counter, wxsExpressionStatements, ctx, isPage),
+		(node) => transformTemplateStyle(node, returnValue, counter, wxsExpressionStatements, ctx, isPage),
+		unifiedTransform,
+		(node) => transformEventHandlers(node, returnValue, counter, ctx),
+		createRootNodeTransform()
+	] }));
+	return {
+		wxmlContent: generateWxml(generateWxsScripts(wxsExpressionStatements, filePath), templateAST),
+		returnValue,
+		thirdPartyComponents,
+		bridgedFunctions: ctx.bridgedFunctions,
+		internalVars: ctx.internalVars,
+		renderVars: ctx.renderVars,
+		needsProxyRefs: ctx.needsProxyRefs
+	};
+}
+/**
+* 创建统一节点转换器
+* 在单次遍历中完成属性转换和 codegenNode 构建
+*/
+function createUnifiedNodeTransform(returnValue, counter, wxsExpressionStatements, ctx) {
+	const propResultsMap = /* @__PURE__ */ new WeakMap();
+	return (node) => {
+		if (node.type === NodeTypes.INTERPOLATION) {
+			const interpolationNode = node;
+			if (interpolationNode.content?.type === NodeTypes.SIMPLE_EXPRESSION) {
+				const { content } = getTemplateNodeProp(node, {
+					exp: interpolationNode.content,
+					loc: node.loc
+				}, returnValue, counter, wxsExpressionStatements, ctx);
+				setCodegenNode(node, {
+					type: NodeTypes.INTERPOLATION,
+					content,
+					loc: node.loc
+				});
+			}
+			return;
+		}
+		if (node.type === NodeTypes.TEXT || node.type === NodeTypes.COMMENT) {
+			const codegenNode = createSimpleCodegenNode(node);
+			if (codegenNode) setCodegenNode(node, codegenNode);
+			return;
+		}
+		if (node.type !== NodeTypes.ELEMENT) return;
+		const elementNode = node;
+		const transformCtx = {
+			returnValue,
+			counter,
+			wxsExpressionStatements,
+			ctx,
+			node: elementNode
+		};
+		const propResults = [];
+		for (const prop of elementNode.props || []) for (const transformer of propTransformers) {
+			const result = transformer(prop, transformCtx);
+			if (result) {
+				if (Array.isArray(result)) propResults.push(...result);
+				else propResults.push(result);
+				break;
+			}
+		}
+		propResultsMap.set(node, propResults);
+		return () => {
+			const children = [];
+			for (const child of elementNode.children || []) {
+				const childCodegen = getCodegenNode(child);
+				if (childCodegen) children.push(childCodegen);
+			}
+			const finalProps = mergePropResults(propResultsMap.get(node) || []);
+			const existingCodegen = getCodegenNode(node);
+			if (existingCodegen?.props) for (const [key, value] of existingCodegen.props) finalProps.set(key, value);
+			setCodegenNode(node, {
+				type: NodeTypes.ELEMENT,
+				tag: elementNode.tag,
+				props: finalProps,
+				children,
+				loc: elementNode.loc
+			});
+		};
+	};
+}
+/**
+* 为非元素节点创建 codegenNode
+*/
+function createSimpleCodegenNode(node) {
+	switch (node.type) {
+		case NodeTypes.TEXT: return {
+			type: NodeTypes.TEXT,
+			content: node.content,
+			loc: node.loc
+		};
+		case NodeTypes.INTERPOLATION: {
+			const content = node.content?.type === NodeTypes.SIMPLE_EXPRESSION ? `{{${node.content.content}}}` : `无法转译`;
+			return {
+				type: NodeTypes.INTERPOLATION,
+				content,
+				loc: node.loc
+			};
+		}
+		case NodeTypes.COMMENT: return {
+			type: NodeTypes.COMMENT,
+			content: node.content,
+			loc: node.loc
+		};
+		default: return null;
+	}
+}
+/**
+* 创建根节点转换器
+* 在遍历结束时构建根节点的 codegenNode
+*/
+function createRootNodeTransform() {
+	return (node) => {
+		if (node.type !== NodeTypes.ROOT) return;
+		return () => {
+			const rootNode = node;
+			const children = [];
+			for (const child of rootNode.children || []) {
+				const childCodegen = getCodegenNode(child);
+				if (childCodegen) children.push(childCodegen);
+			}
+			setCodegenNode(node, {
+				type: NodeTypes.ROOT,
+				children,
+				loc: node.loc
+			});
+		};
+	};
+}
+function generateWxsScripts(wxsFunctions, filePath) {
+	if (wxsFunctions.length > 0) {
+		let hasArrayUtils = false;
+		const functionsCode = wxsFunctions.map((stmt) => {
+			const code = generate(stmt, { jsescOption: { quotes: "single" } }).code;
+			if (!hasArrayUtils) code.includes("__vmsWXSUtils.") && (hasArrayUtils = true);
+			return code;
+		});
+		if (hasArrayUtils) functionsCode.unshift(`var __vmsWXSUtils = require("${getPolyfillFileRelativePath("wxsUtils.wxs", filePath)}");`);
+		return `<wxs module="${WXS_NAMESPACE}">\n${functionsCode.join("\n")}</wxs>\n`;
+	}
+}
+//#endregion
+//#region src/utils/merge.ts
+/**
+* 深度合并两个普通对象，合并规则：
+* 1. 类型不同：新值覆盖旧值
+* 2. 都是普通对象：递归合并（取并集）
+* 3. 都是数组：取并集（去重）
+* 4. 同类型原始值：新值覆盖旧值
+*/
+function deepMerge(target, source) {
+	const result = { ...target };
+	for (const key of Object.keys(source)) {
+		const srcVal = source[key];
+		const tgtVal = result[key];
+		if (!(key in result)) result[key] = srcVal;
+		else if (!isSameCompositeType(tgtVal, srcVal)) result[key] = srcVal;
+		else if (isPlainObject(tgtVal) && isPlainObject(srcVal)) result[key] = deepMerge(tgtVal, srcVal);
+		else if (Array.isArray(tgtVal) && Array.isArray(srcVal)) result[key] = arrayUnion(tgtVal, srcVal);
+		else result[key] = srcVal;
+	}
+	return result;
+}
+function isPlainObject(val) {
+	return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+function isSameCompositeType(a, b) {
+	if (Array.isArray(a) && Array.isArray(b)) return true;
+	if (isPlainObject(a) && isPlainObject(b)) return true;
+	return false;
+}
+function arrayUnion(a, b) {
+	const seen = new Set(a.map(serialize));
+	const result = [...a];
+	for (const item of b) if (!seen.has(serialize(item))) {
+		result.push(item);
+		seen.add(serialize(item));
+	}
+	return result;
+}
+function serialize(val) {
+	return JSON.stringify(val);
+}
+//#endregion
+//#region src/transformer.ts
+const srcDir = join(process.cwd(), userConfig.sourceDir);
+function resolveComponentPath(importPath) {
+	if (importPath.startsWith("@/")) return importPath.replace("@/", "/");
+	return importPath;
+}
+function generateUsingComponents(imports, thirdPartyComponents) {
+	const usingComponents = {};
+	imports.forEach((imp) => {
+		if (imp.path.endsWith(".vue")) {
+			const componentName = imp.name;
+			usingComponents[componentName] = resolveComponentPath(imp.path).replace(/\.vue$/, "");
+		}
+	});
+	thirdPartyComponents.forEach((value, key) => {
+		usingComponents[key] = value;
+	});
+	return usingComponents;
+}
+async function transformVueToMiniProgram(filePath, outputDir, isPage = false, cb) {
+	const { descriptor } = parse(readFileSync(filePath, "utf-8"), {
+		filename: filePath,
+		templateParseOptions: { comments: false }
+	});
+	const { template, scriptSetup, styles } = descriptor;
+	if (!template?.ast) return;
+	try {
+		const scriptScope = !scriptSetup ? createEmptyScriptScope() : analyzeScriptScope(scriptSetup.content, filePath);
+		const { wxmlContent, returnValue, thirdPartyComponents, bridgedFunctions, internalVars, renderVars, needsProxyRefs } = parseTemplate(template.ast, filePath, isPage, scriptScope);
+		const result = await parseScript(descriptor, returnValue, bridgedFunctions, internalVars, renderVars, needsProxyRefs, isPage, scriptScope);
+		const css = parseStyles(styles);
+		const componentDir = join(outputDir, relative(srcDir, dirname(filePath)));
+		if (!existsSync(componentDir)) await mkdir(componentDir, { recursive: true });
+		const baseJsonConfig = {
+			component: true,
+			styleIsolation: isPage ? "shared" : "apply-shared",
+			usingComponents: generateUsingComponents(result.vueComponentImports, thirdPartyComponents)
+		};
+		const jsonConfig = result.defineOptionsObject ? deepMerge(baseJsonConfig, result.defineOptionsObject) : baseJsonConfig;
+		const script = await cb(result.script);
+		const componentName = basename(filePath, ".vue");
+		const wxmlPath = join(componentDir, `${componentName}.wxml`);
+		const jsPath = join(componentDir, `${componentName}.js`);
+		const wxssPath = join(componentDir, `${componentName}.wxss`);
+		const jsonPath = join(componentDir, `${componentName}.json`);
+		const jsonContent = JSON.stringify(jsonConfig, null, 2);
+		return Promise.all([
+			writeFileIfChangedAsync(wxmlPath, wxmlContent),
+			writeFileIfChangedAsync(jsPath, script),
+			writeFileIfChangedAsync(wxssPath, css),
+			writeFileIfChangedAsync(jsonPath, jsonContent)
+		]);
+	} catch (e) {
+		handleCompileError(descriptor.source, e, filePath);
+		return Promise.reject(e);
+	}
+}
+function streamHash(filePath) {
+	return new Promise((resolve, reject) => {
+		const hash = createHash("md5");
+		const stream = createReadStream(filePath);
+		stream.on("data", (chunk) => hash.update(chunk));
+		stream.on("end", () => resolve(hash.digest("hex")));
+		stream.on("error", reject);
+	});
+}
+function stringHash(content) {
+	return createHash("md5").update(content).digest("hex");
+}
+async function writeFileIfChangedAsync(filePath, newContent) {
+	try {
+		if (!existsSync(filePath)) {
+			await writeFile(filePath, newContent, "utf-8");
+			return;
+		}
+		const existingStat = await stat(filePath);
+		const newContentLength = Buffer.byteLength(newContent, "utf8");
+		if (existingStat.size !== newContentLength) {
+			await writeFile(filePath, newContent, "utf-8");
+			return;
+		}
+		const [existingHash, newHash] = await Promise.all([streamHash(filePath), Promise.resolve(stringHash(newContent))]);
+		if (existingHash === newHash) return;
+		await writeFile(filePath, newContent, "utf-8");
+	} catch (error) {
+		console.error(`❌ 写入文件失败 ${filePath}:`, getErrorMessage(error));
+		throw error;
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/rolldown@1.0.0/node_modules/rolldown/dist/shared/binding-ESkOU1xr.mjs
+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 __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+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));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+var require_webcontainer_fallback = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = __require("node:fs");
+	const childProcess = __require("node:child_process");
+	const version = JSON.parse(fs.readFileSync(__require.resolve("rolldown/package.json"), "utf-8")).version;
+	const baseDir = `/tmp/rolldown-${version}`;
+	const bindingEntry = `${baseDir}/node_modules/@rolldown/binding-wasm32-wasi/rolldown-binding.wasi.cjs`;
+	if (!fs.existsSync(bindingEntry)) {
+		const bindingPkg = `@rolldown/binding-wasm32-wasi@${version}`;
+		fs.rmSync(baseDir, {
+			recursive: true,
+			force: true
+		});
+		fs.mkdirSync(baseDir, { recursive: true });
+		console.log(`[rolldown] Downloading ${bindingPkg} on WebContainer...`);
+		childProcess.execFileSync("pnpm", ["i", bindingPkg], {
+			cwd: baseDir,
+			stdio: "inherit"
+		});
+	}
+	module.exports = __require(bindingEntry);
+}));
+var require_binding = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { readFileSync } = __require("node:fs");
+	let nativeBinding = null;
+	const loadErrors = [];
+	const isMusl = () => {
+		let musl = false;
+		if (process.platform === "linux") {
+			musl = isMuslFromFilesystem();
+			if (musl === null) musl = isMuslFromReport();
+			if (musl === null) musl = isMuslFromChildProcess();
+		}
+		return musl;
+	};
+	const isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+	const isMuslFromFilesystem = () => {
+		try {
+			return readFileSync("/usr/bin/ldd", "utf-8").includes("musl");
+		} catch {
+			return null;
+		}
+	};
+	const isMuslFromReport = () => {
+		let report = null;
+		if (typeof process.report?.getReport === "function") {
+			process.report.excludeNetwork = true;
+			report = process.report.getReport();
+		}
+		if (!report) return null;
+		if (report.header && report.header.glibcVersionRuntime) return false;
+		if (Array.isArray(report.sharedObjects)) {
+			if (report.sharedObjects.some(isFileMusl)) return true;
+		}
+		return false;
+	};
+	const isMuslFromChildProcess = () => {
+		try {
+			return __require("child_process").execSync("ldd --version", { encoding: "utf8" }).includes("musl");
+		} catch (e) {
+			return false;
+		}
+	};
+	function requireNative() {
+		if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) try {
+			return __require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+		} catch (err) {
+			loadErrors.push(err);
+		}
+		else if (process.platform === "android") if (process.arch === "arm64") {
+			try {
+				return __require("./rolldown-binding.android-arm64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-android-arm64");
+				const bindingPackageVersion = __require("@rolldown/binding-android-arm64/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm") {
+			try {
+				return __require("./rolldown-binding.android-arm-eabi.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-android-arm-eabi");
+				const bindingPackageVersion = __require("@rolldown/binding-android-arm-eabi/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on Android ${process.arch}`));
+		else if (process.platform === "win32") if (process.arch === "x64") if (process.config?.variables?.shlib_suffix === "dll.a" || process.config?.variables?.node_target_type === "shared_library") {
+			try {
+				return __require("./rolldown-binding.win32-x64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-win32-x64-gnu");
+				const bindingPackageVersion = __require("@rolldown/binding-win32-x64-gnu/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			try {
+				return __require("./rolldown-binding.win32-x64-msvc.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-win32-x64-msvc");
+				const bindingPackageVersion = __require("@rolldown/binding-win32-x64-msvc/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		}
+		else if (process.arch === "ia32") {
+			try {
+				return __require("./rolldown-binding.win32-ia32-msvc.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-win32-ia32-msvc");
+				const bindingPackageVersion = __require("@rolldown/binding-win32-ia32-msvc/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm64") {
+			try {
+				return __require("./rolldown-binding.win32-arm64-msvc.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-win32-arm64-msvc");
+				const bindingPackageVersion = __require("@rolldown/binding-win32-arm64-msvc/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on Windows: ${process.arch}`));
+		else if (process.platform === "darwin") {
+			try {
+				return __require("./rolldown-binding.darwin-universal.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-darwin-universal");
+				const bindingPackageVersion = __require("@rolldown/binding-darwin-universal/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			if (process.arch === "x64") {
+				try {
+					return __require("./rolldown-binding.darwin-x64.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = __require("@rolldown/binding-darwin-x64");
+					const bindingPackageVersion = __require("@rolldown/binding-darwin-x64/package.json").version;
+					if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else if (process.arch === "arm64") {
+				try {
+					return __require("./rolldown-binding.darwin-arm64.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = __require("@rolldown/binding-darwin-arm64");
+					const bindingPackageVersion = __require("@rolldown/binding-darwin-arm64/package.json").version;
+					if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on macOS: ${process.arch}`));
+		} else if (process.platform === "freebsd") if (process.arch === "x64") {
+			try {
+				return __require("./rolldown-binding.freebsd-x64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-freebsd-x64");
+				const bindingPackageVersion = __require("@rolldown/binding-freebsd-x64/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm64") {
+			try {
+				return __require("./rolldown-binding.freebsd-arm64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-freebsd-arm64");
+				const bindingPackageVersion = __require("@rolldown/binding-freebsd-arm64/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on FreeBSD: ${process.arch}`));
+		else if (process.platform === "linux") if (process.arch === "x64") if (isMusl()) {
+			try {
+				return __require("./rolldown-binding.linux-x64-musl.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-x64-musl");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-x64-musl/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			try {
+				return __require("../rolldown-binding.linux-x64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-x64-gnu");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-x64-gnu/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		}
+		else if (process.arch === "arm64") if (isMusl()) {
+			try {
+				return __require("./rolldown-binding.linux-arm64-musl.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-arm64-musl");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-arm64-musl/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			try {
+				return __require("./rolldown-binding.linux-arm64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-arm64-gnu");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-arm64-gnu/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		}
+		else if (process.arch === "arm") if (isMusl()) {
+			try {
+				return __require("./rolldown-binding.linux-arm-musleabihf.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-arm-musleabihf");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-arm-musleabihf/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			try {
+				return __require("./rolldown-binding.linux-arm-gnueabihf.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-arm-gnueabihf");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-arm-gnueabihf/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		}
+		else if (process.arch === "loong64") if (isMusl()) {
+			try {
+				return __require("./rolldown-binding.linux-loong64-musl.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-loong64-musl");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-loong64-musl/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			try {
+				return __require("./rolldown-binding.linux-loong64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-loong64-gnu");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-loong64-gnu/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		}
+		else if (process.arch === "riscv64") if (isMusl()) {
+			try {
+				return __require("./rolldown-binding.linux-riscv64-musl.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-riscv64-musl");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-riscv64-musl/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			try {
+				return __require("./rolldown-binding.linux-riscv64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-riscv64-gnu");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-riscv64-gnu/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		}
+		else if (process.arch === "ppc64") {
+			try {
+				return __require("./rolldown-binding.linux-ppc64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-ppc64-gnu");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-ppc64-gnu/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "s390x") {
+			try {
+				return __require("./rolldown-binding.linux-s390x-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-s390x-gnu");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-s390x-gnu/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on Linux: ${process.arch}`));
+		else if (process.platform === "openharmony") if (process.arch === "arm64") {
+			try {
+				return __require("./rolldown-binding.openharmony-arm64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-openharmony-arm64");
+				const bindingPackageVersion = __require("@rolldown/binding-openharmony-arm64/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "x64") {
+			try {
+				return __require("./rolldown-binding.openharmony-x64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-openharmony-x64");
+				const bindingPackageVersion = __require("@rolldown/binding-openharmony-x64/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm") {
+			try {
+				return __require("./rolldown-binding.openharmony-arm.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-openharmony-arm");
+				const bindingPackageVersion = __require("@rolldown/binding-openharmony-arm/package.json").version;
+				if (bindingPackageVersion !== "1.0.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`));
+		else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
+	}
+	nativeBinding = requireNative();
+	if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+		let wasiBinding = null;
+		let wasiBindingError = null;
+		try {
+			wasiBinding = __require("../rolldown-binding.wasi.cjs");
+			nativeBinding = wasiBinding;
+		} catch (err) {
+			if (process.env.NAPI_RS_FORCE_WASI) wasiBindingError = err;
+		}
+		if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) try {
+			wasiBinding = __require("@rolldown/binding-wasm32-wasi");
+			nativeBinding = wasiBinding;
+		} catch (err) {
+			if (process.env.NAPI_RS_FORCE_WASI) {
+				if (!wasiBindingError) wasiBindingError = err;
+				else wasiBindingError.cause = err;
+				loadErrors.push(err);
+			}
+		}
+		if (process.env.NAPI_RS_FORCE_WASI === "error" && !wasiBinding) {
+			const error = /* @__PURE__ */ new Error("WASI binding not found and NAPI_RS_FORCE_WASI is set to error");
+			error.cause = wasiBindingError;
+			throw error;
+		}
+	}
+	if (!nativeBinding && globalThis.process?.versions?.["webcontainer"]) try {
+		nativeBinding = require_webcontainer_fallback();
+	} catch (err) {
+		loadErrors.push(err);
+	}
+	if (!nativeBinding) {
+		if (loadErrors.length > 0) throw new Error("Cannot find native binding. npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). Please try `npm i` again after removing both package-lock.json and node_modules directory.", { cause: loadErrors.reduce((err, cur) => {
+			cur.cause = err;
+			return cur;
+		}) });
+		throw new Error(`Failed to load native binding`);
+	}
+	module.exports = nativeBinding;
+	module.exports.minify = nativeBinding.minify;
+	module.exports.minifySync = nativeBinding.minifySync;
+	module.exports.Severity = nativeBinding.Severity;
+	module.exports.ParseResult = nativeBinding.ParseResult;
+	module.exports.ExportExportNameKind = nativeBinding.ExportExportNameKind;
+	module.exports.ExportImportNameKind = nativeBinding.ExportImportNameKind;
+	module.exports.ExportLocalNameKind = nativeBinding.ExportLocalNameKind;
+	module.exports.ImportNameKind = nativeBinding.ImportNameKind;
+	module.exports.parse = nativeBinding.parse;
+	module.exports.parseSync = nativeBinding.parseSync;
+	module.exports.rawTransferSupported = nativeBinding.rawTransferSupported;
+	module.exports.ResolverFactory = nativeBinding.ResolverFactory;
+	module.exports.EnforceExtension = nativeBinding.EnforceExtension;
+	module.exports.ModuleType = nativeBinding.ModuleType;
+	module.exports.sync = nativeBinding.sync;
+	module.exports.HelperMode = nativeBinding.HelperMode;
+	module.exports.isolatedDeclaration = nativeBinding.isolatedDeclaration;
+	module.exports.isolatedDeclarationSync = nativeBinding.isolatedDeclarationSync;
+	module.exports.moduleRunnerTransform = nativeBinding.moduleRunnerTransform;
+	module.exports.moduleRunnerTransformSync = nativeBinding.moduleRunnerTransformSync;
+	module.exports.transform = nativeBinding.transform;
+	module.exports.transformSync = nativeBinding.transformSync;
+	module.exports.BindingBundleEndEventData = nativeBinding.BindingBundleEndEventData;
+	module.exports.BindingBundleErrorEventData = nativeBinding.BindingBundleErrorEventData;
+	module.exports.BindingBundler = nativeBinding.BindingBundler;
+	module.exports.BindingCallableBuiltinPlugin = nativeBinding.BindingCallableBuiltinPlugin;
+	module.exports.BindingChunkingContext = nativeBinding.BindingChunkingContext;
+	module.exports.BindingDecodedMap = nativeBinding.BindingDecodedMap;
+	module.exports.BindingDevEngine = nativeBinding.BindingDevEngine;
+	module.exports.BindingLoadPluginContext = nativeBinding.BindingLoadPluginContext;
+	module.exports.BindingMagicString = nativeBinding.BindingMagicString;
+	module.exports.BindingModuleInfo = nativeBinding.BindingModuleInfo;
+	module.exports.BindingNormalizedOptions = nativeBinding.BindingNormalizedOptions;
+	module.exports.BindingOutputAsset = nativeBinding.BindingOutputAsset;
+	module.exports.BindingOutputChunk = nativeBinding.BindingOutputChunk;
+	module.exports.BindingPluginContext = nativeBinding.BindingPluginContext;
+	module.exports.BindingRenderedChunk = nativeBinding.BindingRenderedChunk;
+	module.exports.BindingRenderedChunkMeta = nativeBinding.BindingRenderedChunkMeta;
+	module.exports.BindingRenderedModule = nativeBinding.BindingRenderedModule;
+	module.exports.BindingSourceMap = nativeBinding.BindingSourceMap;
+	module.exports.BindingTransformPluginContext = nativeBinding.BindingTransformPluginContext;
+	module.exports.BindingWatcher = nativeBinding.BindingWatcher;
+	module.exports.BindingWatcherBundler = nativeBinding.BindingWatcherBundler;
+	module.exports.BindingWatcherChangeData = nativeBinding.BindingWatcherChangeData;
+	module.exports.BindingWatcherEvent = nativeBinding.BindingWatcherEvent;
+	module.exports.ParallelJsPluginRegistry = nativeBinding.ParallelJsPluginRegistry;
+	module.exports.ScheduledBuild = nativeBinding.ScheduledBuild;
+	module.exports.TraceSubscriberGuard = nativeBinding.TraceSubscriberGuard;
+	module.exports.TsconfigCache = nativeBinding.TsconfigCache;
+	module.exports.BindingAttachDebugInfo = nativeBinding.BindingAttachDebugInfo;
+	module.exports.BindingBuiltinPluginName = nativeBinding.BindingBuiltinPluginName;
+	module.exports.BindingChunkModuleOrderBy = nativeBinding.BindingChunkModuleOrderBy;
+	module.exports.BindingLogLevel = nativeBinding.BindingLogLevel;
+	module.exports.BindingPluginOrder = nativeBinding.BindingPluginOrder;
+	module.exports.BindingPropertyReadSideEffects = nativeBinding.BindingPropertyReadSideEffects;
+	module.exports.BindingPropertyWriteSideEffects = nativeBinding.BindingPropertyWriteSideEffects;
+	module.exports.BindingRebuildStrategy = nativeBinding.BindingRebuildStrategy;
+	module.exports.collapseSourcemaps = nativeBinding.collapseSourcemaps;
+	module.exports.enhancedTransform = nativeBinding.enhancedTransform;
+	module.exports.enhancedTransformSync = nativeBinding.enhancedTransformSync;
+	module.exports.FilterTokenKind = nativeBinding.FilterTokenKind;
+	module.exports.initTraceSubscriber = nativeBinding.initTraceSubscriber;
+	module.exports.registerPlugins = nativeBinding.registerPlugins;
+	module.exports.resolveTsconfig = nativeBinding.resolveTsconfig;
+	module.exports.shutdownAsyncRuntime = nativeBinding.shutdownAsyncRuntime;
+	module.exports.startAsyncRuntime = nativeBinding.startAsyncRuntime;
+}));
+//#endregion
+//#region node_modules/.pnpm/rolldown@1.0.0/node_modules/rolldown/dist/shared/logs-D80CXhvg.mjs
+const PLUGIN_ERROR = "PLUGIN_ERROR";
+function logPluginError(error, plugin, { hook, id } = {}) {
+	try {
+		const code = error.code;
+		if (!error.pluginCode && code != null && (typeof code !== "string" || !code.startsWith("PLUGIN_"))) error.pluginCode = code;
+		error.code = PLUGIN_ERROR;
+		error.plugin = plugin;
+		if (hook) error.hook = hook;
+		if (id) error.id = id;
+	} catch (_) {} finally {
+		return error;
+	}
+}
+function error(base) {
+	if (!(base instanceof Error)) {
+		base = Object.assign(new Error(base.message), base);
+		Object.defineProperty(base, "name", {
+			value: "RolldownError",
+			writable: true
+		});
+	}
+	throw base;
+}
+//#endregion
+//#region node_modules/.pnpm/rolldown@1.0.0/node_modules/rolldown/dist/shared/normalize-string-or-regex-dAjLOSbp.mjs
+var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
+var BuiltinPlugin = class {
+	name;
+	_options;
+	/** Vite-specific option to control plugin ordering */
+	enforce;
+	constructor(name, _options) {
+		this.name = name;
+		this._options = _options;
+	}
+};
+function makeBuiltinPluginCallable(plugin) {
+	let callablePlugin = new import_binding.BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
+	const wrappedPlugin = plugin;
+	for (const key in callablePlugin) {
+		const wrappedHook = async function(...args) {
+			try {
+				return await callablePlugin[key](...args);
+			} catch (e) {
+				if (e instanceof Error && !e.stack?.includes("at ")) Error.captureStackTrace(e, wrappedPlugin[key]);
+				return error(logPluginError(e, plugin.name, {
+					hook: key,
+					id: key === "transform" ? args[2] : void 0
+				}));
+			}
+		};
+		const order = callablePlugin.getOrder(key);
+		if (order == void 0) wrappedPlugin[key] = wrappedHook;
+		else wrappedPlugin[key] = {
+			handler: wrappedHook,
+			order
+		};
+	}
+	return wrappedPlugin;
+}
+function bindingifyBuiltInPlugin(plugin) {
+	return {
+		__name: plugin.name,
+		options: plugin._options
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/rolldown@1.0.0/node_modules/rolldown/dist/plugins-index.mjs
+/**
+* Replaces targeted strings in files while bundling.
+*
+* @example
+* **Basic usage**
+* ```js
+* replacePlugin({
+*   'process.env.NODE_ENV': JSON.stringify('production'),
+*    __buildVersion: 15
+* })
+* ```
+* @example
+* **With options**
+* ```js
+* replacePlugin({
+*   'process.env.NODE_ENV': JSON.stringify('production'),
+*   __buildVersion: 15
+* }, {
+*   preventAssignment: false,
+* })
+* ```
+*
+* @see https://rolldown.rs/builtin-plugins/replace
+* @category Builtin Plugins
+*/
+function replacePlugin(values = {}, options = {}) {
+	Object.keys(values).forEach((key) => {
+		const value = values[key];
+		if (typeof value !== "string") values[key] = String(value);
+	});
+	return makeBuiltinPluginCallable(new BuiltinPlugin("builtin:replace", {
+		...options,
+		values
+	}));
+}
+//#endregion
+//#region src/cli.ts
+const NODE_ENV = process$1.env.NODE_ENV || "production";
+let pagePaths = null;
+const pageComponentCache = /* @__PURE__ */ new Map();
+/**
+* 清空所有缓存（在 app.json 变更时调用）
+*/
+function clearAllCaches() {
+	pagePaths = null;
+	pageComponentCache.clear();
+	pathCache.clear();
+}
+/**
+* 读取 app.json 并生成页面路径列表
+* 页面路径格式: pages/index/Index 或 subHome/pages/home/HomeIndex
+*/
+async function loadPagePaths() {
+	if (pagePaths) return pagePaths;
+	const appJsonPath = path.join(sourceDir, "app.json");
+	pagePaths = /* @__PURE__ */ new Set();
+	try {
+		const appJson = await fs$1.readJson(appJsonPath);
+		if (appJson.pages) for (const page of appJson.pages) pagePaths.add(page);
+		if (appJson.subPackages) for (const pkg of appJson.subPackages) {
+			const root = pkg.root;
+			for (const page of pkg.pages) pagePaths.add(`${root}/${page}`);
+		}
+		console.log(bold(green(`加载到 ${pagePaths.size} 个页面路径`)));
+	} catch (error) {
+		console.warn("读取 app.json 失败:", getErrorMessage(error));
+	}
+	return pagePaths;
+}
+/**
+* 判断文件路径是否为页面组件
+* @param filePath 文件路径，如 src/pages/index/Index.vue
+* @returns 是否为页面组件
+*/
+function isPageComponent(filePath) {
+	const cached = pageComponentCache.get(filePath);
+	if (typeof cached === "boolean") return cached;
+	if (!pagePaths || pagePaths.size === 0) {
+		pageComponentCache.set(filePath, false);
+		return false;
+	}
+	const normalizedPath = path.relative(sourceDir, filePath).replace(/\.vue$/, "");
+	const isPage = pagePaths.has(normalizedPath);
+	pageComponentCache.set(filePath, isPage);
+	return isPage;
+}
+const sourceDir = userConfig.sourceDir;
+const copyOnlyPatterns = userConfig.copyOnly ?? [];
+function isCopyOnly(filePath) {
+	if (filePath.endsWith(".min.js")) return true;
+	return copyOnlyPatterns.some((pattern) => filePath.includes(pattern));
+}
+const aliasPath = userConfig.alias?.["@"] || `./${sourceDir}`;
+if (config.plugins) {
+	const moduleResolverPlugin = config.plugins.find((plugin) => Array.isArray(plugin) && plugin[0] === "module-resolver");
+	if (moduleResolverPlugin && Array.isArray(moduleResolverPlugin) && moduleResolverPlugin[1] && typeof moduleResolverPlugin[1] === "object") {
+		const options = moduleResolverPlugin[1];
+		if (options.alias) options.alias["@"] = aliasPath;
+	}
+}
+let topLevelJobs = [];
+let bundleJobs = [];
+const startTime = Date.now();
+let __PROD__ = false;
+let independentPackages = [];
+const IGNORED_FILES = (file, stats) => {
+	if (!stats?.isFile()) return false;
+	return file.endsWith(".gitkeep") || file.endsWith(".DS_Store") || file.endsWith(".d.ts") || /[\\/]node_modules[\\/]/.test(file) || /[\\/]\.git[\\/]/.test(file);
+};
+const CONCURRENT_LIMIT = Math.max(4, os.cpus().length * 2 - 1);
+async function batchProcess(items, processor, concurrency = CONCURRENT_LIMIT) {
+	if (items.length === 0) return;
+	let index = 0;
+	let running = 0;
+	let completed = 0;
+	const total = items.length;
+	let hasError = false;
+	return new Promise((resolve, reject) => {
+		const runNext = async () => {
+			while (index < total && running < concurrency && !hasError) {
+				const currentIndex = index++;
+				running++;
+				processor(items[currentIndex]).catch((error) => {
+					console.error(`处理失败 [${items[currentIndex]}]:`, error);
+					hasError = true;
+				}).finally(() => {
+					running--;
+					completed++;
+					if (completed === total) if (hasError) reject(/* @__PURE__ */ new Error("部分任务处理失败"));
+					else resolve();
+					else if (!hasError) runNext();
+				});
+			}
+		};
+		runNext();
+	});
+}
+const pathCache = /* @__PURE__ */ new Map();
+function getOutputPath(inputPath) {
+	let cached = pathCache.get(inputPath);
+	if (!cached) {
+		cached = inputPath.startsWith(sourceDir) ? OUTPUT_DIR + inputPath.slice(sourceDir.length) : inputPath;
+		pathCache.set(inputPath, cached);
+	}
+	return cached;
+}
+function clearPathCache() {
+	pathCache.clear();
+}
+async function findIndependentPackages() {
+	const appJson = await fs$1.readJson(path.resolve(sourceDir, "app.json"));
+	if (appJson.subpackages) independentPackages = appJson.subpackages.filter(({ independent }) => independent).map(({ root }) => root);
+}
+const builtLibraries = [];
+const bundledModules = /* @__PURE__ */ new Map();
+async function bundleModule(module, pkg) {
+	const bundled = bundledModules.get(pkg);
+	if (bundled?.has(module) || builtLibraries.some((library) => module.startsWith(library))) return false;
+	if (bundled) bundled.add(module);
+	else bundledModules.set(pkg, new Set([module]));
+	const pkInfo = await getPackageInfo(module);
+	if (pkInfo) {
+		const { packageJson: { peerDependencies } } = pkInfo;
+		if (await fs$1.pathExists(path.resolve(pkg.replace(sourceDir, OUTPUT_DIR), "miniprogram_npm", module))) return true;
+		await (await rolldown({
+			input: module,
+			external: peerDependencies ? Object.keys(peerDependencies) : void 0,
+			plugins: [replacePlugin({ "process.env.NODE_ENV": JSON.stringify(NODE_ENV) }, { preventAssignment: true })],
+			treeshake: true
+		})).write({
+			file: `${pkg.replace(sourceDir, OUTPUT_DIR)}/miniprogram_npm/${module}/index.js`,
+			format: "cjs",
+			exports: "named",
+			minify: __PROD__
+		});
+		return true;
+	} else {
+		console.warn(`未找到 ${module} 的依赖信息`);
+		return false;
+	}
+}
+function traverseAST(ast, pkg, babelOnly = false) {
+	traverse(ast, { CallExpression({ node }) {
+		if (!t.isIdentifier(node.callee) || node.callee.name !== "require" || !t.isStringLiteral(node.arguments[0]) || node.arguments[0].value.startsWith(".") || babelOnly && !node.arguments[0].value.startsWith("@babel/runtime")) return;
+		const module = node.arguments[0].value;
+		let promise = bundleModule(module, pkg);
+		if (babelOnly) promise = promise.then((valid) => {
+			if (!valid) return;
+			return Promise.all(independentPackages.map((item) => {
+				const bundled = bundledModules.get(item);
+				if (bundled) bundled.add(module);
+				else bundledModules.set(item, new Set([module]));
+				return fs$1.copy(path.join(OUTPUT_DIR, "miniprogram_npm", module), path.join(OUTPUT_DIR, item, "miniprogram_npm", module));
+			}));
+		});
+		bundleJobs?.push(promise);
+	} });
+}
+async function buildComponentLibrary(name) {
+	const pkInfo = await getPackageInfo(name);
+	if (pkInfo) {
+		const { rootPath, packageJson: { miniprogram } } = pkInfo;
+		let source = "";
+		if (miniprogram) source = path.join(rootPath, miniprogram);
+		else try {
+			const dist = path.join(rootPath, "miniprogram_dist");
+			if ((await fs$1.stat(dist)).isDirectory()) source = dist;
+		} catch {}
+		if (!source) return;
+		const destination = path.resolve(OUTPUT_DIR, "miniprogram_npm", name);
+		builtLibraries.push(name);
+		if (await fs$1.pathExists(destination)) return;
+		await fs$1.copy(source, destination);
+		const processJsFiles = async (dir) => {
+			const entries = await fs$1.readdir(dir, { withFileTypes: true });
+			const jsFiles = [];
+			for (const entry of entries) {
+				const fullPath = path.join(dir, entry.name);
+				if (entry.isDirectory()) await processJsFiles(fullPath);
+				else if (entry.isFile() && entry.name.endsWith(".js")) jsFiles.push(fullPath);
+			}
+			await batchProcess(jsFiles, async (filePath) => {
+				try {
+					const result = await transformFileAsync(filePath, {
+						ast: true,
+						...config
+					});
+					if (result) {
+						traverseAST(result.ast, sourceDir, true);
+						const code = __PROD__ ? (await minify(result.code, {
+							ecma: 2016,
+							toplevel: true
+						})).code : result.code;
+						await fs$1.writeFile(filePath, code);
+					}
+				} catch (error) {
+					console.error(`处理 ${filePath} 失败:`, getErrorMessage(error));
+				}
+			}, Math.min(10, CONCURRENT_LIMIT));
+		};
+		await processJsFiles(destination);
+		if (independentPackages.length > 0) await Promise.all(independentPackages.map(async (item) => {
+			const independentDestination = path.join(OUTPUT_DIR, item, "miniprogram_npm", name);
+			if (!await fs$1.pathExists(independentDestination)) return fs$1.copy(destination, independentDestination);
+		}));
+	} else console.warn(`未找到 ${name} 的依赖信息`);
+}
+async function scanDependencies() {
+	try {
+		const { dependencies } = await fs$1.readJson("package.json");
+		if (dependencies) {
+			const depNames = Object.keys(dependencies);
+			const depConcurrency = Math.min(5, Math.max(2, Math.ceil(os.cpus().length / 2)));
+			console.log(bold(green(`扫描到 ${depNames.length} 个依赖，开始并行处理（并发=${depConcurrency}）...`)));
+			const startDepTime = Date.now();
+			await batchProcess(depNames, async (name) => {
+				await buildComponentLibrary(name);
+			}, depConcurrency);
+			console.log(bold(green(`依赖处理完成，耗时：${Date.now() - startDepTime}ms`)));
+		}
+	} catch (error) {
+		console.warn("读取 package.json 失败:", getErrorMessage(error));
+	}
+}
+const normalizedPkgPaths = /* @__PURE__ */ new Map();
+async function dealScriptCode(filePath, result) {
+	const ast = result.ast;
+	let code = result.code;
+	const pkg = independentPackages.find((item) => {
+		let normalized = normalizedPkgPaths.get(item);
+		if (!normalized) {
+			normalized = path.normalize(`${sourceDir}/${item}`);
+			normalizedPkgPaths.set(item, normalized);
+		}
+		return filePath.startsWith(normalized);
+	});
+	traverseAST(ast, pkg ? path.join(sourceDir, pkg) : sourceDir);
+	if (__PROD__) code = (await minify(code, {
+		ecma: 2016,
+		toplevel: true
+	})).code;
+	return code;
+}
+async function processScript(filePath) {
+	try {
+		const result = await transformFileAsync(path.resolve(filePath), {
+			ast: true,
+			...config
+		});
+		if (result) {
+			const code = await dealScriptCode(filePath, result);
+			const destination = path.join(getOutputPath(filePath).replace(/\.ts$/, ".js"));
+			await fs$1.ensureDir(path.dirname(destination));
+			await fs$1.writeFile(destination, code);
+		}
+	} catch (error) {
+		handleCompileError("", error, filePath);
+		if (__PROD__) throw error;
+	}
+}
+const cb = async (filePath, callbacks) => {
+	if (filePath.endsWith(".vue")) {
+		const t = performance.now();
+		try {
+			await transformVueToMiniProgram(filePath, OUTPUT_DIR, isPageComponent(filePath), async (generatedCode) => {
+				try {
+					const result = await transformAsync(generatedCode, {
+						filename: filePath.replace(".vue", ".js"),
+						...config
+					});
+					if (result) return dealScriptCode(filePath, result);
+					return `Failed to transformAsync ${filePath}`;
+				} catch (error) {
+					handleCompileError("", error, filePath);
+					return `console.error('Failed to compile ${filePath}: ${error.message?.replace(/'/g, "\\'")}');`;
+				}
+			});
+		} catch (error) {
+			if (__PROD__) throw error;
+			return;
+		} finally {
+			callbacks?.vueCb?.(performance.now() - t);
+		}
+		return;
+	}
+	if (filePath.endsWith(".d.ts")) return;
+	if (isCopyOnly(filePath)) {
+		const t = performance.now();
+		const destinationPath = getOutputPath(filePath);
+		await fs$1.ensureDir(path.dirname(destinationPath));
+		await fs$1.copy(filePath, destinationPath);
+		callbacks?.othersCb?.(performance.now() - t);
+		return;
+	}
+	if (filePath.endsWith(".ts") || filePath.endsWith(".js")) {
+		const t = performance.now();
+		await processScript(filePath);
+		callbacks?.jsCb?.(performance.now() - t);
+		return;
+	}
+	const t = performance.now();
+	const destinationPath = path.join(getOutputPath(filePath));
+	await fs$1.copy(filePath, path.normalize(destinationPath));
+	callbacks?.othersCb?.(performance.now() - t);
+};
+async function dev() {
+	__PROD__ = false;
+	const t0 = Date.now();
+	copyPolyfillFiles().then(() => {
+		console.log(bold(green(`[timing] copyPolyfillFiles: ${Date.now() - t0}ms`)));
+		return copyProjectConfigFile();
+	}).then(() => {
+		console.log(bold(green(`[timing] copyProjectConfigFile: ${Date.now() - t0}ms`)));
+		return loadPagePaths();
+	}).then(() => {
+		console.log(bold(green(`[timing] loadPagePaths: ${Date.now() - t0}ms`)));
+		return findIndependentPackages();
+	}).then(() => {
+		console.log(bold(green(`[timing] findIndependentPackages: ${Date.now() - t0}ms`)));
+		return scanDependencies();
+	}).then(() => {
+		console.log(bold(green(`[timing] scanDependencies: ${Date.now() - t0}ms`)));
+		const processingFiles = /* @__PURE__ */ new Set();
+		const pendingFiles = /* @__PURE__ */ new Set();
+		const initialFiles = [];
+		let isInitialScan = true;
+		chokidar.watch([sourceDir], {
+			awaitWriteFinish: {
+				stabilityThreshold: 100,
+				pollInterval: 50
+			},
+			ignored: IGNORED_FILES,
+			usePolling: false,
+			interval: 100
+		}).on("add", (filePath) => {
+			if (isInitialScan) initialFiles.push(filePath);
+			else {
+				const promise = cb(filePath);
+				topLevelJobs?.push(promise);
+			}
+		}).on("addDir", (dirPath) => {
+			const outputDir = getOutputPath(dirPath);
+			const promise = fs$1.ensureDir(outputDir);
+			topLevelJobs?.push(promise);
+		}).on("unlink", async (filePath) => {
+			const outputPath = getOutputPath(filePath);
+			const basePath = outputPath.replace(/\.vue$/, "");
+			const filesToDelete = filePath.endsWith(".vue") ? [
+				`${basePath}.js`,
+				`${basePath}.wxml`,
+				`${basePath}.wxss`,
+				`${basePath}.json`
+			] : [path.join(outputPath)];
+			try {
+				await Promise.all(filesToDelete.map((f) => fs$1.remove(f)));
+				pathCache.delete(filePath);
+			} catch (error) {
+				console.warn(`删除目标文件失败：${filesToDelete.join(", ")}`, getErrorMessage(error));
+			}
+		}).on("unlinkDir", async (dirPath) => {
+			const outputDir = getOutputPath(dirPath);
+			try {
+				await fs$1.remove(outputDir);
+			} catch (error) {
+				console.warn(`删除目标目录失败：${outputDir}`, getErrorMessage(error));
+			}
+		}).on("change", async (filePath) => {
+			if (filePath.endsWith("app.json")) {
+				console.log(bold(green("检测到 app.json 变更，清空缓存并重新加载页面路径...")));
+				clearAllCaches();
+				await loadPagePaths();
+			}
+			if (processingFiles.has(filePath)) {
+				pendingFiles.add(filePath);
+				return;
+			}
+			const runCompile = async (initialPath) => {
+				let targetPath = initialPath;
+				while (targetPath) {
+					processingFiles.add(targetPath);
+					const date = Date.now();
+					console.log(bold(green(`文件已修改：${targetPath}`)));
+					try {
+						await cb(targetPath);
+						console.log(bold(green(`文件已处理完毕，耗时：${Date.now() - date}ms`)));
+					} finally {
+						processingFiles.delete(targetPath);
+						const nextFile = Array.from(pendingFiles)[0];
+						if (nextFile) {
+							pendingFiles.delete(nextFile);
+							targetPath = nextFile;
+						} else targetPath = null;
+					}
+				}
+			};
+			await runCompile(filePath);
+		}).on("ready", async () => {
+			isInitialScan = false;
+			console.log(bold(green(`[timing] chokidar ready（文件扫描完成）: ${Date.now() - t0}ms，共 ${initialFiles.length} 个文件`)));
+			const vueFiles = initialFiles.filter((f) => f.endsWith(".vue"));
+			const tsFiles = initialFiles.filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
+			const otherFiles = initialFiles.filter((f) => !f.endsWith(".vue") && !f.endsWith(".ts") && !f.endsWith(".js"));
+			console.log(bold(green(`[timing] 文件分布：vue=${vueFiles.length}, ts/js=${tsFiles.length}, 其他=${otherFiles.length}`)));
+			let vueTime = 0, tsTime = 0, otherTime = 0;
+			const fileProcessor = async (filePath) => {
+				await cb(filePath, {
+					vueCb: (elapsed) => {
+						vueTime += elapsed;
+					},
+					jsCb: (elapsed) => {
+						tsTime += elapsed;
+					},
+					othersCb: (elapsed) => {
+						otherTime += elapsed;
+					}
+				});
+			};
+			if (initialFiles.length > 0) {
+				console.log(bold(green(`开始并行处理 ${initialFiles.length} 个文件（并发=${CONCURRENT_LIMIT}）...`)));
+				const processStartTime = Date.now();
+				await batchProcess(initialFiles, fileProcessor, CONCURRENT_LIMIT);
+				console.log(bold(green(`[timing] 并行处理完成：${Date.now() - processStartTime}ms（总耗时 ${Date.now() - t0}ms）`)));
+				console.log(bold(green(`[timing] 耗时分布：vue=${vueTime}ms, ts/js=${tsTime}ms, 其他=${otherTime}ms`)));
+			}
+			await Promise.all(bundleJobs);
+			console.log(bold(green(`启动完成，耗时：${Date.now() - startTime}ms`)));
+			console.log(bold(green("监听文件变化中...")));
+			topLevelJobs = null;
+			bundleJobs = null;
+		});
+	});
+}
+async function prod(options) {
+	__PROD__ = true;
+	return new Promise((resolve, reject) => {
+		fs$1.remove(OUTPUT_DIR).then(() => copyPolyfillFiles()).then(() => copyProjectConfigFile()).then(() => loadPagePaths()).then(() => findIndependentPackages()).then(() => scanDependencies()).then(() => {
+			const initialFiles = [];
+			let isInitialScan = true;
+			const watcher = chokidar.watch([sourceDir], { ignored: IGNORED_FILES });
+			watcher.on("add", (filePath) => {
+				if (isInitialScan) initialFiles.push(filePath);
+				else {
+					const promise = cb(filePath);
+					topLevelJobs.push(promise);
+				}
+			});
+			watcher.on("ready", async () => {
+				isInitialScan = false;
+				const fileProcessor = async (filePath) => {
+					await cb(filePath);
+				};
+				if (initialFiles.length > 0) {
+					console.log(bold(green(`开始并行处理 ${initialFiles.length} 个文件...`)));
+					const processStartTime = Date.now();
+					await batchProcess(initialFiles, fileProcessor, CONCURRENT_LIMIT);
+					console.log(bold(green(`并行处理完成，耗时：${Date.now() - processStartTime}ms`)));
+				}
+				const promise = watcher.close();
+				topLevelJobs.push(promise);
+				await Promise.all(topLevelJobs);
+				await Promise.all(bundleJobs);
+				topLevelJobs = null;
+				bundleJobs = null;
+				clearPathCache();
+				normalizedPkgPaths.clear();
+				if (options.upload) {
+					const { default: ci } = await import("miniprogram-ci");
+					const project = new ci.Project({
+						appid: userConfig.wx.appid,
+						type: "miniProgram",
+						projectPath: OUTPUT_DIR,
+						privateKeyPath: userConfig.wx.privateKeyPath,
+						ignores: []
+					});
+					console.log(bold(green("上传中...")));
+					const uploadResult = await ci.upload({
+						project,
+						version: userConfig.wx.version,
+						desc: userConfig.wx.description,
+						setting: { useProjectConfig: true },
+						onProgressUpdate: void 0
+					});
+					console.log(bold(green(`上传结果：`)), uploadResult, "当前编译环境：", NODE_ENV);
+				}
+				resolve();
+			});
+		}).catch(reject);
+	});
+}
+//#endregion
+export { dev, prod };