npm - @vureact/compiler-core - Versions diffs - 1.2.1 → 1.3.0 - Mend

@vureact/compiler-core 1.2.1 → 1.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/lib/{chunk-SQRJUILR.js → chunk-7LBUUA24.js} +829 -740
package/lib/{chunk-7FIMRVQS.esm.js → chunk-CUCUXW56.esm.js} +782 -693
package/lib/cli.d.cts +1 -2
package/lib/cli.d.ts +1 -2
package/lib/cli.esm.js +47 -2
package/lib/cli.js +54 -9
package/lib/compiler-core.d.cts +9 -0
package/lib/compiler-core.d.ts +9 -0
package/lib/compiler-core.esm.js +2 -2
package/lib/compiler-core.js +3 -3
package/package.json +13 -5
package/templates/route-setup-notes.md +192 -0
package/templates/route-setup-notes.zh.md +192 -0

package/lib/{chunk-7FIMRVQS.esm.js → chunk-CUCUXW56.esm.js} RENAMED Viewed

@@ -1,5 +1,5 @@
 /**
- * @vureact/compiler-core v1.2.1
+ * @vureact/compiler-core v1.3.0
  * (c) 2025-present Ruihong Zhong (Ryan John)
  * @license MIT
  */
@@ -24,7 +24,7 @@ function executePlugins(map, result, ctx) {
 }
 // src/core/codegen/component/jsx/syntax-processor/postprocess/build-ctx-provider.ts
-import * as t10 from "@babel/types";
+import * as t11 from "@babel/types";
 // src/consts/other.ts
 var PACKAGE_NAME = {
@@ -418,8 +418,8 @@ function getBabelParseOptions(lang = "js", context = "script", filename) {
 function stringToExpr(input, lang, filename = "") {
   return parseExpression(input, getBabelParseOptions(lang, "expression", filename));
 }
-function atComponentOrHookRoot(path7, rootScope, inScriptFile = false) {
-  const { parentPath, scope } = path7;
+function atComponentOrHookRoot(path8, rootScope, inScriptFile = false) {
+  const { parentPath, scope } = path8;
   const parentBlock = scope.block;
   if (!parentPath) return !inScriptFile;
   if (parentBlock === rootScope) {
@@ -448,7 +448,7 @@ function createJsxElement(tag, props, children, selfClosing) {
 }
 // src/core/codegen/component/jsx/syntax-processor/process/build-condition-node.ts
-import * as t9 from "@babel/types";
+import * as t10 from "@babel/types";
 // src/core/codegen/component/jsx/utils/jsx-expression-utils.ts
 import * as t2 from "@babel/types";
@@ -544,7 +544,82 @@ function buildJsxChildren(children, ctx) {
 }
 // src/core/codegen/component/jsx/syntax-processor/process/build-loop-node.ts
+import * as t6 from "@babel/types";
+// src/core/transform/sfc/template/shared/resolve-string-expression/index.ts
 import * as t5 from "@babel/types";
+// src/utils/camelCase.ts
+var camelCase = (str) => {
+  if (str.includes("-")) {
+    return str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+  }
+  return str;
+};
+// src/utils/capitalize.ts
+var capitalize = (str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+// src/core/transform/sfc/template/shared/resolve-string-expression/special-expressions.ts
+function resolveSpecialExpressions(input, ctx) {
+  input = resolveEmitsCalls(input, ctx);
+  input = resolveRefVariable(input, ctx);
+  return input;
+}
+function resolveEmitsCalls(input, ctx) {
+  const result = matchEmitCalls(input, ctx);
+  if (!result) return input;
+  const [, , eventName, args] = result;
+  const callee = eventName.split(/[:\-]/).map((part) => capitalize(camelCase(part))).join("");
+  const event = args ? `on${callee}?.(${args})` : `on${callee}?.()`;
+  return `${ctx.propField}?.${event}`;
+}
+function matchEmitCalls(input, ctx) {
+  const { reactiveBindings } = ctx.templateData;
+  const macroBinding = Object.values(reactiveBindings).find((b) => b.source === "defineEmits");
+  if (!macroBinding) return null;
+  const escapedName = macroBinding.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(
+    `${escapedName}\\s*\\(\\s*(['"\`])([^\\1]*?)\\1\\s*(?:,\\s*(.*?))?\\s*\\)$`,
+    // 可选的第二个参数
+    "s"
+    // s 标志让 . 匹配换行符
+  );
+  return input.trim().match(regex);
+}
+function resolveRefVariable(input, ctx) {
+  const { reactiveBindings } = ctx.templateData;
+  const addValueProperty = (input2, varName) => {
+    const escapedVarName = varName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(
+      `(?<![a-zA-Z0-9_\\.])${escapedVarName}(?![a-zA-Z0-9_])(?!\\.value)`,
+      "g"
+    );
+    return input2.replace(regex, `${varName}.value`);
+  };
+  for (const name in reactiveBindings) {
+    const binding = reactiveBindings[name];
+    if (binding?.reactiveType !== "ref") continue;
+    input = addValueProperty(input, name);
+  }
+  return input;
+}
+// src/core/transform/sfc/template/shared/resolve-string-expression/index.ts
+function resolveStringExpr(input, ctx, toStrLiteral = false) {
+  if (toStrLiteral) return t5.stringLiteral(input);
+  const { filename, scriptData } = ctx;
+  const newContent = resolveSpecialExpressions(input, ctx);
+  try {
+    return stringToExpr(newContent, scriptData.lang, filename);
+  } catch {
+    return t5.identifier(newContent);
+  }
+}
+// src/core/codegen/component/jsx/syntax-processor/process/build-loop-node.ts
 function buildLoopNode(nodeIR, ctx) {
   const loop = nodeIR.meta.loop;
   loop.isHandled = true;
@@ -554,15 +629,15 @@ function buildLoopNode(nodeIR, ctx) {
 function buildArrayLoopNode(nodeIR, ctx) {
   const loop = nodeIR.meta.loop;
   const { source, value, index, key } = loop.value;
-  const sourceIdentifier = t5.identifier(source);
-  const params = [t5.identifier(value)];
+  const sourceExpression = resolveStringExpr(source, ctx);
+  const params = [t6.identifier(value)];
   if (index ?? key) {
-    params.push(t5.identifier(index ?? key));
+    params.push(t6.identifier(index ?? key));
   }
-  const mapCallExpression = t5.callExpression(
-    t5.memberExpression(sourceIdentifier, t5.identifier("map")),
+  const mapCallExpression = t6.callExpression(
+    t6.memberExpression(sourceExpression, t6.identifier("map")),
     [
-      t5.arrowFunctionExpression(
+      t6.arrowFunctionExpression(
         params,
         convertJsxChildToExpression(buildElementNode(nodeIR, ctx))
       )
@@ -573,21 +648,21 @@ function buildArrayLoopNode(nodeIR, ctx) {
 function buildObjectLoopNode(nodeIR, ctx) {
   const loop = nodeIR.meta.loop;
   const { source, value, key, index } = loop.value;
-  const sourceIdentifier = t5.identifier(source);
-  const objectEntriesCallExpression = t5.callExpression(
-    t5.memberExpression(t5.identifier("Object"), t5.identifier("entries")),
-    [sourceIdentifier]
+  const sourceExpression = resolveStringExpr(source, ctx);
+  const objectEntriesCallExpression = t6.callExpression(
+    t6.memberExpression(t6.identifier("Object"), t6.identifier("entries")),
+    [sourceExpression]
   );
   const params = [
-    t5.arrayPattern([t5.identifier(key || "key"), t5.identifier(value)])
+    t6.arrayPattern([t6.identifier(key || "key"), t6.identifier(value)])
   ];
   if (index) {
-    params.push(t5.identifier(index));
+    params.push(t6.identifier(index));
   }
-  const mapCallExpression = t5.callExpression(
-    t5.memberExpression(objectEntriesCallExpression, t5.identifier("map")),
+  const mapCallExpression = t6.callExpression(
+    t6.memberExpression(objectEntriesCallExpression, t6.identifier("map")),
     [
-      t5.arrowFunctionExpression(
+      t6.arrowFunctionExpression(
         params,
         convertJsxChildToExpression(buildElementNode(nodeIR, ctx))
       )
@@ -597,25 +672,25 @@ function buildObjectLoopNode(nodeIR, ctx) {
 }
 // src/core/codegen/component/jsx/syntax-processor/process/build-memo-node.ts
-import * as t6 from "@babel/types";
+import * as t7 from "@babel/types";
 function buildMemoNode(nodeIR, ctx) {
   const memo = nodeIR.meta.memo;
   memo.isHandled = true;
   const depsExpression = memo.babelExp.ast;
   const bodyExpression = convertJsxChildToExpression(buildElementNode(nodeIR, ctx));
-  const useMemoCallExpression = t6.callExpression(t6.identifier("useMemo"), [
-    t6.arrowFunctionExpression([], bodyExpression),
+  const useMemoCallExpression = t7.callExpression(t7.identifier("useMemo"), [
+    t7.arrowFunctionExpression([], bodyExpression),
     depsExpression
   ]);
   return buildJsxExpressionNode(useMemoCallExpression);
 }
 // src/core/codegen/component/jsx/syntax-processor/process/build-props.ts
-import * as t8 from "@babel/types";
+import * as t9 from "@babel/types";
 // src/core/codegen/component/jsx/syntax-processor/process/build-slot-prop.ts
 import { parseExpression as parseExpression2 } from "@babel/parser";
-import * as t7 from "@babel/types";
+import * as t8 from "@babel/types";
 // src/shared/logger.ts
 import kleur2 from "kleur";
@@ -624,6 +699,9 @@ import kleur2 from "kleur";
 import { minimatch } from "minimatch";
 import { fileURLToPath } from "url";
 import path from "path";
+function getDirname(metaUrl) {
+  return path.dirname(fileURLToPath(metaUrl));
+}
 var PathFilter = class {
   patterns = [];
   cwd;
@@ -864,7 +942,7 @@ var logger = new Logger();
 // src/core/codegen/component/jsx/syntax-processor/process/build-slot-prop.ts
 function buildSlotProp(nodeIR, ctx) {
-  const slotKey = t7.jsxIdentifier(nodeIR.name);
+  const slotKey = t8.jsxIdentifier(nodeIR.name);
   const childrenNodeIR = !nodeIR.isScoped ? nodeIR.content : nodeIR.callback?.exp;
   if (!childrenNodeIR?.length) {
     return null;
@@ -873,7 +951,7 @@ function buildSlotProp(nodeIR, ctx) {
   if (!jsxChild) {
     return null;
   }
-  const slotValue = nodeIR.isScoped ? t7.arrowFunctionExpression(
+  const slotValue = nodeIR.isScoped ? t8.arrowFunctionExpression(
     buildSlotCallbackParams(nodeIR, ctx),
     convertJsxChildToExpression(jsxChild)
   ) : jsxChild;
@@ -882,15 +960,15 @@ function buildSlotProp(nodeIR, ctx) {
   }
   if (!nodeIR.isStatic) {
     const dynamicSlotKey = parseExpression2(nodeIR.name);
-    const spreadObject = t7.objectExpression([
-      t7.objectProperty(dynamicSlotKey, convertSlotValueToExpression(slotValue), true)
+    const spreadObject = t8.objectExpression([
+      t8.objectProperty(dynamicSlotKey, convertSlotValueToExpression(slotValue), true)
     ]);
-    return t7.jsxSpreadAttribute(spreadObject);
+    return t8.jsxSpreadAttribute(spreadObject);
   }
-  return t7.jsxAttribute(slotKey, buildJsxExpressionNode(convertSlotValueToExpression(slotValue)));
+  return t8.jsxAttribute(slotKey, buildJsxExpressionNode(convertSlotValueToExpression(slotValue)));
 }
 function convertSlotValueToExpression(nodeIR) {
-  if (t7.isArrowFunctionExpression(nodeIR)) {
+  if (t8.isArrowFunctionExpression(nodeIR)) {
     return nodeIR;
   }
   return convertJsxChildToExpression(nodeIR);
@@ -903,7 +981,7 @@ function buildSlotCallbackParams(nodeIR, ctx) {
   const source = rawArg.startsWith("(") ? `${rawArg} => null` : `(${rawArg}) => null`;
   try {
     const expression = parseExpression2(source);
-    if (!t7.isArrowFunctionExpression(expression)) {
+    if (!t8.isArrowFunctionExpression(expression)) {
       return [];
     }
     return expression.params;
@@ -946,13 +1024,13 @@ function buildStandardProp(nodeIR) {
     }
   } = nodeIR;
   if (!isStatic || isKeyLessVBind) {
-    return t8.jsxSpreadAttribute(valueAST);
+    return t9.jsxSpreadAttribute(valueAST);
   }
   let value;
   if (content !== "true") {
-    value = isStringLiteral13 ? t8.stringLiteral(content) : buildJsxExpressionNode(valueAST);
+    value = isStringLiteral13 ? t9.stringLiteral(content) : buildJsxExpressionNode(valueAST);
   }
-  return t8.jsxAttribute(keyAST, value);
+  return t9.jsxAttribute(keyAST, value);
 }
 // src/core/codegen/component/jsx/syntax-processor/process/build-element-node.ts
@@ -998,8 +1076,8 @@ function buildConditionNode(nodeIR, ctx) {
   }
   const testExpression = condition.babelExp.ast;
   const trueBranchExpression = convertJsxChildToExpression(buildCurrentNode());
-  const falseBranchExpression = nextNodeIR ? convertJsxChildToExpression(buildElementNode(nextNodeIR, ctx)) : t9.nullLiteral();
-  const conditionalExpression2 = t9.conditionalExpression(
+  const falseBranchExpression = nextNodeIR ? convertJsxChildToExpression(buildElementNode(nextNodeIR, ctx)) : t10.nullLiteral();
+  const conditionalExpression2 = t10.conditionalExpression(
     testExpression,
     // 条件测试部分
     trueBranchExpression,
@@ -1019,19 +1097,19 @@ function buildCtxProviderNode(nodeIR, ctx, children) {
     childNodes = [buildCtxProviderNode(nextProvide, ctx, children)];
   }
   const parseProviderExpr = (raw) => {
-    if (!raw) return t10.stringLiteral("");
+    if (!raw) return t11.stringLiteral("");
     try {
       return stringToExpr(raw, ctx.scriptData.lang, ctx.filename);
     } catch {
-      return t10.stringLiteral(raw);
+      return t11.stringLiteral(raw);
     }
   };
-  const nameProp = t10.jsxAttribute(
-    t10.jsxIdentifier("name"),
+  const nameProp = t11.jsxAttribute(
+    t11.jsxIdentifier("name"),
     buildJsxExpressionNode(parseProviderExpr(name))
   );
-  const valueProp = t10.jsxAttribute(
-    t10.jsxIdentifier("value"),
+  const valueProp = t11.jsxAttribute(
+    t11.jsxIdentifier("value"),
     buildJsxExpressionNode(parseProviderExpr(value))
   );
   void ctx;
@@ -1085,29 +1163,29 @@ function buildJSX(nodeIR, ctx) {
 }
 // src/core/codegen/component/script/syntax-processor/index.ts
-import * as t13 from "@babel/types";
+import * as t14 from "@babel/types";
 // src/core/codegen/component/script/syntax-processor/postprocess/build-program-node.ts
-import * as t11 from "@babel/types";
+import * as t12 from "@babel/types";
 function buildProgramNode(nodeIR, ctx, state) {
   const statements = [...state.preambleStatements];
   if (!state.component) {
-    state.result = t11.program(statements, void 0, "module");
+    state.result = t12.program(statements, void 0, "module");
     return;
   }
   statements.push(state.component);
   if (state.expose) {
     const [declarator] = state.component.declarations;
     const { name } = declarator.id;
-    statements.push(t11.exportDefaultDeclaration(t11.identifier(name)));
+    statements.push(t12.exportDefaultDeclaration(t12.identifier(name)));
   }
-  state.result = t11.program(statements, void 0, "module");
+  state.result = t12.program(statements, void 0, "module");
   void nodeIR;
   void ctx;
 }
 // src/core/codegen/component/script/syntax-processor/process/build-component-function.ts
-import * as t12 from "@babel/types";
+import * as t13 from "@babel/types";
 // src/consts/react-api-map.ts
 var REACT_API_MAP = {
@@ -1121,19 +1199,6 @@ var REACT_API_MAP = {
   useImperativeHandle: "useImperativeHandle"
 };
-// src/utils/camelCase.ts
-var camelCase = (str) => {
-  if (str.includes("-")) {
-    return str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
-  }
-  return str;
-};
-// src/utils/capitalize.ts
-var capitalize = (str) => {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-};
 // src/utils/hash.ts
 import XXH from "xxhashjs";
 function genHashByXXH(str) {
@@ -1157,7 +1222,7 @@ function buildComponent(scriptIR, ctx, state) {
   } = ctx;
   const hasProps = getHasProps(propsTSIface.propsTypes) || getHasProps(propsTSIface.emitTypes) || getHasProps(propsTSIface.slotTypes);
   const shouldMemo = scriptIR !== null || hasProps;
-  const jsxStatement = t12.returnStatement(state.jsx || t12.nullLiteral());
+  const jsxStatement = t13.returnStatement(state.jsx || t13.nullLiteral());
   const component = !shouldMemo ? resolvePureUIComponent(jsxStatement, ctx) : resolveMemoComponent(scriptIR.statement.local, jsxStatement, ctx);
   state.component = component;
 }
@@ -1165,24 +1230,24 @@ function getHasProps(list) {
   return list.length > 0;
 }
 function resolvePureUIComponent(jsxStmt, ctx) {
-  return t12.variableDeclaration("const", [
-    t12.variableDeclarator(
+  return t13.variableDeclaration("const", [
+    t13.variableDeclarator(
       resolveComponentName(ctx),
-      t12.arrowFunctionExpression([], t12.blockStatement([jsxStmt]))
+      t13.arrowFunctionExpression([], t13.blockStatement([jsxStmt]))
     )
   ]);
 }
 function resolveMemoComponent(local, jsxStmt, ctx) {
   const name = resolveComponentName(ctx);
   const param = resolvePropsParam(ctx);
-  const body = t12.blockStatement(resolveLocalStatements(local, jsxStmt));
+  const body = t13.blockStatement(resolveLocalStatements(local, jsxStmt));
   const component = resolveComponent(param, body, ctx);
   let compFn = component;
   if (ctx.scriptData.forwardRef.enabled) {
     compFn = resolveForwardRef(body, ctx);
   }
-  const memoCall = t12.callExpression(t12.identifier(REACT_API_MAP.memo), [compFn]);
-  return t12.variableDeclaration("const", [t12.variableDeclarator(name, memoCall)]);
+  const memoCall = t13.callExpression(t13.identifier(REACT_API_MAP.memo), [compFn]);
+  return t13.variableDeclaration("const", [t13.variableDeclarator(name, memoCall)]);
 }
 function resolveComponentName(ctx) {
   const { filename, compName } = ctx;
@@ -1196,7 +1261,7 @@ function resolveComponentName(ctx) {
       file: filename
     });
   }
-  return t12.identifier(name);
+  return t13.identifier(name);
 }
 function resolveLocalStatements(local, jsx) {
   const stmts = [jsx];
@@ -1216,7 +1281,7 @@ function resolveComponent(param, body, ctx) {
   if (forwardRef.enabled) {
     return resolveForwardRef(body, ctx);
   }
-  const baseComponent = t12.arrowFunctionExpression(!param ? [] : [param], body);
+  const baseComponent = t13.arrowFunctionExpression(!param ? [] : [param], body);
   return baseComponent;
 }
 function resolveForwardRef(body, ctx) {
@@ -1224,18 +1289,18 @@ function resolveForwardRef(body, ctx) {
     propField,
     scriptData: { forwardRef, lang }
   } = ctx;
-  const params = [t12.identifier(forwardRef.refField)];
+  const params = [t13.identifier(forwardRef.refField)];
   const propsId = resolvePropsParam(ctx);
-  const callExpr = t12.callExpression(t12.identifier(REACT_API_MAP.forwardRef), [
-    t12.arrowFunctionExpression(params, body)
+  const callExpr = t13.callExpression(t13.identifier(REACT_API_MAP.forwardRef), [
+    t13.arrowFunctionExpression(params, body)
   ]);
   if (lang.startsWith("ts")) {
-    const types = [t12.tsAnyKeyword()];
+    const types = [t13.tsAnyKeyword()];
     if (propsId) {
       const propsType = propsId?.typeAnnotation?.typeAnnotation;
-      types.push(propsType || t12.tsAnyKeyword());
+      types.push(propsType || t13.tsAnyKeyword());
     }
-    callExpr.typeParameters = t12.tsTypeParameterInstantiation(types);
+    callExpr.typeParameters = t13.tsTypeParameterInstantiation(types);
   }
   if (propsId) {
     propsId.typeAnnotation = null;
@@ -1246,7 +1311,7 @@ function resolveForwardRef(body, ctx) {
 function resolvePropsParam(ctx) {
   const { propField, scriptData } = ctx;
   const { propsTSIface } = scriptData;
-  const propsIdentifier = t12.identifier(propField);
+  const propsIdentifier = t13.identifier(propField);
   if (scriptData.lang.startsWith("js")) {
     if (propsTSIface.hasPropsInJsEnv) {
       return propsIdentifier;
@@ -1256,8 +1321,8 @@ function resolvePropsParam(ctx) {
   if (!propsTSIface.name) {
     return;
   }
-  const typeIdentifier = t12.identifier(propsTSIface.name);
-  propsIdentifier.typeAnnotation = t12.tsTypeAnnotation(t12.tsTypeReference(typeIdentifier));
+  const typeIdentifier = t13.identifier(propsTSIface.name);
+  propsIdentifier.typeAnnotation = t13.tsTypeAnnotation(t13.tsTypeReference(typeIdentifier));
   return propsIdentifier;
 }
@@ -1282,7 +1347,7 @@ function buildScriptSyntax(nodeIR, ctx, jsx, expose = true) {
     process: [buildProgramPreamble, buildComponent],
     postprocess: [buildProgramNode]
   });
-  return state.result || t13.program([], void 0, "module");
+  return state.result || t14.program([], void 0, "module");
 }
 function scriptSyntaxProcessor(nodeIR, ctx, state, options) {
   const run = (p) => {
@@ -1377,7 +1442,7 @@ import {
 // src/core/parse/sfc/process/resolve-script.ts
 import { generate as generate2 } from "@babel/generator";
 import { parse as babelParse2 } from "@babel/parser";
-import * as t14 from "@babel/types";
+import * as t15 from "@babel/types";
 function resolveScript(descriptor, ctx, pResult) {
   const scriptBlock = descriptor.scriptSetup || descriptor.script;
   if (!scriptBlock) return null;
@@ -1419,41 +1484,41 @@ function extractSetupBodyToTopLevel(content, options) {
     const otherTopLevel = [];
     let setupStatements = [];
     for (const node of ast.program.body) {
-      if (t14.isImportDeclaration(node)) {
+      if (t15.isImportDeclaration(node)) {
         importNodes.push(node);
         continue;
       }
-      if (t14.isExportDefaultDeclaration(node)) {
+      if (t15.isExportDefaultDeclaration(node)) {
         const decl = node.declaration;
-        if (decl && t14.isObjectExpression(decl)) {
+        if (decl && t15.isObjectExpression(decl)) {
           const nameProp = decl.properties.find((p) => {
-            if (t14.isObjectProperty(p)) {
+            if (t15.isObjectProperty(p)) {
               const key = p.key;
-              return t14.isIdentifier(key) && key.name === "name" || t14.isStringLiteral(key) && key.value === "name";
+              return t15.isIdentifier(key) && key.name === "name" || t15.isStringLiteral(key) && key.value === "name";
             }
             return false;
           });
-          if (nameProp && t14.isObjectProperty(nameProp)) {
-            if (t14.isStringLiteral(nameProp.value)) {
+          if (nameProp && t15.isObjectProperty(nameProp)) {
+            if (t15.isStringLiteral(nameProp.value)) {
               name = nameProp.value.value;
             }
           }
           const setupProp = decl.properties.find((p) => {
-            if (t14.isObjectMethod(p)) {
+            if (t15.isObjectMethod(p)) {
               return p.key && p.key.name === "setup";
             }
-            if (t14.isObjectProperty(p)) {
+            if (t15.isObjectProperty(p)) {
               const key = p.key;
-              return t14.isIdentifier(key) && key.name === "setup" || t14.isStringLiteral(key) && key.value === "setup";
+              return t15.isIdentifier(key) && key.name === "setup" || t15.isStringLiteral(key) && key.value === "setup";
             }
             return false;
           });
           if (setupProp) {
-            const value = t14.isObjectMethod(setupProp) ? setupProp : t14.isObjectProperty(setupProp) ? setupProp.value : null;
-            if (value && (t14.isFunction(value) || t14.isObjectMethod(value))) {
-              const fnBody = t14.isBlockStatement(value.body) ? value.body.body : [];
+            const value = t15.isObjectMethod(setupProp) ? setupProp : t15.isObjectProperty(setupProp) ? setupProp.value : null;
+            if (value && (t15.isFunction(value) || t15.isObjectMethod(value))) {
+              const fnBody = t15.isBlockStatement(value.body) ? value.body.body : [];
               for (const stmt of fnBody) {
-                if (t14.isReturnStatement(stmt)) continue;
+                if (t15.isReturnStatement(stmt)) continue;
                 setupStatements.push(stmt);
               }
             }
@@ -1481,7 +1546,7 @@ function extractCompName(source) {
 // src/core/parse/sfc/process/resolve-script-meta.ts
 import { traverse } from "@babel/core";
-import * as t15 from "@babel/types";
+import * as t16 from "@babel/types";
 // src/consts/html-tag-types.ts
 var HTML_TAG_TYPES = {
@@ -1585,12 +1650,12 @@ function resolveScriptMeta(result, ctx) {
   const scriptAST = result.script?.ast;
   if (!scriptAST) return;
   traverse(scriptAST, {
-    VariableDeclarator(path7) {
-      const { node } = path7;
-      if (!atComponentOrHookRoot(path7, scriptAST.program) || !t15.isIdentifier(node.id)) {
+    VariableDeclarator(path8) {
+      const { node } = path8;
+      if (!atComponentOrHookRoot(path8, scriptAST.program) || !t16.isIdentifier(node.id)) {
         return;
       }
-      if (node.init && t15.isCallExpression(node.init) && t15.isIdentifier(node.init.callee)) {
+      if (node.init && t16.isCallExpression(node.init) && t16.isIdentifier(node.init.callee)) {
         collectReactiveBindings(node, ctx);
         collectRefBindings(node, ctx);
       }
@@ -1868,7 +1933,7 @@ import { parse as babelParse3 } from "@babel/parser";
 import { traverse as traverse3 } from "@babel/core";
 // src/core/transform/sfc/script/syntax-processor/postprocess/insert-css-import.ts
-import * as t16 from "@babel/types";
+import * as t17 from "@babel/types";
 function insertCSSImport(ctx) {
   const { inputType } = ctx;
   if (inputType !== "sfc") return;
@@ -1877,15 +1942,15 @@ function insertCSSImport(ctx) {
   const scriptIR = getScriptIR(ctx);
   const filename = normalizePath(filePath).split("/").pop();
   const importPath = `./${filename}`;
-  const importDecl = t16.importDeclaration(
-    !moduleName ? [] : [t16.importDefaultSpecifier(t16.identifier(moduleName))],
-    t16.stringLiteral(importPath)
+  const importDecl = t17.importDeclaration(
+    !moduleName ? [] : [t17.importDefaultSpecifier(t17.identifier(moduleName))],
+    t17.stringLiteral(importPath)
   );
   scriptIR.imports.push(importDecl);
 }
 // src/core/transform/sfc/script/syntax-processor/postprocess/insert-required-imports.ts
-import * as t17 from "@babel/types";
+import * as t18 from "@babel/types";
 // src/core/transform/shared.ts
 function recordImport(ctx, pkg, name, onDemand = true) {
@@ -1921,36 +1986,36 @@ function insertRequiredImports(ctx) {
   const processedModules = /* @__PURE__ */ new Set();
   let hasProcessedImports = false;
   recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.memo);
-  function resolveRequiredImport(path7) {
-    const { node } = path7;
+  function resolveRequiredImport(path8) {
+    const { node } = path8;
     const moduleName = node.source.value.toLowerCase();
     const isVueLike = isVueEcosystemPackage(moduleName);
     mergeImports(node, ctx);
-    if (processedModules.has(moduleName) && !path7.removed) {
-      path7.remove();
+    if (processedModules.has(moduleName) && !path8.removed) {
+      path8.remove();
       return;
     }
     processedModules.add(moduleName);
     if (!hasProcessedImports) {
       const required = createRequiredImports(ctx);
       if (isVueLike) {
-        path7.replaceWithMultiple(required);
+        path8.replaceWithMultiple(required);
       } else if (moduleName === PACKAGE_NAME.react) {
-        path7.insertAfter(required);
+        path8.insertAfter(required);
       } else {
-        path7.insertBefore(required);
+        path8.insertBefore(required);
       }
       hasProcessedImports = true;
     }
-    if (isVueLike && !path7.removed) {
-      path7.remove();
+    if (isVueLike && !path8.removed) {
+      path8.remove();
       return;
     }
     replaceVueSuffix(ctx, node.source);
   }
-  function resolveStyleFileExt(path7) {
+  function resolveStyleFileExt(path8) {
     if (!ctx.preprocessStyles) return;
-    const { node } = path7;
+    const { node } = path8;
     if (!node || !node.source || !node.source.value) return;
     const importSource = node.source.value;
     if (typeof importSource !== "string") return;
@@ -1962,16 +2027,16 @@ function insertRequiredImports(ctx) {
   return {
     // 增加 Program.exit 兜底注入 required imports（处理无 ImportDeclaration 的 SFC）
     Program: {
-      exit(path7) {
+      exit(path8) {
         if (hasProcessedImports) return;
         const required = createRequiredImports(ctx);
-        path7.unshiftContainer("body", required);
+        path8.unshiftContainer("body", required);
         hasProcessedImports = true;
       }
     },
-    ImportDeclaration(path7) {
-      resolveRequiredImport(path7);
-      resolveStyleFileExt(path7);
+    ImportDeclaration(path8) {
+      resolveRequiredImport(path8);
+      resolveStyleFileExt(path8);
     }
   };
 }
@@ -1995,17 +2060,17 @@ function mergeImports(currentNode, ctx) {
   }
   const currentImports = /* @__PURE__ */ new Set();
   for (const spec of currentNode.specifiers) {
-    if (t17.isImportSpecifier(spec) && t17.isIdentifier(spec.imported)) {
+    if (t18.isImportSpecifier(spec) && t18.isIdentifier(spec.imported)) {
       currentImports.add(spec.imported.name);
     }
-    if (t17.isImportDefaultSpecifier(spec) && t17.isIdentifier(spec.local)) {
+    if (t18.isImportDefaultSpecifier(spec) && t18.isIdentifier(spec.local)) {
       currentImports.add(spec.local.name);
     }
   }
   for (const item of ctxImportItems) {
     if (currentImports.has(item.name)) return;
-    const local = t17.identifier(item.name);
-    const newNode = !item.onDemand ? t17.importDefaultSpecifier(local) : t17.importSpecifier(local, local);
+    const local = t18.identifier(item.name);
+    const newNode = !item.onDemand ? t18.importDefaultSpecifier(local) : t18.importSpecifier(local, local);
     currentNode.specifiers.push(newNode);
   }
   ctx.imports.delete(moduleName);
@@ -2016,18 +2081,18 @@ function createRequiredImports(ctx) {
   ctx.imports.forEach((items, moduleName) => {
     const specifier = [];
     for (const item of items) {
-      const local = t17.identifier(item.name);
+      const local = t18.identifier(item.name);
       if (!item.onDemand) {
-        specifier.push(t17.importDefaultSpecifier(local));
+        specifier.push(t18.importDefaultSpecifier(local));
       } else {
-        specifier.push(t17.importSpecifier(local, local));
+        specifier.push(t18.importSpecifier(local, local));
       }
     }
     importMap[moduleName] = specifier;
   });
   for (const name in importMap) {
     const specifiers = importMap[name];
-    const importDecl = t17.importDeclaration(specifiers, t17.stringLiteral(name));
+    const importDecl = t18.importDeclaration(specifiers, t18.stringLiteral(name));
     if (name === PACKAGE_NAME.react) {
       result.unshift(importDecl);
     } else {
@@ -2038,33 +2103,33 @@ function createRequiredImports(ctx) {
 }
 // src/core/transform/sfc/script/syntax-processor/postprocess/resolve-static-hoisting.ts
-import * as t19 from "@babel/types";
+import * as t20 from "@babel/types";
 // src/core/transform/sfc/script/shared/babel-utils.ts
-import * as t18 from "@babel/types";
-function findRootVariablePath(path7) {
-  const rootId = findRootIdentifier(path7.node);
+import * as t19 from "@babel/types";
+function findRootVariablePath(path8) {
+  const rootId = findRootIdentifier(path8.node);
   if (!rootId?.name) return null;
-  const binding = path7.scope.getBinding(rootId.name);
+  const binding = path8.scope.getBinding(rootId.name);
   if (!binding) return null;
   const rootPath = getVariableDeclaratorPath(binding.path);
   return rootPath;
 }
 function findRootIdentifier(node) {
   let current = node.object;
-  while (t18.isMemberExpression(current) || t18.isOptionalMemberExpression(current)) {
+  while (t19.isMemberExpression(current) || t19.isOptionalMemberExpression(current)) {
     current = current.object;
   }
-  return t18.isIdentifier(current) ? current : null;
+  return t19.isIdentifier(current) ? current : null;
 }
-function getVariableDeclaratorPath(path7) {
-  if (path7.isVariableDeclarator()) {
-    return path7;
+function getVariableDeclaratorPath(path8) {
+  if (path8.isVariableDeclarator()) {
+    return path8;
   }
-  return path7.findParent((p) => p.isVariableDeclarator());
+  return path8.findParent((p) => p.isVariableDeclarator());
 }
-function isVariableDeclTopLevel(path7) {
-  const variableDeclaratorPath = path7;
+function isVariableDeclTopLevel(path8) {
+  const variableDeclaratorPath = path8;
   const variableDeclarationPath = variableDeclaratorPath.parentPath;
   if (!variableDeclarationPath) {
     return false;
@@ -2078,75 +2143,75 @@ function isVariableDeclTopLevel(path7) {
   }
   return false;
 }
-function isRealVariableAccess(path7) {
-  return isIdentifierAccess(path7) && !isPropertyName(path7);
+function isRealVariableAccess(path8) {
+  return isIdentifierAccess(path8) && !isPropertyName(path8);
 }
-function isIdentifierAccess(path7) {
-  if (isIdentifierDeclaration(path7)) {
+function isIdentifierAccess(path8) {
+  if (isIdentifierDeclaration(path8)) {
     return false;
   }
-  const binding = path7.scope.getBinding(path7.node.name);
+  const binding = path8.scope.getBinding(path8.node.name);
   if (!binding) {
     return true;
   }
-  return binding.identifier !== path7.node;
+  return binding.identifier !== path8.node;
 }
-function isIdentifierDeclaration(path7) {
-  const parent = path7.parentPath;
+function isIdentifierDeclaration(path8) {
+  const parent = path8.parentPath;
   if (!parent) return false;
-  if (parent.isVariableDeclarator() && parent.node.id === path7.node) {
+  if (parent.isVariableDeclarator() && parent.node.id === path8.node) {
     return true;
   }
-  if (parent.isFunctionDeclaration() && parent.node.id === path7.node) {
+  if (parent.isFunctionDeclaration() && parent.node.id === path8.node) {
     return true;
   }
-  if (parent.isFunctionExpression() && parent.node.id === path7.node) {
+  if (parent.isFunctionExpression() && parent.node.id === path8.node) {
     return true;
   }
-  if (parent.isClassDeclaration() && parent.node.id === path7.node) {
+  if (parent.isClassDeclaration() && parent.node.id === path8.node) {
     return true;
   }
-  if (parent.isImportSpecifier() && parent.node.local === path7.node) {
+  if (parent.isImportSpecifier() && parent.node.local === path8.node) {
     return true;
   }
-  if (parent.isImportDefaultSpecifier() && parent.node.local === path7.node) {
+  if (parent.isImportDefaultSpecifier() && parent.node.local === path8.node) {
     return true;
   }
-  if (parent.isImportNamespaceSpecifier() && parent.node.local === path7.node) {
+  if (parent.isImportNamespaceSpecifier() && parent.node.local === path8.node) {
     return true;
   }
-  if (parent.isFunction() && parent.node.params.includes(path7.node)) {
+  if (parent.isFunction() && parent.node.params.includes(path8.node)) {
     return true;
   }
-  if (parent.isCatchClause() && parent.node.param === path7.node) {
+  if (parent.isCatchClause() && parent.node.param === path8.node) {
     return true;
   }
   return false;
 }
-function isPropertyName(path7) {
-  const parent = path7.parentPath;
+function isPropertyName(path8) {
+  const parent = path8.parentPath;
   if (!parent) return false;
-  if (parent.isObjectProperty() && parent.node.key === path7.node) {
+  if (parent.isObjectProperty() && parent.node.key === path8.node) {
     return true;
   }
-  if (parent.isClassProperty() && parent.node.key === path7.node) {
+  if (parent.isClassProperty() && parent.node.key === path8.node) {
     return true;
   }
-  if (parent.isMemberExpression() && parent.node.property === path7.node) {
+  if (parent.isMemberExpression() && parent.node.property === path8.node) {
     return true;
   }
   return false;
 }
 function replaceCallName(callExp, identifierName) {
   const { callee } = callExp;
-  if (!t18.isIdentifier(callee)) return;
+  if (!t19.isIdentifier(callee)) return;
   callee.name = identifierName;
   if (callee.loc) {
     callee.loc.identifierName = identifierName;
   }
 }
 function replaceIdName(id, newName) {
-  if (!t18.isIdentifier(id)) return;
+  if (!t19.isIdentifier(id)) return;
   id.name = newName;
   if (id.loc) {
     id.loc.identifierName = newName;
@@ -2156,65 +2221,65 @@ function stringValueToTSType(ctx, input, tsTypeAnnotation7) {
   const { filename, scriptData } = ctx;
   const exp = stringToExpr(input, scriptData.lang, filename);
   const ts = expressionToTSType(exp);
-  return tsTypeAnnotation7 ? t18.tsTypeAnnotation(ts) : ts;
+  return tsTypeAnnotation7 ? t19.tsTypeAnnotation(ts) : ts;
 }
 function expressionToTSType(exp) {
-  if (t18.isStringLiteral(exp)) return t18.tsStringKeyword();
-  if (t18.isNumericLiteral(exp)) return t18.tsNumberKeyword();
-  if (t18.isBooleanLiteral(exp)) return t18.tsBooleanKeyword();
-  if (t18.isArrayExpression(exp)) return t18.tsArrayType(t18.tsAnyKeyword());
-  if (t18.isObjectExpression(exp)) {
+  if (t19.isStringLiteral(exp)) return t19.tsStringKeyword();
+  if (t19.isNumericLiteral(exp)) return t19.tsNumberKeyword();
+  if (t19.isBooleanLiteral(exp)) return t19.tsBooleanKeyword();
+  if (t19.isArrayExpression(exp)) return t19.tsArrayType(t19.tsAnyKeyword());
+  if (t19.isObjectExpression(exp)) {
     const members = [];
     for (const p of exp.properties) {
-      if (!t18.isObjectProperty(p)) continue;
+      if (!t19.isObjectProperty(p)) continue;
       let key;
-      if (t18.isIdentifier(p.key)) key = p.key.name;
-      else if (t18.isStringLiteral(p.key)) key = p.key.value;
+      if (t19.isIdentifier(p.key)) key = p.key.name;
+      else if (t19.isStringLiteral(p.key)) key = p.key.value;
       if (!key) continue;
-      if (t18.isExpression(p.value)) {
+      if (t19.isExpression(p.value)) {
         members.push(
-          t18.tsPropertySignature(t18.identifier(key), t18.tsTypeAnnotation(expressionToTSType(p.value)))
+          t19.tsPropertySignature(t19.identifier(key), t19.tsTypeAnnotation(expressionToTSType(p.value)))
         );
       } else {
         members.push(
-          t18.tsPropertySignature(t18.identifier(key), t18.tsTypeAnnotation(t18.tsAnyKeyword()))
+          t19.tsPropertySignature(t19.identifier(key), t19.tsTypeAnnotation(t19.tsAnyKeyword()))
         );
       }
     }
-    return t18.tsTypeLiteral(members);
+    return t19.tsTypeLiteral(members);
   }
-  if (t18.isArrowFunctionExpression(exp) || t18.isFunctionExpression(exp)) {
+  if (t19.isArrowFunctionExpression(exp) || t19.isFunctionExpression(exp)) {
     const params = exp.params.map((p, i) => {
-      const id = t18.isIdentifier(p) ? t18.identifier(p.name) : t18.identifier(`arg${i}`);
-      id.typeAnnotation = t18.tsTypeAnnotation(t18.tsAnyKeyword());
+      const id = t19.isIdentifier(p) ? t19.identifier(p.name) : t19.identifier(`arg${i}`);
+      id.typeAnnotation = t19.tsTypeAnnotation(t19.tsAnyKeyword());
       return id;
     });
-    let returnType = t18.tsAnyKeyword();
-    if (t18.isBlockStatement(exp.body)) {
+    let returnType = t19.tsAnyKeyword();
+    if (t19.isBlockStatement(exp.body)) {
       for (const stmt of exp.body.body) {
-        if (t18.isReturnStatement(stmt) && stmt.argument) {
-          if (t18.isExpression(stmt.argument)) {
+        if (t19.isReturnStatement(stmt) && stmt.argument) {
+          if (t19.isExpression(stmt.argument)) {
             returnType = expressionToTSType(stmt.argument);
             break;
           }
         }
       }
-    } else if (t18.isExpression(exp.body)) {
+    } else if (t19.isExpression(exp.body)) {
       returnType = expressionToTSType(exp.body);
     }
-    return t18.tsFunctionType(null, params, t18.tsTypeAnnotation(returnType));
+    return t19.tsFunctionType(null, params, t19.tsTypeAnnotation(returnType));
   }
-  return t18.tsAnyKeyword();
+  return t19.tsAnyKeyword();
 }
 function isCalleeNamed(node, name) {
-  if (!t18.isIdentifier(node.callee)) {
+  if (!t19.isIdentifier(node.callee)) {
     return false;
   }
   return node.callee.name === name;
 }
 function isSimpleLiteral(node) {
   if (!node) return false;
-  if (t18.isStringLiteral(node) || t18.isNumericLiteral(node) || t18.isBooleanLiteral(node) || t18.isNullLiteral(node) || t18.isRegExpLiteral(node) || t18.isBigIntLiteral(node) || t18.isDecimalLiteral(node)) {
+  if (t19.isStringLiteral(node) || t19.isNumericLiteral(node) || t19.isBooleanLiteral(node) || t19.isNullLiteral(node) || t19.isRegExpLiteral(node) || t19.isBigIntLiteral(node) || t19.isDecimalLiteral(node)) {
     return true;
   }
   return false;
@@ -2243,26 +2308,26 @@ function resolveStaticHoisting(ctx) {
     return {};
   }
   return {
-    "ImportDeclaration|ExportDeclaration"(path7) {
-      if (t19.isImportDeclaration(path7.node)) {
-        scriptIR.imports.push(path7.node);
-      } else if (t19.isExportDeclaration(path7.node)) {
-        scriptIR.exports.push(path7.node);
+    "ImportDeclaration|ExportDeclaration"(path8) {
+      if (t20.isImportDeclaration(path8.node)) {
+        scriptIR.imports.push(path8.node);
+      } else if (t20.isExportDeclaration(path8.node)) {
+        scriptIR.exports.push(path8.node);
       }
-      path7.remove();
+      path8.remove();
     },
-    "TSInterfaceDeclaration|TSTypeAliasDeclaration|TSEnumDeclaration|TSModuleDeclaration|TSModuleDeclaration"(path7) {
-      if (t19.isProgram(path7.parent)) {
-        scriptIR.tsTypes.push(path7.node);
-        path7.remove();
+    "TSInterfaceDeclaration|TSTypeAliasDeclaration|TSEnumDeclaration|TSModuleDeclaration|TSModuleDeclaration"(path8) {
+      if (t20.isProgram(path8.parent)) {
+        scriptIR.tsTypes.push(path8.node);
+        path8.remove();
       }
     },
-    VariableDeclarator(path7) {
-      const { node } = path7;
-      if (!isVariableDeclTopLevel(path7) || !isSimpleLiteral(node.init) || getScriptNodeMeta(node)) {
+    VariableDeclarator(path8) {
+      const { node } = path8;
+      if (!isVariableDeclTopLevel(path8) || !isSimpleLiteral(node.init) || getScriptNodeMeta(node)) {
         return;
       }
-      const declarationPath = path7.findParent((p) => p.isVariableDeclaration());
+      const declarationPath = path8.findParent((p) => p.isVariableDeclaration());
       if (!declarationPath) return;
       scriptIR.statement.global.push(declarationPath.node);
       declarationPath.remove();
@@ -2276,27 +2341,27 @@ function collectLocalStatements(ctx, ast) {
 }
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-async-component.ts
-import * as t20 from "@babel/types";
+import * as t21 from "@babel/types";
 function resolveDefineAsyncComponent(ctx) {
   return {
-    CallExpression(path7) {
-      const { node } = path7;
+    CallExpression(path8) {
+      const { node } = path8;
       if (!isCalleeNamed(node, VUE_API_MAP.defineAsyncComponent)) {
         return;
       }
       const [arg] = node.arguments;
       checkIsUnsupported(ctx, arg);
-      pushToGlobalScope(path7, ctx);
+      pushToGlobalScope(path8, ctx);
       recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.lazy);
     }
   };
 }
 function checkIsUnsupported(ctx, arg) {
-  if (t20.isFunction(arg)) {
+  if (t21.isFunction(arg)) {
     checkIsDynamicImport(ctx, arg);
-  } else if (t20.isObjectExpression(arg)) {
+  } else if (t21.isObjectExpression(arg)) {
     const { value } = arg.properties.find(
-      (p) => t20.isObjectProperty(p) && t20.isIdentifier(p.key) && p.key.name === "loader"
+      (p) => t21.isObjectProperty(p) && t21.isIdentifier(p.key) && p.key.name === "loader"
     );
     checkIsDynamicImport(ctx, value);
     if (arg.properties.length > 1) {
@@ -2307,7 +2372,7 @@ function checkIsUnsupported(ctx, arg) {
 function checkIsDynamicImport(ctx, node) {
   const { scriptData, filename } = ctx;
   const warnIsNotImport = (target) => {
-    if (!target || !t20.isImport(target)) {
+    if (!target || !t21.isImport(target)) {
       logger.error(
         `Only ES module dynamic imports are supported. You must use and return import('...').`,
         {
@@ -2318,20 +2383,20 @@ function checkIsDynamicImport(ctx, node) {
       );
     }
   };
-  if (t20.isFunction(node)) {
+  if (t21.isFunction(node)) {
     checkIsDynamicImport(ctx, node.body);
     return;
   }
-  if (t20.isBlockStatement(node)) {
+  if (t21.isBlockStatement(node)) {
     const [returnSmt] = node.body;
-    if (t20.isReturnStatement(returnSmt)) {
+    if (t21.isReturnStatement(returnSmt)) {
       warnIsNotImport(returnSmt.argument);
     }
     return;
   }
-  if (t20.isCallExpression(node)) {
+  if (t21.isCallExpression(node)) {
     warnIsNotImport(node.callee);
-    if (t20.isStringLiteral(node.arguments[0])) {
+    if (t21.isStringLiteral(node.arguments[0])) {
       replaceVueSuffix(ctx, node.arguments[0]);
     }
     return;
@@ -2349,15 +2414,15 @@ function warnMultipleOptionsUsed(ctx, node) {
     }
   );
 }
-function pushToGlobalScope(path7, ctx) {
-  const { node } = path7;
+function pushToGlobalScope(path8, ctx) {
+  const { node } = path8;
   const callee = node.callee;
   callee.name = REACT_API_MAP.lazy;
   callee.loc.identifierName = REACT_API_MAP.lazy;
   if (node.typeParameters) {
     node.typeParameters = void 0;
   }
-  let declarationPath = path7.parentPath;
+  let declarationPath = path8.parentPath;
   while (declarationPath) {
     if (declarationPath.isVariableDeclaration()) {
       break;
@@ -2368,78 +2433,78 @@ function pushToGlobalScope(path7, ctx) {
   if (declarationPath?.isVariableDeclaration()) {
     fullNode = declarationPath.node;
     declarationPath.remove();
-  } else if (path7.parentPath.isVariableDeclarator()) {
-    fullNode = path7.parent;
-    path7.parentPath.remove();
+  } else if (path8.parentPath.isVariableDeclarator()) {
+    fullNode = path8.parent;
+    path8.parentPath.remove();
   } else {
-    fullNode = path7.node;
-    path7.remove();
+    fullNode = path8.node;
+    path8.remove();
   }
   const scriptIR = getScriptIR(ctx);
   scriptIR.statement.global.push(fullNode);
 }
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-expose.ts
-import * as t22 from "@babel/types";
+import * as t23 from "@babel/types";
 // src/core/transform/sfc/script/shared/hook-creator.ts
-import * as t21 from "@babel/types";
+import * as t22 from "@babel/types";
 function createUseCallback(body, deps) {
-  return t21.callExpression(t21.identifier(REACT_API_MAP.useCallback), [
+  return t22.callExpression(t22.identifier(REACT_API_MAP.useCallback), [
     body,
-    deps ?? t21.arrayExpression([])
+    deps ?? t22.arrayExpression([])
   ]);
 }
 function createUseMemo(body, deps) {
-  return t21.callExpression(t21.identifier(REACT_API_MAP.useMemo), [
-    t21.arrowFunctionExpression([], body),
-    deps ?? t21.arrayExpression([])
+  return t22.callExpression(t22.identifier(REACT_API_MAP.useMemo), [
+    t22.arrowFunctionExpression([], body),
+    deps ?? t22.arrayExpression([])
   ]);
 }
 function createUseImperativeHandle(refId, init) {
-  return t21.callExpression(t21.identifier(REACT_API_MAP.useImperativeHandle), [refId, init]);
+  return t22.callExpression(t22.identifier(REACT_API_MAP.useImperativeHandle), [refId, init]);
 }
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-expose.ts
 function resolveDefineExpose(ctx) {
   if (ctx.inputType !== "sfc") return {};
   return {
-    CallExpression(path7) {
-      const { node } = path7;
+    CallExpression(path8) {
+      const { node } = path8;
       const { filename, scriptData } = ctx;
       if (!isCalleeNamed(node, MACRO_API_NAMES.expose)) {
         return;
       }
       const [expose] = node.arguments;
       if (!expose) {
-        path7.remove();
+        path8.remove();
         return;
       }
       const adapter = ADAPTER_RULES.react[MACRO_API_NAMES.expose];
       recordImport(ctx, adapter.package, REACT_API_MAP.forwardRef);
       recordImport(ctx, adapter.package, adapter.target);
-      if (!t22.isObjectExpression(expose) && !t22.isFunction(expose)) {
+      if (!t23.isObjectExpression(expose) && !t23.isFunction(expose)) {
         logger.warn("Non-deterministic object literal may cause unknown risks.", {
           file: filename,
           loc: expose.loc,
           source: scriptData.source
         });
       }
-      const init = !t22.isFunction(expose) ? t22.arrowFunctionExpression([], expose) : expose;
+      const init = !t23.isFunction(expose) ? t23.arrowFunctionExpression([], expose) : expose;
       const { forwardRef } = scriptData;
-      const newNode = createUseImperativeHandle(t22.identifier(forwardRef.refField), init);
+      const newNode = createUseImperativeHandle(t23.identifier(forwardRef.refField), init);
       forwardRef.enabled = true;
-      path7.replaceWith(newNode);
+      path8.replaceWith(newNode);
     }
   };
 }
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-options.ts
-import * as t23 from "@babel/types";
+import * as t24 from "@babel/types";
 function resolveDefineOptions(ctx) {
   return {
-    CallExpression(path7) {
-      const { node } = path7;
+    CallExpression(path8) {
+      const { node } = path8;
       if (!isCalleeNamed(node, MACRO_API_NAMES.options)) {
         return;
       }
@@ -2451,10 +2516,10 @@ function resolveDefineOptions(ctx) {
           file: filename,
           loc: node?.loc
         });
-        path7.remove();
+        path8.remove();
         return;
       }
-      if (!t23.isObjectExpression(options)) {
+      if (!t24.isObjectExpression(options)) {
         logger.warn("Argument for defineOptions must be an object expression.", {
           source: scriptData.source,
           file: filename,
@@ -2462,13 +2527,13 @@ function resolveDefineOptions(ctx) {
         });
       } else {
         for (const prop of options.properties) {
-          if (!t23.isObjectProperty(prop) || !t23.isIdentifier(prop.key)) {
+          if (!t24.isObjectProperty(prop) || !t24.isIdentifier(prop.key)) {
             continue;
           }
           extractName(prop, ctx);
         }
       }
-      path7.remove();
+      path8.remove();
     }
   };
 }
@@ -2476,7 +2541,7 @@ function extractName(prop, ctx) {
   if (ctx.compName) return;
   const { filename, scriptData } = ctx;
   if (!prop.computed && prop.key.name === "name") {
-    if (t23.isStringLiteral(prop.value)) {
+    if (t24.isStringLiteral(prop.value)) {
       ctx.compName = prop.value.value;
       return;
     }
@@ -2489,7 +2554,7 @@ function extractName(prop, ctx) {
 }
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-emit-calls.ts
-import * as t24 from "@babel/types";
+import * as t25 from "@babel/types";
 function resolveEmitCalls(ctx) {
   const formatEmitEventName = (raw) => {
     if (raw.startsWith("update:")) {
@@ -2500,10 +2565,10 @@ function resolveEmitCalls(ctx) {
     return `on${capitalize(camelCase(normalized))}`;
   };
   return {
-    CallExpression(path7) {
-      const { node } = path7;
+    CallExpression(path8) {
+      const { node } = path8;
       const { filename, templateData, scriptData } = ctx;
-      if (!t24.isIdentifier(node.callee)) return;
+      if (!t25.isIdentifier(node.callee)) return;
       const { name } = node.callee;
       const checkIfFromDefineEmits = () => {
         let result = false;
@@ -2512,10 +2577,10 @@ function resolveEmitCalls(ctx) {
           result = meta.source === MACRO_API_NAMES.emits;
         }
         if (!result) {
-          const binding = path7.scope.getBinding(name);
+          const binding = path8.scope.getBinding(name);
           if (binding) {
             const parent = binding.path.node;
-            if (t24.isVariableDeclarator(parent) && t24.isCallExpression(parent.init) && t24.isIdentifier(parent.init.callee)) {
+            if (t25.isVariableDeclarator(parent) && t25.isCallExpression(parent.init) && t25.isIdentifier(parent.init.callee)) {
               result = parent.init.callee.name === MACRO_API_NAMES.emits;
             }
           }
@@ -2524,55 +2589,56 @@ function resolveEmitCalls(ctx) {
       };
       if (!checkIfFromDefineEmits()) return;
       const [callee, ...args] = node.arguments;
-      const eventName = t24.isStringLiteral(callee) ? formatEmitEventName(callee.value) : void 0;
+      const eventName = t25.isStringLiteral(callee) ? formatEmitEventName(callee.value) : void 0;
       if (!eventName) {
         logger.warn(`Expected String type but got ${callee?.type}, expression will be removed`, {
           file: filename,
           source: scriptData.source,
           loc: callee?.loc
         });
-        path7.remove();
+        path8.remove();
         return;
       }
-      const propCall = t24.callExpression(
-        t24.optionalMemberExpression(
-          t24.identifier(ctx.propField),
-          t24.identifier(eventName),
+      const propCall = t25.optionalCallExpression(
+        t25.optionalMemberExpression(
+          t25.identifier(ctx.propField),
+          t25.identifier(eventName),
           false,
           true
         ),
-        args
+        args,
+        true
       );
-      path7.replaceWith(propCall);
+      path8.replaceWith(propCall);
     }
   };
 }
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/index.ts
-import * as t29 from "@babel/types";
+import * as t30 from "@babel/types";
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-emits.ts
-import * as t26 from "@babel/types";
+import * as t27 from "@babel/types";
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/shared.ts
-import * as t25 from "@babel/types";
+import * as t26 from "@babel/types";
 function cloneCallableParams(params) {
   const cloneCallableParam = (param, index) => {
-    if (t25.isRestElement(param)) {
+    if (t26.isRestElement(param)) {
       const arg = param.argument;
-      const name = t25.isIdentifier(arg) ? arg.name : `args${index}`;
-      const rest = t25.restElement(t25.identifier(name));
-      rest.typeAnnotation = param.typeAnnotation || (t25.isIdentifier(arg) ? arg.typeAnnotation : null) || t25.tsTypeAnnotation(t25.tsArrayType(t25.tsAnyKeyword()));
+      const name = t26.isIdentifier(arg) ? arg.name : `args${index}`;
+      const rest = t26.restElement(t26.identifier(name));
+      rest.typeAnnotation = param.typeAnnotation || (t26.isIdentifier(arg) ? arg.typeAnnotation : null) || t26.tsTypeAnnotation(t26.tsArrayType(t26.tsAnyKeyword()));
       return rest;
     }
-    if (t25.isIdentifier(param)) {
-      const id = t25.identifier(param.name || `arg${index}`);
+    if (t26.isIdentifier(param)) {
+      const id = t26.identifier(param.name || `arg${index}`);
       id.optional = param.optional;
-      id.typeAnnotation = param.typeAnnotation || t25.tsTypeAnnotation(t25.tsAnyKeyword());
+      id.typeAnnotation = param.typeAnnotation || t26.tsTypeAnnotation(t26.tsAnyKeyword());
       return id;
     }
-    const fallback = t25.identifier(`arg${index}`);
-    fallback.typeAnnotation = t25.tsTypeAnnotation(t25.tsAnyKeyword());
+    const fallback = t26.identifier(`arg${index}`);
+    fallback.typeAnnotation = t26.tsTypeAnnotation(t26.tsAnyKeyword());
     return fallback;
   };
   return params.map(cloneCallableParam);
@@ -2581,19 +2647,19 @@ function cloneCallableParams(params) {
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-emits.ts
 function resolveEmitsTopLevelTypes(ctx) {
   return {
-    "TSInterfaceDeclaration|TSTypeAliasDeclaration"(path7) {
-      if (!t26.isProgram(path7.parent)) return;
-      const { node } = path7;
-      if (t26.isTSInterfaceDeclaration(node)) {
-        const typeLiteral = t26.tsTypeLiteral(node.body.body);
+    "TSInterfaceDeclaration|TSTypeAliasDeclaration"(path8) {
+      if (!t27.isProgram(path8.parent)) return;
+      const { node } = path8;
+      if (t27.isTSInterfaceDeclaration(node)) {
+        const typeLiteral = t27.tsTypeLiteral(node.body.body);
         if (!hasEmitsSignatureInType(typeLiteral)) return;
         const resolved = resolveTopLevelEmitType(typeLiteral);
-        if (resolved && t26.isTSTypeLiteral(resolved)) {
+        if (resolved && t27.isTSTypeLiteral(resolved)) {
           node.body.body = resolved.members;
         }
         return;
       }
-      if (t26.isTSTypeAliasDeclaration(node)) {
+      if (t27.isTSTypeAliasDeclaration(node)) {
         if (!hasEmitsSignatureInType(node.typeAnnotation)) return;
         const resolved = resolveTopLevelEmitType(node.typeAnnotation);
         if (resolved) {
@@ -2604,52 +2670,52 @@ function resolveEmitsTopLevelTypes(ctx) {
   };
 }
 function resolveTopLevelEmitType(tsType) {
-  if (t26.isTSParenthesizedType(tsType)) {
+  if (t27.isTSParenthesizedType(tsType)) {
     return resolveTopLevelEmitType(tsType.typeAnnotation);
   }
-  if (t26.isTSTypeReference(tsType)) {
+  if (t27.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return tsType;
     }
     const params = tsType.typeParameters.params.map((param) => resolveTopLevelEmitType(param)).filter(Boolean);
-    return t26.tsTypeReference(
+    return t27.tsTypeReference(
       tsType.typeName,
-      t26.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
+      t27.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
     );
   }
-  if (t26.isTSIntersectionType(tsType)) {
+  if (t27.isTSIntersectionType(tsType)) {
     const types = tsType.types.map(resolveTopLevelEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t26.tsIntersectionType(types);
+    return t27.tsIntersectionType(types);
   }
-  if (t26.isTSUnionType(tsType)) {
+  if (t27.isTSUnionType(tsType)) {
     const types = tsType.types.map(resolveTopLevelEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t26.tsUnionType(types);
+    return t27.tsUnionType(types);
   }
-  if (t26.isTSTypeLiteral(tsType)) {
+  if (t27.isTSTypeLiteral(tsType)) {
     const members = [];
     for (const member of tsType.members) {
-      if (t26.isTSCallSignatureDeclaration(member)) {
+      if (t27.isTSCallSignatureDeclaration(member)) {
         members.push(...resolveEmitPropsFromCallSignature(member));
         continue;
       }
       members.push(member);
     }
     if (!members.length) return null;
-    return t26.tsTypeLiteral(members);
+    return t27.tsTypeLiteral(members);
   }
-  if (t26.isTSFunctionType(tsType)) {
+  if (t27.isTSFunctionType(tsType)) {
     const props = resolveEmitPropsFromCallable(tsType.parameters, tsType.typeAnnotation);
     if (!props.length) return null;
-    return t26.tsTypeLiteral(props);
+    return t27.tsTypeLiteral(props);
   }
   return tsType;
 }
-function resolveDefineEmitsIface(path7, ctx) {
-  const { node } = path7;
+function resolveDefineEmitsIface(path8, ctx) {
+  const { node } = path8;
   const [runtimeArg] = node.arguments;
   const tsParams = node.typeParameters?.params;
   if (tsParams?.length) {
@@ -2665,41 +2731,41 @@ function processInferredTypes(ctx, runtimeArg) {
     propsTSIface: { emitTypes }
   } = ctx.scriptData;
   const members = [];
-  if (t26.isArrayExpression(runtimeArg)) {
+  if (t27.isArrayExpression(runtimeArg)) {
     for (const element of runtimeArg.elements) {
-      if (!element || !t26.isStringLiteral(element)) continue;
+      if (!element || !t27.isStringLiteral(element)) continue;
       const handlerName = resolveEmitHandlerName(element.value);
       const key = buildKey(handlerName);
-      const fnType = t26.tsFunctionType(
+      const fnType = t27.tsFunctionType(
         null,
         [createRestAnyParam("args")],
-        t26.tsTypeAnnotation(t26.tsAnyKeyword())
+        t27.tsTypeAnnotation(t27.tsAnyKeyword())
       );
-      const prop = t26.tsPropertySignature(key, t26.tsTypeAnnotation(fnType));
+      const prop = t27.tsPropertySignature(key, t27.tsTypeAnnotation(fnType));
       prop.optional = true;
       members.push(prop);
     }
     if (members.length) {
-      emitTypes.push(t26.tsTypeLiteral(members));
+      emitTypes.push(t27.tsTypeLiteral(members));
     }
     return;
   }
-  if (t26.isObjectExpression(runtimeArg)) {
+  if (t27.isObjectExpression(runtimeArg)) {
     for (const prop of runtimeArg.properties) {
-      if (!t26.isObjectProperty(prop)) continue;
-      if (t26.isSpreadElement(prop)) continue;
+      if (!t27.isObjectProperty(prop)) continue;
+      if (t27.isSpreadElement(prop)) continue;
       const rawName = resolvePropName(prop.key);
       if (!rawName) continue;
       const handlerName = resolveEmitHandlerName(rawName);
       const key = buildKey(handlerName);
-      const params = t26.isArrayExpression(prop.value) ? resolveRuntimeTupleParams(prop.value) : [createRestAnyParam("args")];
-      const fnType = t26.tsFunctionType(null, params, t26.tsTypeAnnotation(t26.tsAnyKeyword()));
-      const propSig = t26.tsPropertySignature(key, t26.tsTypeAnnotation(fnType));
+      const params = t27.isArrayExpression(prop.value) ? resolveRuntimeTupleParams(prop.value) : [createRestAnyParam("args")];
+      const fnType = t27.tsFunctionType(null, params, t27.tsTypeAnnotation(t27.tsAnyKeyword()));
+      const propSig = t27.tsPropertySignature(key, t27.tsTypeAnnotation(fnType));
       propSig.optional = true;
       members.push(propSig);
     }
     if (members.length) {
-      emitTypes.push(t26.tsTypeLiteral(members));
+      emitTypes.push(t27.tsTypeLiteral(members));
     }
   }
 }
@@ -2720,129 +2786,129 @@ function resolveEmitHandlerName(rawName) {
   return `on${name}`;
 }
 function resolvePropName(key) {
-  if (t26.isIdentifier(key)) return key.name;
-  if (t26.isStringLiteral(key)) return key.value;
-  if (t26.isNumericLiteral(key)) return String(key.value);
+  if (t27.isIdentifier(key)) return key.name;
+  if (t27.isStringLiteral(key)) return key.value;
+  if (t27.isNumericLiteral(key)) return String(key.value);
   return null;
 }
 function buildKey(name) {
-  return t26.isValidIdentifier(name) ? t26.identifier(name) : t26.stringLiteral(name);
+  return t27.isValidIdentifier(name) ? t27.identifier(name) : t27.stringLiteral(name);
 }
 function createRestAnyParam(name) {
-  const id = t26.identifier(name);
-  const rest = t26.restElement(id);
-  rest.typeAnnotation = t26.tsTypeAnnotation(t26.tsArrayType(t26.tsAnyKeyword()));
+  const id = t27.identifier(name);
+  const rest = t27.restElement(id);
+  rest.typeAnnotation = t27.tsTypeAnnotation(t27.tsArrayType(t27.tsAnyKeyword()));
   return rest;
 }
 function resolveRuntimeTupleParams(value) {
   const params = [];
   value.elements.forEach((element, index) => {
     if (!element) return;
-    if (t26.isSpreadElement(element)) {
+    if (t27.isSpreadElement(element)) {
       params.push(createRestAnyParam(`args${index}`));
       return;
     }
-    if (t26.isIdentifier(element)) {
-      const id = t26.identifier(element.name);
-      id.typeAnnotation = element.typeAnnotation || t26.tsTypeAnnotation(t26.tsAnyKeyword());
+    if (t27.isIdentifier(element)) {
+      const id = t27.identifier(element.name);
+      id.typeAnnotation = element.typeAnnotation || t27.tsTypeAnnotation(t27.tsAnyKeyword());
       params.push(id);
       return;
     }
-    if (t26.isTSAsExpression(element)) {
-      const id = t26.identifier(`arg${index}`);
-      id.typeAnnotation = t26.tsTypeAnnotation(element.typeAnnotation);
+    if (t27.isTSAsExpression(element)) {
+      const id = t27.identifier(`arg${index}`);
+      id.typeAnnotation = t27.tsTypeAnnotation(element.typeAnnotation);
       params.push(id);
       return;
     }
-    const fallback = t26.identifier(`arg${index}`);
-    fallback.typeAnnotation = t26.tsTypeAnnotation(t26.tsAnyKeyword());
+    const fallback = t27.identifier(`arg${index}`);
+    fallback.typeAnnotation = t27.tsTypeAnnotation(t27.tsAnyKeyword());
     params.push(fallback);
   });
   return params;
 }
 function resolveExplicitEmitType(tsType) {
-  if (t26.isTSParenthesizedType(tsType)) {
+  if (t27.isTSParenthesizedType(tsType)) {
     return resolveExplicitEmitType(tsType.typeAnnotation);
   }
-  if (t26.isTSTypeReference(tsType)) {
+  if (t27.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return tsType;
     }
     const params = tsType.typeParameters.params.map((param) => resolveExplicitEmitType(param)).filter(Boolean);
-    return t26.tsTypeReference(
+    return t27.tsTypeReference(
       tsType.typeName,
-      t26.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
+      t27.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
     );
   }
-  if (t26.isTSIntersectionType(tsType)) {
+  if (t27.isTSIntersectionType(tsType)) {
     const types = tsType.types.map(resolveExplicitEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t26.tsIntersectionType(types);
+    return t27.tsIntersectionType(types);
   }
-  if (t26.isTSUnionType(tsType)) {
+  if (t27.isTSUnionType(tsType)) {
     const types = tsType.types.map(resolveExplicitEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t26.tsUnionType(types);
+    return t27.tsUnionType(types);
   }
-  if (t26.isTSTypeLiteral(tsType)) {
+  if (t27.isTSTypeLiteral(tsType)) {
     const members = [];
     for (const member of tsType.members) {
-      if (t26.isTSPropertySignature(member)) {
+      if (t27.isTSPropertySignature(member)) {
         const prop = resolveEmitPropFromPropertySignature(member);
         if (prop) members.push(prop);
         continue;
       }
-      if (t26.isTSCallSignatureDeclaration(member)) {
+      if (t27.isTSCallSignatureDeclaration(member)) {
         members.push(...resolveEmitPropsFromCallSignature(member));
         continue;
       }
     }
     if (!members.length) return null;
-    return t26.tsTypeLiteral(members);
+    return t27.tsTypeLiteral(members);
   }
-  if (t26.isTSFunctionType(tsType)) {
+  if (t27.isTSFunctionType(tsType)) {
     const props = resolveEmitPropsFromCallable(tsType.parameters, tsType.typeAnnotation);
     if (!props.length) return null;
-    return t26.tsTypeLiteral(props);
+    return t27.tsTypeLiteral(props);
   }
   return tsType;
 }
 function hasEmitsSignatureInType(tsType) {
-  if (t26.isTSParenthesizedType(tsType)) {
+  if (t27.isTSParenthesizedType(tsType)) {
     return hasEmitsSignatureInType(tsType.typeAnnotation);
   }
-  if (t26.isTSTypeReference(tsType)) {
+  if (t27.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return false;
     }
     return tsType.typeParameters.params.some(hasEmitsSignatureInType);
   }
-  if (t26.isTSIntersectionType(tsType) || t26.isTSUnionType(tsType)) {
+  if (t27.isTSIntersectionType(tsType) || t27.isTSUnionType(tsType)) {
     return tsType.types.some(hasEmitsSignatureInType);
   }
-  if (t26.isTSTypeLiteral(tsType)) {
+  if (t27.isTSTypeLiteral(tsType)) {
     return tsType.members.some(hasEmitsSignatureInMember);
   }
-  if (t26.isTSFunctionType(tsType)) {
+  if (t27.isTSFunctionType(tsType)) {
     return isEmitsCallable(tsType.parameters);
   }
   return false;
 }
 function hasEmitsSignatureInMember(member) {
-  if (t26.isTSCallSignatureDeclaration(member)) {
+  if (t27.isTSCallSignatureDeclaration(member)) {
     return isEmitsCallable(member.parameters);
   }
   return false;
 }
 function isEmitsCallable(parameters) {
   const [eventParam] = parameters;
-  if (!eventParam || !t26.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
+  if (!eventParam || !t27.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
     return false;
   }
   const { typeAnnotation } = eventParam;
-  if (t26.isNoop(typeAnnotation)) return false;
+  if (t27.isNoop(typeAnnotation)) return false;
   return resolveEventNames(typeAnnotation.typeAnnotation).length > 0;
 }
 function resolveEmitPropFromPropertySignature(member) {
@@ -2852,19 +2918,19 @@ function resolveEmitPropFromPropertySignature(member) {
   const key = buildKey(handlerName);
   const typeAnnotation = member.typeAnnotation?.typeAnnotation;
   let params = [];
-  let returnType = t26.tsAnyKeyword();
-  if (typeAnnotation && t26.isTSFunctionType(typeAnnotation)) {
+  let returnType = t27.tsAnyKeyword();
+  if (typeAnnotation && t27.isTSFunctionType(typeAnnotation)) {
     params = cloneCallableParams(typeAnnotation.parameters);
     returnType = typeAnnotation.typeAnnotation?.typeAnnotation ?? returnType;
-  } else if (typeAnnotation && t26.isTSTupleType(typeAnnotation)) {
+  } else if (typeAnnotation && t27.isTSTupleType(typeAnnotation)) {
     params = resolveTupleTypeParams(typeAnnotation);
   } else if (typeAnnotation) {
-    const id = t26.identifier("value");
-    id.typeAnnotation = t26.tsTypeAnnotation(typeAnnotation);
+    const id = t27.identifier("value");
+    id.typeAnnotation = t27.tsTypeAnnotation(typeAnnotation);
     params = [id];
   }
-  const fnType = t26.tsFunctionType(null, params, t26.tsTypeAnnotation(returnType));
-  const prop = t26.tsPropertySignature(key, t26.tsTypeAnnotation(fnType));
+  const fnType = t27.tsFunctionType(null, params, t27.tsTypeAnnotation(returnType));
+  const prop = t27.tsPropertySignature(key, t27.tsTypeAnnotation(fnType));
   prop.optional = !!member.optional;
   return prop;
 }
@@ -2873,32 +2939,32 @@ function resolveEmitPropsFromCallSignature(member) {
 }
 function resolveEmitPropsFromCallable(parameters, typeAnnotation) {
   const [eventParam, ...restParams] = parameters;
-  if (!eventParam || !t26.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
+  if (!eventParam || !t27.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
     return [];
   }
   const { typeAnnotation: paramTypeAnnotation } = eventParam;
-  if (t26.isNoop(paramTypeAnnotation)) return [];
+  if (t27.isNoop(paramTypeAnnotation)) return [];
   const eventNames = resolveEventNames(paramTypeAnnotation.typeAnnotation);
   if (!eventNames.length) return [];
-  const returnType = typeAnnotation?.typeAnnotation ?? t26.tsAnyKeyword();
+  const returnType = typeAnnotation?.typeAnnotation ?? t27.tsAnyKeyword();
   return eventNames.map((eventName) => {
     const handlerName = resolveEmitHandlerName(eventName);
     const key = buildKey(handlerName);
     const params = cloneCallableParams(restParams);
-    const fnType = t26.tsFunctionType(null, params, t26.tsTypeAnnotation(returnType));
-    const prop = t26.tsPropertySignature(key, t26.tsTypeAnnotation(fnType));
+    const fnType = t27.tsFunctionType(null, params, t27.tsTypeAnnotation(returnType));
+    const prop = t27.tsPropertySignature(key, t27.tsTypeAnnotation(fnType));
     prop.optional = true;
     return prop;
   });
 }
 function resolveEventNames(type) {
-  if (t26.isTSLiteralType(type) && t26.isStringLiteral(type.literal)) {
+  if (t27.isTSLiteralType(type) && t27.isStringLiteral(type.literal)) {
     return [type.literal.value];
   }
-  if (t26.isTSUnionType(type)) {
+  if (t27.isTSUnionType(type)) {
     return type.types.flatMap(resolveEventNames);
   }
-  if (t26.isTSParenthesizedType(type)) {
+  if (t27.isTSParenthesizedType(type)) {
     return resolveEventNames(type.typeAnnotation);
   }
   return [];
@@ -2911,46 +2977,46 @@ function resolveTupleTypeParams(tuple) {
   return params;
 }
 function resolveTupleElementParam(element, index) {
-  const isNamedTuple = typeof t26.isTSNamedTupleMember === "function" && t26.isTSNamedTupleMember(element);
+  const isNamedTuple = typeof t27.isTSNamedTupleMember === "function" && t27.isTSNamedTupleMember(element);
   if (isNamedTuple) {
     const tupleMember = element;
     const name = tupleMember.label?.name || `arg${index}`;
     let innerType = tupleMember.elementType;
     let optional = tupleMember.optional;
-    if (t26.isTSOptionalType(innerType)) {
+    if (t27.isTSOptionalType(innerType)) {
       optional = true;
       innerType = innerType.typeAnnotation;
     }
-    if (t26.isTSRestType(innerType)) {
-      const rest = t26.restElement(t26.identifier(name));
-      rest.typeAnnotation = t26.tsTypeAnnotation(innerType.typeAnnotation);
+    if (t27.isTSRestType(innerType)) {
+      const rest = t27.restElement(t27.identifier(name));
+      rest.typeAnnotation = t27.tsTypeAnnotation(innerType.typeAnnotation);
       return rest;
     }
-    const id2 = t26.identifier(name);
+    const id2 = t27.identifier(name);
     id2.optional = optional;
-    id2.typeAnnotation = t26.tsTypeAnnotation(innerType);
+    id2.typeAnnotation = t27.tsTypeAnnotation(innerType);
     return id2;
   }
-  if (t26.isTSRestType(element)) {
-    const rest = t26.restElement(t26.identifier(`args${index}`));
-    rest.typeAnnotation = t26.tsTypeAnnotation(element.typeAnnotation);
+  if (t27.isTSRestType(element)) {
+    const rest = t27.restElement(t27.identifier(`args${index}`));
+    rest.typeAnnotation = t27.tsTypeAnnotation(element.typeAnnotation);
     return rest;
   }
-  if (t26.isTSOptionalType(element)) {
-    const id2 = t26.identifier(`arg${index}`);
+  if (t27.isTSOptionalType(element)) {
+    const id2 = t27.identifier(`arg${index}`);
     id2.optional = true;
-    id2.typeAnnotation = t26.tsTypeAnnotation(element.typeAnnotation);
+    id2.typeAnnotation = t27.tsTypeAnnotation(element.typeAnnotation);
     return id2;
   }
-  const id = t26.identifier(`arg${index}`);
-  id.typeAnnotation = t26.tsTypeAnnotation(element);
+  const id = t27.identifier(`arg${index}`);
+  id.typeAnnotation = t27.tsTypeAnnotation(element);
   return id;
 }
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-props.ts
-import * as t27 from "@babel/types";
-function resolveDefinePropsIface(path7, ctx) {
-  const { node } = path7;
+import * as t28 from "@babel/types";
+function resolveDefinePropsIface(path8, ctx) {
+  const { node } = path8;
   const [runtimeArg] = node.arguments;
   const tsParams = node.typeParameters?.params;
   if (tsParams?.length) {
@@ -2968,38 +3034,38 @@ function processInferredTypes2(ctx, runtimeArg) {
   } = scriptData;
   if (!runtimeArg) return;
   const members = [];
-  if (t27.isArrayExpression(runtimeArg)) {
+  if (t28.isArrayExpression(runtimeArg)) {
     for (const element of runtimeArg.elements) {
-      if (!element || !t27.isStringLiteral(element)) continue;
-      const key = t27.isValidIdentifier(element.value) ? t27.identifier(element.value) : t27.stringLiteral(element.value);
-      const prop = t27.tsPropertySignature(key, t27.tsTypeAnnotation(t27.tsAnyKeyword()));
+      if (!element || !t28.isStringLiteral(element)) continue;
+      const key = t28.isValidIdentifier(element.value) ? t28.identifier(element.value) : t28.stringLiteral(element.value);
+      const prop = t28.tsPropertySignature(key, t28.tsTypeAnnotation(t28.tsAnyKeyword()));
       prop.optional = true;
       members.push(prop);
     }
     if (members.length) {
-      propsTypes.push(t27.tsTypeLiteral(members));
+      propsTypes.push(t28.tsTypeLiteral(members));
     }
     return;
   }
-  if (t27.isObjectExpression(runtimeArg)) {
+  if (t28.isObjectExpression(runtimeArg)) {
     for (const prop of runtimeArg.properties) {
-      if (!t27.isObjectProperty(prop)) continue;
-      if (t27.isSpreadElement(prop)) continue;
+      if (!t28.isObjectProperty(prop)) continue;
+      if (t28.isSpreadElement(prop)) continue;
       const key = prop.key;
       let propName = null;
-      if (t27.isIdentifier(key)) propName = key.name;
-      if (t27.isStringLiteral(key)) propName = key.value;
-      if (t27.isNumericLiteral(key)) propName = String(key.value);
+      if (t28.isIdentifier(key)) propName = key.name;
+      if (t28.isStringLiteral(key)) propName = key.value;
+      if (t28.isNumericLiteral(key)) propName = String(key.value);
       if (!propName) continue;
       const { type, required } = resolveRuntimePropMeta(prop.value);
-      const tsType = type ?? t27.tsAnyKeyword();
-      const tsKey = t27.isValidIdentifier(propName) ? t27.identifier(propName) : t27.stringLiteral(propName);
-      const tsProp = t27.tsPropertySignature(tsKey, t27.tsTypeAnnotation(tsType));
+      const tsType = type ?? t28.tsAnyKeyword();
+      const tsKey = t28.isValidIdentifier(propName) ? t28.identifier(propName) : t28.stringLiteral(propName);
+      const tsProp = t28.tsPropertySignature(tsKey, t28.tsTypeAnnotation(tsType));
       tsProp.optional = !required;
       members.push(tsProp);
     }
     if (members.length) {
-      propsTypes.push(t27.tsTypeLiteral(members));
+      propsTypes.push(t28.tsTypeLiteral(members));
     }
     return;
   }
@@ -3013,42 +3079,42 @@ function processInferredTypes2(ctx, runtimeArg) {
   );
 }
 function resolveRuntimePropMeta(value) {
-  if (t27.isIdentifier(value)) {
+  if (t28.isIdentifier(value)) {
     return {
       type: mapRuntimeTypeToTSType(value),
       required: false
     };
   }
-  if (t27.isArrayExpression(value)) {
+  if (t28.isArrayExpression(value)) {
     return {
       type: resolveRuntimeUnionType(value),
       required: false
     };
   }
-  if (!t27.isObjectExpression(value)) {
+  if (!t28.isObjectExpression(value)) {
     return { required: false };
   }
   let type;
   let required = false;
   for (const prop of value.properties) {
-    if (!t27.isObjectProperty(prop)) continue;
-    if (t27.isSpreadElement(prop)) continue;
+    if (!t28.isObjectProperty(prop)) continue;
+    if (t28.isSpreadElement(prop)) continue;
     const key = prop.key;
-    const propName = t27.isIdentifier(key) ? key.name : t27.isStringLiteral(key) ? key.value : null;
+    const propName = t28.isIdentifier(key) ? key.name : t28.isStringLiteral(key) ? key.value : null;
     if (!propName) continue;
     if (propName === "type") {
       const valueNode = prop.value;
-      if (t27.isArrayExpression(valueNode)) {
+      if (t28.isArrayExpression(valueNode)) {
         type = resolveRuntimeUnionType(valueNode);
         continue;
       }
-      if (t27.isIdentifier(valueNode)) {
+      if (t28.isIdentifier(valueNode)) {
         type = mapRuntimeTypeToTSType(valueNode);
         continue;
       }
     }
     if (propName === "required") {
-      if (t27.isBooleanLiteral(prop.value)) {
+      if (t28.isBooleanLiteral(prop.value)) {
         required = prop.value.value;
       }
     }
@@ -3058,58 +3124,58 @@ function resolveRuntimePropMeta(value) {
 function resolveRuntimeUnionType(value) {
   const types = [];
   for (const element of value.elements) {
-    if (!element || !t27.isIdentifier(element)) continue;
+    if (!element || !t28.isIdentifier(element)) continue;
     const resolved = mapRuntimeTypeToTSType(element);
     if (resolved) types.push(resolved);
   }
-  if (!types.length) return t27.tsAnyKeyword();
+  if (!types.length) return t28.tsAnyKeyword();
   if (types.length === 1) return types[0];
-  return t27.tsUnionType(types);
+  return t28.tsUnionType(types);
 }
 function mapRuntimeTypeToTSType(value) {
   switch (value.name) {
     case "String":
-      return t27.tsStringKeyword();
+      return t28.tsStringKeyword();
     case "Number":
-      return t27.tsNumberKeyword();
+      return t28.tsNumberKeyword();
     case "Boolean":
-      return t27.tsBooleanKeyword();
+      return t28.tsBooleanKeyword();
     case "Object":
-      return t27.tsTypeLiteral([]);
+      return t28.tsTypeLiteral([]);
     case "Array":
-      return t27.tsArrayType(t27.tsAnyKeyword());
+      return t28.tsArrayType(t28.tsAnyKeyword());
     case "Function":
-      return t27.tsFunctionType(null, [], t27.tsTypeAnnotation(t27.tsAnyKeyword()));
+      return t28.tsFunctionType(null, [], t28.tsTypeAnnotation(t28.tsAnyKeyword()));
     case "Symbol":
-      return t27.tsSymbolKeyword();
+      return t28.tsSymbolKeyword();
     case "BigInt":
-      return t27.tsBigIntKeyword();
+      return t28.tsBigIntKeyword();
     default:
-      return t27.tsAnyKeyword();
+      return t28.tsAnyKeyword();
   }
 }
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot.ts
-import * as t28 from "@babel/types";
+import * as t29 from "@babel/types";
 var SLOT_DEFAULT_NAME = "default";
 var SLOT_CHILDREN_NAME = "children";
 var SLOT_FN_PARAM_NAME = "props";
 function resolveSlotsTopLevelTypes(ctx) {
   return {
-    "TSInterfaceDeclaration|TSTypeAliasDeclaration"(path7) {
-      if (!t28.isProgram(path7.parent)) return;
-      const { node } = path7;
-      if (t28.isTSInterfaceDeclaration(node)) {
-        const typeLiteral = t28.tsTypeLiteral(node.body.body);
+    "TSInterfaceDeclaration|TSTypeAliasDeclaration"(path8) {
+      if (!t29.isProgram(path8.parent)) return;
+      const { node } = path8;
+      if (t29.isTSInterfaceDeclaration(node)) {
+        const typeLiteral = t29.tsTypeLiteral(node.body.body);
         if (!hasSlotsSignatureInType(typeLiteral)) return;
         const resolved = resolveSlotType(typeLiteral);
-        if (resolved && t28.isTSTypeLiteral(resolved)) {
+        if (resolved && t29.isTSTypeLiteral(resolved)) {
           node.body.body = resolved.members;
           recordReactNode(ctx);
         }
         return;
       }
-      if (t28.isTSTypeAliasDeclaration(node)) {
+      if (t29.isTSTypeAliasDeclaration(node)) {
         if (!hasSlotsSignatureInType(node.typeAnnotation)) return;
         const resolved = resolveSlotType(node.typeAnnotation);
         if (resolved) {
@@ -3120,8 +3186,8 @@ function resolveSlotsTopLevelTypes(ctx) {
     }
   };
 }
-function resolveDefineSlotsIface(path7, ctx) {
-  const { node } = path7;
+function resolveDefineSlotsIface(path8, ctx) {
+  const { node } = path8;
   const tsParams = node.typeParameters?.params;
   if (!tsParams?.length) return;
   const {
@@ -3154,7 +3220,7 @@ function resolveTemplateSlotIface(ctx) {
   }
   if (tsMembers.length) {
     recordReactNode(ctx);
-    slotTypes.push(t28.tsTypeLiteral(tsMembers));
+    slotTypes.push(t29.tsTypeLiteral(tsMembers));
   }
 }
 function recordReactNode(ctx) {
@@ -3164,32 +3230,32 @@ function recordReactNode(ctx) {
   recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.ReactNode);
 }
 function resolveSlotType(tsType) {
-  if (t28.isTSParenthesizedType(tsType)) {
+  if (t29.isTSParenthesizedType(tsType)) {
     return resolveSlotType(tsType.typeAnnotation);
   }
-  if (t28.isTSTypeReference(tsType)) {
+  if (t29.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return tsType;
     }
     const params = tsType.typeParameters.params.map((param) => resolveSlotType(param)).filter(Boolean);
-    return t28.tsTypeReference(
+    return t29.tsTypeReference(
       tsType.typeName,
-      t28.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
+      t29.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
     );
   }
-  if (t28.isTSIntersectionType(tsType)) {
+  if (t29.isTSIntersectionType(tsType)) {
     const types = tsType.types.map(resolveSlotType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t28.tsIntersectionType(types);
+    return t29.tsIntersectionType(types);
   }
-  if (t28.isTSUnionType(tsType)) {
+  if (t29.isTSUnionType(tsType)) {
     const types = tsType.types.map(resolveSlotType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t28.tsUnionType(types);
+    return t29.tsUnionType(types);
   }
-  if (t28.isTSTypeLiteral(tsType)) {
+  if (t29.isTSTypeLiteral(tsType)) {
     const members = [];
     for (const member of tsType.members) {
       const resolved = resolveSlotPropFromMember(member);
@@ -3200,56 +3266,56 @@ function resolveSlotType(tsType) {
       members.push(member);
     }
     if (!members.length) return null;
-    return t28.tsTypeLiteral(members);
+    return t29.tsTypeLiteral(members);
   }
-  if (t28.isTSFunctionType(tsType)) {
+  if (t29.isTSFunctionType(tsType)) {
     const props = buildSlotPropSignature(
       SLOT_DEFAULT_NAME,
       cloneCallableParams(tsType.parameters),
       false
     );
-    return t28.tsTypeLiteral([props]);
+    return t29.tsTypeLiteral([props]);
   }
   return tsType;
 }
 function hasSlotsSignatureInType(tsType) {
-  if (t28.isTSParenthesizedType(tsType)) {
+  if (t29.isTSParenthesizedType(tsType)) {
     return hasSlotsSignatureInType(tsType.typeAnnotation);
   }
-  if (t28.isTSTypeReference(tsType)) {
+  if (t29.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return false;
     }
     return tsType.typeParameters.params.some(hasSlotsSignatureInType);
   }
-  if (t28.isTSIntersectionType(tsType) || t28.isTSUnionType(tsType)) {
+  if (t29.isTSIntersectionType(tsType) || t29.isTSUnionType(tsType)) {
     return tsType.types.some(hasSlotsSignatureInType);
   }
-  if (t28.isTSTypeLiteral(tsType)) {
+  if (t29.isTSTypeLiteral(tsType)) {
     return tsType.members.some(hasSlotsSignatureInMember);
   }
-  if (t28.isTSFunctionType(tsType)) {
+  if (t29.isTSFunctionType(tsType)) {
     return true;
   }
   return false;
 }
 function hasSlotsSignatureInMember(member) {
-  if (t28.isTSMethodSignature(member)) return true;
-  if (t28.isTSCallSignatureDeclaration(member)) return true;
-  if (t28.isTSPropertySignature(member)) {
+  if (t29.isTSMethodSignature(member)) return true;
+  if (t29.isTSCallSignatureDeclaration(member)) return true;
+  if (t29.isTSPropertySignature(member)) {
     const typeAnnotation = member.typeAnnotation?.typeAnnotation;
     return !!(typeAnnotation && resolveCallableType(typeAnnotation));
   }
   return false;
 }
 function resolveSlotPropFromMember(member) {
-  if (t28.isTSMethodSignature(member)) {
+  if (t29.isTSMethodSignature(member)) {
     const rawName = resolvePropName2(member.key);
     if (!rawName) return null;
     const params = cloneCallableParams(member.parameters);
     return buildSlotPropSignature(rawName, params, !!member.optional);
   }
-  if (t28.isTSPropertySignature(member)) {
+  if (t29.isTSPropertySignature(member)) {
     const rawName = resolvePropName2(member.key);
     if (!rawName) return null;
     const typeAnnotation = member.typeAnnotation?.typeAnnotation;
@@ -3258,53 +3324,53 @@ function resolveSlotPropFromMember(member) {
     const params = cloneCallableParams(callable.parameters);
     return buildSlotPropSignature(rawName, params, !!member.optional);
   }
-  if (t28.isTSCallSignatureDeclaration(member)) {
+  if (t29.isTSCallSignatureDeclaration(member)) {
     const params = cloneCallableParams(member.parameters);
     return buildSlotPropSignature(SLOT_DEFAULT_NAME, params, true);
   }
   return null;
 }
 function resolveCallableType(tsType) {
-  if (t28.isTSFunctionType(tsType)) return tsType;
-  if (t28.isTSParenthesizedType(tsType)) return resolveCallableType(tsType.typeAnnotation);
+  if (t29.isTSFunctionType(tsType)) return tsType;
+  if (t29.isTSParenthesizedType(tsType)) return resolveCallableType(tsType.typeAnnotation);
   return null;
 }
 function buildSlotPropSignature(rawName, params, optional) {
   const propName = rawName === SLOT_DEFAULT_NAME ? SLOT_CHILDREN_NAME : rawName;
-  const key = t28.isValidIdentifier(propName) ? t28.identifier(propName) : t28.stringLiteral(propName);
-  const reactNodeType = t28.tsTypeAnnotation(
-    t28.tsTypeReference(t28.identifier(REACT_API_MAP.ReactNode))
+  const key = t29.isValidIdentifier(propName) ? t29.identifier(propName) : t29.stringLiteral(propName);
+  const reactNodeType = t29.tsTypeAnnotation(
+    t29.tsTypeReference(t29.identifier(REACT_API_MAP.ReactNode))
   );
   let typeAnnotation;
   if (rawName === SLOT_DEFAULT_NAME && params.length === 0 || params.length === 0) {
     typeAnnotation = reactNodeType;
   } else {
-    const fnType = t28.tsFunctionType(null, params, reactNodeType);
-    typeAnnotation = t28.tsTypeAnnotation(fnType);
+    const fnType = t29.tsFunctionType(null, params, reactNodeType);
+    typeAnnotation = t29.tsTypeAnnotation(fnType);
   }
-  const prop = t28.tsPropertySignature(key, typeAnnotation);
+  const prop = t29.tsPropertySignature(key, typeAnnotation);
   prop.optional = optional;
   return prop;
 }
 function createSlotScopeParam(props, ctx) {
-  const paramId = t28.identifier(SLOT_FN_PARAM_NAME);
+  const paramId = t29.identifier(SLOT_FN_PARAM_NAME);
   const propsSigns = [];
   const { reactiveBindings } = ctx.templateData;
   props.forEach(({ prop, tsType }) => {
     const foundBindingValue = reactiveBindings[prop]?.value;
     const foundBindingTypes = foundBindingValue ? expressionToTSType(foundBindingValue) : null;
-    const typeAnnotation = foundBindingTypes ? t28.tsTypeAnnotation(foundBindingTypes) : tsType;
-    const key = t28.isValidIdentifier(prop) ? t28.identifier(prop) : t28.stringLiteral(prop);
-    const propSign = t28.tsPropertySignature(key, typeAnnotation);
+    const typeAnnotation = foundBindingTypes ? t29.tsTypeAnnotation(foundBindingTypes) : tsType;
+    const key = t29.isValidIdentifier(prop) ? t29.identifier(prop) : t29.stringLiteral(prop);
+    const propSign = t29.tsPropertySignature(key, typeAnnotation);
     propsSigns.push(propSign);
   });
-  paramId.typeAnnotation = t28.tsTypeAnnotation(t28.tsTypeLiteral(propsSigns));
+  paramId.typeAnnotation = t29.tsTypeAnnotation(t29.tsTypeLiteral(propsSigns));
   return paramId;
 }
 function resolvePropName2(key) {
-  if (t28.isIdentifier(key)) return key.name;
-  if (t28.isStringLiteral(key)) return key.value;
-  if (t28.isNumericLiteral(key)) return String(key.value);
+  if (t29.isIdentifier(key)) return key.name;
+  if (t29.isStringLiteral(key)) return key.value;
+  if (t29.isNumericLiteral(key)) return String(key.value);
   return null;
 }
@@ -3312,8 +3378,8 @@ function resolvePropName2(key) {
 function resolvePropsIface(ctx) {
   const isTS = ctx.scriptData.lang.startsWith("ts");
   return {
-    CallExpression(path7) {
-      const { node, parentPath } = path7;
+    CallExpression(path8) {
+      const { node, parentPath } = path8;
       const name = node.callee.name;
       if (!isCalleeNamed(node, MACRO_API_NAMES.props) && !isCalleeNamed(node, MACRO_API_NAMES.emits) && !isCalleeNamed(node, MACRO_API_NAMES.slots)) {
         return;
@@ -3322,7 +3388,7 @@ function resolvePropsIface(ctx) {
         if (parentPath.isVariableDeclaration() || parentPath.isVariableDeclarator()) {
           parentPath.remove();
         } else {
-          path7.remove();
+          path8.remove();
         }
       };
       if (ctx.inputType !== "sfc") {
@@ -3336,11 +3402,11 @@ function resolvePropsIface(ctx) {
         propsTSIface.hasPropsInJsEnv = true;
       } else {
         if (name === MACRO_API_NAMES.props) {
-          resolveDefinePropsIface(path7, ctx);
+          resolveDefinePropsIface(path8, ctx);
         } else if (name === MACRO_API_NAMES.emits) {
-          resolveDefineEmitsIface(path7, ctx);
+          resolveDefineEmitsIface(path8, ctx);
         } else if (name === MACRO_API_NAMES.slots) {
-          resolveDefineSlotsIface(path7, ctx);
+          resolveDefineSlotsIface(path8, ctx);
         }
       }
       removePath();
@@ -3356,9 +3422,9 @@ function resolveCompIProps(ctx, ast) {
   }
   const n = ctx.compName || "Comp";
   const ns = `I${camelCase(capitalize(n))}Props`;
-  const typeNode = t29.tsIntersectionType(tsTypes);
-  const typeAliasDecl = t29.tsTypeAliasDeclaration(t29.identifier(ns), null, typeNode);
-  const exportDecl = t29.exportNamedDeclaration(typeAliasDecl);
+  const typeNode = t30.tsIntersectionType(tsTypes);
+  const typeAliasDecl = t30.tsTypeAliasDeclaration(t30.identifier(ns), null, typeNode);
+  const exportDecl = t30.exportNamedDeclaration(typeAliasDecl);
   propsTSIface.name = ns;
   const scriptIR = getScriptIR(ctx);
   scriptIR.exports.push(exportDecl);
@@ -3366,17 +3432,17 @@ function resolveCompIProps(ctx, ast) {
 }
 // src/core/transform/sfc/script/syntax-processor/process/resolve-analysis-only-adapter.ts
-import * as t31 from "@babel/types";
+import * as t32 from "@babel/types";
 // src/core/transform/sfc/script/shared/dependency-analyzer.ts
 import { traverse as traverse2 } from "@babel/core";
-import * as t30 from "@babel/types";
+import * as t31 from "@babel/types";
 var TRACE_MAX_DEPTH = 20;
 function analyzeDeps(node, ctx, parentPath) {
   if (!parentPath) {
-    return t30.arrayExpression([]);
+    return t31.arrayExpression([]);
   }
-  const isFnExpr = t30.isArrowFunctionExpression(node) || t30.isFunctionExpression(node);
+  const isFnExpr = t31.isArrowFunctionExpression(node) || t31.isFunctionExpression(node);
   const analyzeTarget = isFnExpr ? node.body : node;
   const bindingLocalBoundary = isFnExpr ? node : analyzeTarget;
   const reactiveStateApis = getReactiveStateApis();
@@ -3389,11 +3455,11 @@ function analyzeDeps(node, ctx, parentPath) {
     analyzeTarget,
     {
       "MemberExpression|OptionalMemberExpression"(memberPath) {
-        const path7 = memberPath;
-        if (isNestedMemberObject(path7)) return;
-        const rootId = findRootIdentifier(path7.node);
+        const path8 = memberPath;
+        if (isNestedMemberObject(path8)) return;
+        const rootId = findRootIdentifier(path8.node);
         if (!rootId) return;
-        tryAddDependency(path7, rootId.name, path7.scope);
+        tryAddDependency(path8, rootId.name, path8.scope);
         processedIdentifiers.add(rootId);
       },
       Identifier(idPath) {
@@ -3428,40 +3494,41 @@ function analyzeDeps(node, ctx, parentPath) {
       addDependency(sourcedExpression);
     }
   }
-  function normalizeDependencyExpr(path7, rootName) {
-    if (t30.isIdentifier(path7.node)) {
-      return t30.identifier(path7.node.name);
+  function normalizeDependencyExpr(path8, rootName) {
+    if (t31.isIdentifier(path8.node)) {
+      return t31.identifier(path8.node.name);
     }
-    if (t30.isMemberExpression(path7.node) || t30.isOptionalMemberExpression(path7.node)) {
-      const normalizedExp = normalizeMemberForCallSite(path7, path7.node);
-      if (isReactValidDependencyExpr(normalizedExp)) {
-        return t30.cloneNode(normalizedExp, true);
+    if (t31.isMemberExpression(path8.node) || t31.isOptionalMemberExpression(path8.node)) {
+      const normalizedExp = normalizeMemberForCallSite(path8, path8.node);
+      const safeExp = t31.isMemberExpression(normalizedExp) || t31.isOptionalMemberExpression(normalizedExp) ? ensureOptionalForRefValue(normalizedExp) : normalizedExp;
+      if (isReactValidDependencyExpr(safeExp)) {
+        return t31.cloneNode(safeExp, true);
       }
-      return t30.identifier(rootName);
+      return t31.identifier(rootName);
     }
     return null;
   }
   function isReactValidDependencyExpr(node2) {
-    if (t30.isIdentifier(node2)) {
+    if (t31.isIdentifier(node2)) {
       return true;
     }
-    if (t30.isMemberExpression(node2) || t30.isOptionalMemberExpression(node2)) {
+    if (t31.isMemberExpression(node2) || t31.isOptionalMemberExpression(node2)) {
       return isStaticMemberChain(node2);
     }
     return false;
   }
   function isStaticMemberChain(node2) {
     let current = node2;
-    while (t30.isMemberExpression(current) || t30.isOptionalMemberExpression(current)) {
-      if (!current.computed && !t30.isIdentifier(current.property)) {
+    while (t31.isMemberExpression(current) || t31.isOptionalMemberExpression(current)) {
+      if (!current.computed && !t31.isIdentifier(current.property)) {
         return false;
       }
-      if (current.computed && !t30.isStringLiteral(current.property) && !t30.isNumericLiteral(current.property)) {
+      if (current.computed && !t31.isStringLiteral(current.property) && !t31.isNumericLiteral(current.property)) {
         return false;
       }
       current = current.object;
     }
-    return t30.isIdentifier(current);
+    return t31.isIdentifier(current);
   }
   function isBindingDeclaredInsideBoundary(binding, boundary) {
     let current = binding.path;
@@ -3473,17 +3540,42 @@ function analyzeDeps(node, ctx, parentPath) {
     }
     return false;
   }
-  function normalizeMemberForCallSite(path7, node2) {
-    const parent = path7.parentPath;
+  function normalizeMemberForCallSite(path8, node2) {
+    const parent = path8.parentPath;
     const isDirectCallee = !!parent && (parent.isCallExpression() && parent.node.callee === node2 || parent.isOptionalCallExpression() && parent.node.callee === node2);
     if (!isDirectCallee) {
       return node2;
     }
-    if (!t30.isExpression(node2.object)) {
+    if (!t31.isExpression(node2.object)) {
       return node2;
     }
     return node2.object;
   }
+  function ensureOptionalForRefValue(node2) {
+    if (!hasRefValueAccess(node2)) {
+      return node2;
+    }
+    if (t31.isOptionalMemberExpression(node2) && node2.optional) {
+      return node2;
+    }
+    const object = t31.cloneNode(node2.object, true);
+    const property = t31.cloneNode(node2.property, true);
+    return t31.optionalMemberExpression(object, property, node2.computed, true);
+  }
+  function hasRefValueAccess(node2) {
+    let current = node2;
+    while (t31.isMemberExpression(current) || t31.isOptionalMemberExpression(current)) {
+      if (current.computed) {
+        if (t31.isStringLiteral(current.property) && current.property.value === "value") {
+          return true;
+        }
+      } else if (t31.isIdentifier(current.property) && current.property.name === "value") {
+        return true;
+      }
+      current = current.object;
+    }
+    return false;
+  }
   function isEligibleBindingSource(binding) {
     if (binding.kind === "param") {
       return false;
@@ -3493,19 +3585,19 @@ function analyzeDeps(node, ctx, parentPath) {
     const isImportBinding = bindingPath.isImportSpecifier() || bindingPath.isImportDefaultSpecifier() || bindingPath.isImportNamespaceSpecifier();
     const isReactiveVarBinding = !!declaratorPath && isReactiveBinding(declaratorPath.node);
     const nodeInit = declaratorPath?.node.init;
-    const isReactiveApiCallVarBinding = !!declaratorPath && t30.isCallExpression(nodeInit) && t30.isIdentifier(nodeInit.callee) && reactiveStateApis.has(nodeInit.callee.name);
-    const isHookCallVarBinding = !!declaratorPath && t30.isCallExpression(nodeInit) && isHookLikeCallee(nodeInit.callee);
-    const isFunctionBinding = bindingPath.isFunctionDeclaration() || !!declaratorPath && !!nodeInit && (t30.isArrowFunctionExpression(nodeInit) || t30.isFunctionExpression(nodeInit));
-    if (declaratorPath && nodeInit && (t30.isArrowFunctionExpression(nodeInit) || t30.isFunctionExpression(nodeInit))) {
+    const isReactiveApiCallVarBinding = !!declaratorPath && t31.isCallExpression(nodeInit) && t31.isIdentifier(nodeInit.callee) && reactiveStateApis.has(nodeInit.callee.name);
+    const isHookCallVarBinding = !!declaratorPath && t31.isCallExpression(nodeInit) && isHookLikeCallee(nodeInit.callee);
+    const isFunctionBinding = bindingPath.isFunctionDeclaration() || !!declaratorPath && !!nodeInit && (t31.isArrowFunctionExpression(nodeInit) || t31.isFunctionExpression(nodeInit));
+    if (declaratorPath && nodeInit && (t31.isArrowFunctionExpression(nodeInit) || t31.isFunctionExpression(nodeInit))) {
       markAsAnalyzed(nodeInit, false);
     }
     return isImportBinding || isReactiveVarBinding || isReactiveApiCallVarBinding || isHookCallVarBinding || isFunctionBinding;
   }
   function isHookLikeCallee(callee) {
-    if (t30.isIdentifier(callee)) {
+    if (t31.isIdentifier(callee)) {
       return callee.name.startsWith("use");
     }
-    if (t30.isMemberExpression(callee) && !callee.computed && t30.isIdentifier(callee.property)) {
+    if (t31.isMemberExpression(callee) && !callee.computed && t31.isIdentifier(callee.property)) {
       return callee.property.name.startsWith("use");
     }
     return false;
@@ -3521,7 +3613,7 @@ function analyzeDeps(node, ctx, parentPath) {
   }
   function isExpressionSourcedFromEligibleBinding(exp, scope, seen, depth) {
     if (depth <= 0) return null;
-    if (t30.isIdentifier(exp)) {
+    if (t31.isIdentifier(exp)) {
       const sourceBinding = scope.getBinding(exp.name);
       if (!sourceBinding) return null;
       if (isEligibleBindingSource(sourceBinding)) {
@@ -3529,13 +3621,13 @@ function analyzeDeps(node, ctx, parentPath) {
       }
       return traceBindingSource(sourceBinding, seen, depth - 1);
     }
-    if (t30.isMemberExpression(exp) || t30.isOptionalMemberExpression(exp)) {
+    if (t31.isMemberExpression(exp) || t31.isOptionalMemberExpression(exp)) {
       const root = findRootIdentifier(exp);
       if (!root) return null;
       const sourceBinding = scope.getBinding(root.name);
       if (!sourceBinding) return null;
       if (isEligibleBindingSource(sourceBinding)) {
-        return t30.cloneNode(exp);
+        return t31.cloneNode(exp);
       }
       const sourcedRoot = traceBindingSource(sourceBinding, seen, depth - 1);
       if (sourcedRoot) {
@@ -3543,17 +3635,17 @@ function analyzeDeps(node, ctx, parentPath) {
         if (rebuilt) {
           return rebuilt;
         }
-        return t30.cloneNode(sourcedRoot, true);
+        return t31.cloneNode(sourcedRoot, true);
       }
     }
     return null;
   }
   function rebuildMemberWithNewRoot(node2, nextRoot) {
     const replacedObject = (() => {
-      if (t30.isIdentifier(node2.object)) {
-        return t30.cloneNode(nextRoot, true);
+      if (t31.isIdentifier(node2.object)) {
+        return t31.cloneNode(nextRoot, true);
       }
-      if (t30.isMemberExpression(node2.object) || t30.isOptionalMemberExpression(node2.object)) {
+      if (t31.isMemberExpression(node2.object) || t31.isOptionalMemberExpression(node2.object)) {
         return rebuildMemberWithNewRoot(node2.object, nextRoot);
       }
       return null;
@@ -3561,45 +3653,45 @@ function analyzeDeps(node, ctx, parentPath) {
     if (!replacedObject) {
       return null;
     }
-    const property = t30.cloneNode(node2.property, true);
-    if (t30.isMemberExpression(node2)) {
-      return t30.memberExpression(
+    const property = t31.cloneNode(node2.property, true);
+    if (t31.isMemberExpression(node2)) {
+      return t31.memberExpression(
         replacedObject,
         property,
         node2.computed
       );
     }
-    return t30.optionalMemberExpression(
+    return t31.optionalMemberExpression(
       replacedObject,
       property,
       node2.computed,
       node2.optional
     );
   }
-  return t30.arrayExpression(Array.from(deps.values()));
+  return t31.arrayExpression(Array.from(deps.values()));
 }
 function getDependencyKey(exp) {
-  if (t30.isIdentifier(exp)) {
+  if (t31.isIdentifier(exp)) {
     return exp.name;
   }
-  if (t30.isMemberExpression(exp) || t30.isOptionalMemberExpression(exp)) {
+  if (t31.isMemberExpression(exp) || t31.isOptionalMemberExpression(exp)) {
     const objectKey = getDependencyKey(exp.object);
     const opt = exp.optional ? "?" : "";
-    if (!exp.computed && t30.isIdentifier(exp.property)) {
+    if (!exp.computed && t31.isIdentifier(exp.property)) {
       return `${objectKey}${opt}.${exp.property.name}`;
     }
-    if (t30.isStringLiteral(exp.property) || t30.isNumericLiteral(exp.property)) {
+    if (t31.isStringLiteral(exp.property) || t31.isNumericLiteral(exp.property)) {
       return `${objectKey}${opt}[${JSON.stringify(exp.property.value)}]`;
     }
     return `${objectKey}${opt}[*]`;
   }
   return exp.type;
 }
-function isNestedMemberObject(path7) {
-  const parent = path7.parentPath;
+function isNestedMemberObject(path8) {
+  const parent = path8.parentPath;
   if (!parent) return false;
   if (parent.isMemberExpression() || parent.isOptionalMemberExpression()) {
-    return parent.node.object === path7.node;
+    return parent.node.object === path8.node;
   }
   return false;
 }
@@ -3619,15 +3711,15 @@ function getIsAnalyzed(node) {
 // src/core/transform/sfc/script/syntax-processor/process/resolve-analysis-only-adapter.ts
 function resolveAnalysisOnlyAdapter(ctx) {
   return {
-    "CallExpression|Identifier"(path7) {
-      const node = path7.node;
+    "CallExpression|Identifier"(path8) {
+      const node = path8.node;
       const apiName = getApiName(node);
       const adapter = ADAPTER_RULES.runtime[apiName];
       if (!adapter || adapter.type !== "analyzed-deps") {
         return;
       }
-      if (t31.isCallExpression(node)) {
-        resolveCallNode(path7, adapter, ctx);
+      if (t32.isCallExpression(node)) {
+        resolveCallNode(path8, adapter, ctx);
       } else {
         replaceIdName(node, adapter.target);
       }
@@ -3636,24 +3728,24 @@ function resolveAnalysisOnlyAdapter(ctx) {
   };
 }
 function getApiName(node) {
-  const isCallNode = t31.isCallExpression(node);
+  const isCallNode = t32.isCallExpression(node);
   let apiName = "";
-  if (t31.isIdentifier(node)) {
+  if (t32.isIdentifier(node)) {
     apiName = node.name;
-  } else if (isCallNode && t31.isIdentifier(node.callee)) {
+  } else if (isCallNode && t32.isIdentifier(node.callee)) {
     apiName = node.callee.name;
   }
   return apiName;
 }
-function resolveCallNode(path7, adapter, ctx) {
-  const { node } = path7;
+function resolveCallNode(path8, adapter, ctx) {
+  const { node } = path8;
   const { arguments: args } = node;
   if (!args.length) return;
   const fn = args[0];
-  if (!t31.isArrowFunctionExpression(fn) && !t31.isFunctionExpression(fn)) {
+  if (!t32.isArrowFunctionExpression(fn) && !t32.isFunctionExpression(fn)) {
     return;
   }
-  const fnPath = path7.get("arguments")[0];
+  const fnPath = path8.get("arguments")[0];
   const deps = analyzeDeps(fn, ctx, fnPath);
   args.push(deps);
   replaceCallName(node, adapter.target);
@@ -3663,41 +3755,41 @@ function resolveCallNode(path7, adapter, ctx) {
 // src/core/transform/sfc/script/syntax-processor/process/resolve-arrow-deps.ts
 function resolveArrowFnDeps(ctx, ast) {
   return {
-    ArrowFunctionExpression(path7) {
-      const { node, parentPath } = path7;
-      if (isSkip(path7) || !atComponentOrHookRoot(parentPath, ast.program)) {
+    ArrowFunctionExpression(path8) {
+      const { node, parentPath } = path8;
+      if (isSkip(path8) || !atComponentOrHookRoot(parentPath, ast.program)) {
         return;
       }
-      const deps = analyzeDeps(node, ctx, path7);
+      const deps = analyzeDeps(node, ctx, path8);
       if (!deps.elements.length) return;
       const newNode = createUseCallback(node, deps);
-      const declaratorPath = getVariableDeclaratorPath(path7);
+      const declaratorPath = getVariableDeclaratorPath(path8);
       markAsAnalyzed(newNode.arguments[0]);
       recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.useCallback);
       setScriptNodeMeta(declaratorPath?.node, { is_reactive: true, reactive_type: "indirect" });
-      path7.replaceWith(newNode);
+      path8.replaceWith(newNode);
     }
   };
 }
 function resolveUnanalyzedArrow(ctx) {
   return {
-    ArrowFunctionExpression(path7) {
-      const { node } = path7;
+    ArrowFunctionExpression(path8) {
+      const { node } = path8;
       const analyzed = getIsAnalyzed(node);
       if (typeof analyzed === "undefined" || analyzed) return;
       const newNode = createUseCallback(node);
-      const declaratorPath = getVariableDeclaratorPath(path7);
+      const declaratorPath = getVariableDeclaratorPath(path8);
       if (declaratorPath?.node) {
         setScriptNodeMeta(declaratorPath.node, { is_reactive: true, reactive_type: "indirect" });
       }
       markAsAnalyzed(newNode.arguments[0]);
-      path7.replaceWith(newNode);
+      path8.replaceWith(newNode);
     }
   };
 }
-function isSkip(path7) {
-  const { parentPath } = path7;
-  const isVariableDecl = () => getVariableDeclaratorPath(path7) !== null;
+function isSkip(path8) {
+  const { parentPath } = path8;
+  const isVariableDecl = () => getVariableDeclaratorPath(path8) !== null;
   const isReturnFunc = () => !isVariableDecl() && parentPath.isReturnStatement();
   const isCallback = () => {
     if (!parentPath) {
@@ -3706,12 +3798,12 @@ function isSkip(path7) {
     if (parentPath.isCallExpression()) {
       const callExpressionPath = parentPath;
       const args = callExpressionPath.node.arguments;
-      return args.some((arg) => arg === path7.node);
+      return args.some((arg) => arg === path8.node);
     }
     if (parentPath.isArrayExpression()) {
       const arrayExpressionPath = parentPath;
       const elements = arrayExpressionPath.node.elements;
-      return elements.some((element) => element === path7.node);
+      return elements.some((element) => element === path8.node);
     }
     return false;
   };
@@ -3732,16 +3824,16 @@ function isSkip(path7) {
 }
 // src/core/transform/sfc/script/syntax-processor/process/resolve-element-ref.ts
-import * as t32 from "@babel/types";
+import * as t33 from "@babel/types";
 function resolveElementRef(ctx) {
   return {
-    CallExpression(path7) {
+    CallExpression(path8) {
       const {
         inputType,
         templateData: { refBindings }
       } = ctx;
       if (inputType !== "sfc") return;
-      const { node } = path7;
+      const { node } = path8;
       const isUseTemplateRef = isCalleeNamed(node, VUE_API_MAP.useTemplateRef);
       const isCompRefBindings = Object.keys(refBindings.componentRefs).length > 0 && isCalleeNamed(node, VUE_API_MAP.ref);
       const shouldProcess = isUseTemplateRef || isCompRefBindings;
@@ -3749,31 +3841,31 @@ function resolveElementRef(ctx) {
         return;
       }
       if (isCompRefBindings) {
-        const varDeclaratorPath = getVariableDeclaratorPath(path7)?.node;
-        if (!t32.isIdentifier(varDeclaratorPath?.id)) {
+        const varDeclaratorPath = getVariableDeclaratorPath(path8)?.node;
+        if (!t33.isIdentifier(varDeclaratorPath?.id)) {
           return;
         }
         const varName = varDeclaratorPath.id.name;
         const compRef = refBindings.componentRefs[varName];
         if (!compRef) return;
       }
-      node.arguments[0] = t32.identifier("null");
-      resolveTypeParameters(ctx, path7);
+      node.arguments[0] = t33.identifier("null");
+      resolveTypeParameters(ctx, path8);
       replaceCallName(node, REACT_API_MAP.useRef);
       recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.useRef);
     },
-    MemberExpression(path7) {
-      resolveRefValueToCurrent(path7);
+    MemberExpression(path8) {
+      resolveRefValueToCurrent(path8);
     }
   };
 }
-function resolveTypeParameters(ctx, path7) {
+function resolveTypeParameters(ctx, path8) {
   const {
     templateData: { refBindings },
     scriptData
   } = ctx;
-  const { node } = path7;
-  const varDeclaratorNode = getVariableDeclaratorPath(path7)?.node;
+  const { node } = path8;
+  const varDeclaratorNode = getVariableDeclaratorPath(path8)?.node;
   if (!scriptData.lang.startsWith("ts") || !varDeclaratorNode) {
     return;
   }
@@ -3782,45 +3874,45 @@ function resolveTypeParameters(ctx, path7) {
   const compBindingMeta = refBindings.componentRefs[idName];
   if (!node.typeParameters && (domBindingMeta || compBindingMeta)) {
     const type = compBindingMeta ? "any" : domBindingMeta.htmlType;
-    node.typeParameters = t32.tsTypeParameterInstantiation([t32.tsTypeReference(t32.identifier(type))]);
+    node.typeParameters = t33.tsTypeParameterInstantiation([t33.tsTypeReference(t33.identifier(type))]);
   }
 }
-function resolveRefValueToCurrent(path7) {
-  const { node } = path7;
-  if (node.computed || !t32.isIdentifier(node.property) || node.property.name !== "value") {
+function resolveRefValueToCurrent(path8) {
+  const { node } = path8;
+  if (node.computed || !t33.isIdentifier(node.property) || node.property.name !== "value") {
     return;
   }
-  const rootPath = findRootVariablePath(path7);
-  if (!rootPath?.node || !t32.isCallExpression(rootPath.node.init) || !isCalleeNamed(rootPath.node.init, REACT_API_MAP.useRef)) {
+  const rootPath = findRootVariablePath(path8);
+  if (!rootPath?.node || !t33.isCallExpression(rootPath.node.init) || !isCalleeNamed(rootPath.node.init, REACT_API_MAP.useRef)) {
     return;
   }
   const rootId = findRootIdentifier(node);
-  if (!t32.isIdentifier(node.object) || node.object.name !== rootId?.name) {
+  if (!t33.isIdentifier(node.object) || node.object.name !== rootId?.name) {
     return;
   }
   node.property.name = "current";
 }
 // src/core/transform/sfc/script/syntax-processor/process/resolve-expression-memo.ts
-import * as t33 from "@babel/types";
+import * as t34 from "@babel/types";
 function resolveExprMemo(ctx, ast) {
   const isScriptFile = ctx.inputType !== "sfc";
   return {
-    VariableDeclarator(path7) {
-      const { node } = path7;
+    VariableDeclarator(path8) {
+      const { node } = path8;
       const { init } = node;
       if (!init) return;
       const shouldMemo = () => {
-        if (!atComponentOrHookRoot(path7, ast.program, isScriptFile)) {
+        if (!atComponentOrHookRoot(path8, ast.program, isScriptFile)) {
           return false;
         }
-        if (t33.isCallExpression(init) && t33.isIdentifier(init.callee) && init.callee.name.startsWith("use")) {
+        if (t34.isCallExpression(init) && t34.isIdentifier(init.callee) && init.callee.name.startsWith("use")) {
           return false;
         }
         return true;
       };
       if (!shouldMemo()) return;
-      const initPath = path7.get("init");
+      const initPath = path8.get("init");
       if (!initPath.isExpression()) return;
       const deps = analyzeDeps(initPath.node, ctx, initPath);
       if (!deps.elements.length) return;
@@ -3832,13 +3924,13 @@ function resolveExprMemo(ctx, ast) {
 }
 // src/core/transform/sfc/script/syntax-processor/process/resolve-lint-rules.ts
-import * as t34 from "@babel/types";
+import * as t35 from "@babel/types";
 function resolveLintRules(ctx, ast) {
   const inScriptFile = ctx.inputType !== "sfc";
   return {
-    CallExpression(path7) {
-      const { node, parentPath } = path7;
-      if (!t34.isIdentifier(node.callee)) return;
+    CallExpression(path8) {
+      const { node, parentPath } = path8;
+      if (!t35.isIdentifier(node.callee)) return;
       const { name: callName } = node.callee;
       const addLog = (t41) => {
         logger.error(t41, {
@@ -3856,7 +3948,7 @@ function resolveLintRules(ctx, ast) {
           );
           return;
         }
-        if (!atComponentOrHookRoot(path7, ast.program)) {
+        if (!atComponentOrHookRoot(path8, ast.program)) {
           addLog(
             `The ${macro} must be defined at the top level of the component, not inside blocks or functions.`
           );
@@ -3872,7 +3964,7 @@ function resolveLintRules(ctx, ast) {
       };
       const lintHooks = () => {
         if (!callName.startsWith("use")) return;
-        if (!atComponentOrHookRoot(path7, ast.program, inScriptFile)) {
+        if (!atComponentOrHookRoot(path8, ast.program, inScriptFile)) {
           addLog(
             `The ${callName} hook must be called at the top level, not inside loops, conditions, or nested functions.`
           );
@@ -3886,12 +3978,12 @@ function resolveLintRules(ctx, ast) {
 // src/core/transform/sfc/script/syntax-processor/process/resolve-provide.ts
 import { generate as generate3 } from "@babel/generator";
-import * as t35 from "@babel/types";
+import * as t36 from "@babel/types";
 function resolveProvide(ctx) {
   if (ctx.inputType === "style") return {};
   return {
-    CallExpression(path7) {
-      const { node } = path7;
+    CallExpression(path8) {
+      const { node } = path8;
       const providerTarget = ADAPTER_RULES.runtime[VUE_API_MAP.provide]?.target;
       const isProvideCall = isCalleeNamed(node, VUE_API_MAP.provide) || providerTarget && isCalleeNamed(node, providerTarget);
       if (!isProvideCall) return;
@@ -3901,7 +3993,7 @@ function resolveProvide(ctx) {
       const adapter = ADAPTER_RULES.runtime[VUE_API_MAP.provide];
       assignProviderValue(target, key, value);
       recordImport(ctx, adapter.package, adapter.target);
-      path7.parentPath.remove();
+      path8.parentPath.remove();
     }
   };
 }
@@ -3918,13 +4010,13 @@ function findOrCreateCtxProvider(root) {
 function assignProviderValue(target, key, value) {
   const getRawExp = (exp) => {
     if (!exp) return "''";
-    if (t35.isStringLiteral(exp)) {
+    if (t36.isStringLiteral(exp)) {
       return JSON.stringify(exp.value);
     }
-    if (t35.isNumericLiteral(exp)) {
+    if (t36.isNumericLiteral(exp)) {
       return exp.value.toString();
     }
-    if (t35.isIdentifier(exp)) {
+    if (t36.isIdentifier(exp)) {
       return exp.name;
     }
     try {
@@ -3940,16 +4032,16 @@ function assignProviderValue(target, key, value) {
 }
 // src/core/transform/sfc/script/syntax-processor/process/resolve-rename-adapter.ts
-import * as t36 from "@babel/types";
+import * as t37 from "@babel/types";
 function resolveRenameAdapter(ctx) {
   return {
-    "CallExpression|Identifier"(path7) {
-      const node = path7.node;
-      const isCallNode = t36.isCallExpression(node);
+    "CallExpression|Identifier"(path8) {
+      const node = path8.node;
+      const isCallNode = t37.isCallExpression(node);
       let apiName = "";
-      if (t36.isIdentifier(node)) {
+      if (t37.isIdentifier(node)) {
         apiName = node.name;
-      } else if (isCallNode && t36.isIdentifier(node.callee)) {
+      } else if (isCallNode && t37.isIdentifier(node.callee)) {
         apiName = node.callee.name;
       }
       const runtimeAdapter = ADAPTER_RULES.runtime[apiName];
@@ -3960,7 +4052,7 @@ function resolveRenameAdapter(ctx) {
       }
       if (adapter.isTrackable) {
         const reactiveType = getReactiveType(apiName);
-        const declaratorPath = getVariableDeclaratorPath(path7);
+        const declaratorPath = getVariableDeclaratorPath(path8);
         setScriptNodeMeta(declaratorPath?.node, {
           is_reactive: true,
           reactive_type: reactiveType
@@ -4105,7 +4197,7 @@ import * as t39 from "@babel/types";
 // src/shared/string-code-types.ts
 import { parseExpression as parseExpression3 } from "@babel/parser";
-import * as t37 from "@babel/types";
+import * as t38 from "@babel/types";
 var strCodeTypes = {
   isIdentifier: isIdentifier20,
   isSimpleExpression,
@@ -4118,22 +4210,22 @@ function isSimpleExpression(code, excludeVar = false) {
   } catch {
     return false;
   }
-  if (t37.isLiteral(node)) {
+  if (t38.isLiteral(node)) {
     return true;
   }
-  if (!excludeVar && t37.isIdentifier(node)) {
+  if (!excludeVar && t38.isIdentifier(node)) {
     return true;
   }
-  if (t37.isMemberExpression(node)) {
-    return isSimpleExpression(node.object) && t37.isIdentifier(node.property);
+  if (t38.isMemberExpression(node)) {
+    return isSimpleExpression(node.object) && t38.isIdentifier(node.property);
   }
-  if (t37.isObjectExpression(node) || t37.isArrayExpression(node)) {
+  if (t38.isObjectExpression(node) || t38.isArrayExpression(node)) {
     return false;
   }
-  if (t37.isCallExpression(node) || t37.isAssignmentExpression(node)) {
+  if (t38.isCallExpression(node) || t38.isAssignmentExpression(node)) {
     return false;
   }
-  if (t37.isBinaryExpression(node) || t37.isUnaryExpression(node)) {
+  if (t38.isBinaryExpression(node) || t38.isUnaryExpression(node)) {
     return true;
   }
   return false;
@@ -4141,7 +4233,7 @@ function isSimpleExpression(code, excludeVar = false) {
 function isIdentifier20(code) {
   try {
     const node = parseExpression3(code);
-    return t37.isIdentifier(node);
+    return t38.isIdentifier(node);
   } catch {
     return false;
   }
@@ -4149,69 +4241,12 @@ function isIdentifier20(code) {
 function isStringLiteral12(code) {
   try {
     const node = parseExpression3(code);
-    return t37.isStringLiteral(node) || t37.isTemplateLiteral(node);
+    return t38.isStringLiteral(node) || t38.isTemplateLiteral(node);
   } catch {
     return false;
   }
 }
-// src/core/transform/sfc/template/shared/resolve-string-expression/index.ts
-import * as t38 from "@babel/types";
-// src/core/transform/sfc/template/shared/resolve-string-expression/special-expressions.ts
-function resolveSpecialExpressions(input, ctx) {
-  input = resolveEmitsCalls(input, ctx);
-  input = resolveRefVariable(input, ctx);
-  return input;
-}
-function resolveEmitsCalls(input, ctx) {
-  const result = matchEmitCalls(input, ctx);
-  if (!result) return input;
-  const [, , eventName, args] = result;
-  const callee = eventName.split(/[:\-]/).map((part) => capitalize(camelCase(part))).join("");
-  const event = args ? `on${callee}?.(${args})` : `on${callee}?.()`;
-  return `${ctx.propField}?.${event}`;
-}
-function matchEmitCalls(input, ctx) {
-  const { reactiveBindings } = ctx.templateData;
-  const macroBinding = Object.values(reactiveBindings).find((b) => b.source === "defineEmits");
-  if (!macroBinding) return null;
-  const escapedName = macroBinding.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const regex = new RegExp(
-    `${escapedName}\\s*\\(\\s*(['"\`])([^\\1]*?)\\1\\s*(?:,\\s*(.*?))?\\s*\\)$`,
-    // 可选的第二个参数
-    "s"
-    // s 标志让 . 匹配换行符
-  );
-  return input.trim().match(regex);
-}
-function resolveRefVariable(input, ctx) {
-  const { reactiveBindings } = ctx.templateData;
-  const addValueProperty = (input2, varName) => {
-    const escapedVarName = varName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const regex = new RegExp(`(?<![a-zA-Z0-9_])${escapedVarName}(?![a-zA-Z0-9_])(?!\\.value)`, "g");
-    return input2.replace(regex, `${varName}.value`);
-  };
-  for (const name in reactiveBindings) {
-    const binding = reactiveBindings[name];
-    if (binding?.reactiveType !== "ref") continue;
-    input = addValueProperty(input, name);
-  }
-  return input;
-}
-// src/core/transform/sfc/template/shared/resolve-string-expression/index.ts
-function resolveStringExpr(input, ctx, toStrLiteral = false) {
-  if (toStrLiteral) return t38.stringLiteral(input);
-  const { filename, scriptData } = ctx;
-  const newContent = resolveSpecialExpressions(input, ctx);
-  try {
-    return stringToExpr(newContent, scriptData.lang, filename);
-  } catch {
-    return t38.identifier(newContent);
-  }
-}
 // src/core/transform/sfc/template/shared/style-utils.ts
 function parseStyleString(styleStr) {
   if (isSimpleStyle(styleStr) || strCodeTypes.isIdentifier(styleStr)) {
@@ -5425,7 +5460,7 @@ function transform(ast, ctx, options) {
 }
 // package.json
-var version = "1.2.1";
+var version = "1.3.0";
 var bin = {
   vureact: "./bin/vureact.js"
 };
@@ -5737,9 +5772,9 @@ var Helper = class {
     };
   }
   async removeOutputFile(filePath, resolveOutputPath) {
-    const path7 = resolveOutputPath ? this.resolveOutputPath(filePath) : filePath;
-    if (!fs.existsSync(path7)) return;
-    await fs.promises.unlink(path7);
+    const path8 = resolveOutputPath ? this.resolveOutputPath(filePath) : filePath;
+    if (!fs.existsSync(path8)) return;
+    await fs.promises.unlink(path8);
   }
   updateCache(targetFile, newData, cache) {
     const index = cache.target.findIndex((c) => c.file === targetFile);
@@ -5804,12 +5839,12 @@ var Helper = class {
   /**
    * 读取 package.json 文件内容，并处理成对象返回
    */
-  async resolvePackageFile(path7) {
+  async resolvePackageFile(path8) {
     try {
-      if (!fs.existsSync(path7)) {
+      if (!fs.existsSync(path8)) {
         return {};
       }
-      return JSON.parse(await fs.promises.readFile(path7, "utf-8"));
+      return JSON.parse(await fs.promises.readFile(path8, "utf-8"));
     } catch (error) {
       console.error(error);
       return {};
@@ -6330,10 +6365,12 @@ var CacheManager = class {
     const meta = { ...unit };
     delete meta.source;
     if (key === "sfc" /* SFC */) {
-      delete meta.output.jsx.code;
-      delete meta.output.css.code;
+      delete meta.output?.jsx.code;
+      delete meta.output?.css.code;
     } else if (key === "script" /* SCRIPT */) {
-      delete meta.output.script.code;
+      delete meta.output?.script.code;
+    } else if (key === "style" /* STYLE */) {
+      delete meta.output?.style.code;
     }
     this.updateCache(unit.file, meta, cache);
     await this.fileCompiler.saveCache(cache);
@@ -6494,6 +6531,7 @@ var CompilationUnitProcessor = class {
 // src/compiler/shared/file-compiler/file-processor.ts
 import fs3 from "fs";
+import path6 from "path";
 var FileProcessor = class {
   constructor(fileCompiler, compilationUnitProcessor, cacheManager) {
     this.fileCompiler = fileCompiler;
@@ -6552,6 +6590,7 @@ var FileProcessor = class {
       if (key === "sfc" /* SFC */ || key === "script" /* SCRIPT */) {
         if (processed?.hasRoute) {
           await this.injectVuReactRouteDep();
+          await this.copyRouteSetupNotes();
         }
       }
       await this.cacheManager.updateCacheIncrementally(processed, key);
@@ -6562,13 +6601,34 @@ var FileProcessor = class {
     const pkgPath = this.fileCompiler.getOutputPkgPath();
     const pkg = await this.fileCompiler.resolvePackageFile(pkgPath);
     const { router } = this.pkgs;
+    if (!pkg["dependencies"]) {
+      pkg["dependencies"] = {};
+    }
     pkg["dependencies"][router.name] = router.version;
     await fs3.promises.writeFile(pkgPath, JSON.stringify(pkg, null, 2), "utf-8");
   }
+  /**
+   * 如果使用了路由，则拷贝路由配置说明文档到输出目录根部。
+   */
+  async copyRouteSetupNotes() {
+    const outputDir = this.fileCompiler.getOuputPath();
+    const packageRoot = path6.resolve(getDirname(import.meta.url), "../");
+    const templateDir = path6.join(packageRoot, "templates");
+    if (!fs3.existsSync(templateDir)) {
+      return;
+    }
+    const files = ["route-setup-notes.md", "route-setup-notes.zh.md"];
+    for (const file of files) {
+      const srcPath = path6.join(templateDir, file);
+      if (!fs3.existsSync(srcPath)) continue;
+      const destPath = path6.join(outputDir, file);
+      await fs3.promises.copyFile(srcPath, destPath);
+    }
+  }
 };
 // src/compiler/shared/file-compiler/pipeline-manager.ts
-import path6 from "path";
+import path7 from "path";
 var PipelineManager = class {
   constructor(fileCompiler, fileProcessor) {
     this.fileCompiler = fileCompiler;
@@ -6603,7 +6663,7 @@ var PipelineManager = class {
     const scriptExtRegex = /\.(js|ts)$/i;
     const styleExtRegex = /\.(css|less|sass|scss)$/i;
     const files = this.fileCompiler.scanFiles(inputPath, (p) => {
-      const ext = path6.extname(p);
+      const ext = path7.extname(p);
       if (key === "sfc" /* SFC */) {
         return ext === ".vue";
       }
@@ -6816,27 +6876,55 @@ var FileCompiler = class extends BaseCompiler {
     }
     await this.viteBootstrapper.bootstrapIfNeeded();
     try {
-      this.spinner.start("Compiling Vue files...");
-      const sfcCount = await this.pipelineManager.runSfcPipeline();
-      this.spinner.stop();
-      this.spinner.start("Compiling script files...");
-      const scriptCount = await this.pipelineManager.runScriptPipeline();
-      this.spinner.stop();
-      this.spinner.start("Compiling style files...");
-      const styleCount = await this.pipelineManager.runStylePipeline();
-      this.spinner.stop();
-      this.spinner.start("Copying assets...");
-      const assetCount = await this.assetManager.runAssetPipeline();
-      this.spinner.stop();
+      const sfcCount = await this.runPipelineWithSpinner("sfc" /* SFC */);
+      const scriptCount = await this.runPipelineWithSpinner("script" /* SCRIPT */);
+      const styleCount = await this.runPipelineWithSpinner("style" /* STYLE */);
+      const assetCount = await this.runPipelineWithSpinner("copied" /* ASSET */);
       await this.options.onSuccess?.();
       const endTime = calcElapsedTime(startTime);
       this.printCoreLogs();
       this.showCompileStats(endTime, sfcCount, scriptCount, styleCount, assetCount);
     } catch (error) {
-      this.spinner.stop();
       const endTime = calcElapsedTime(startTime);
-      console.error(kleur6.red("\u2716"), `Build failed in ${endTime}
-`);
+      console.error(kleur6.red("\u2716"), `Build failed in ${endTime}`);
+      console.error(error);
+    }
+  }
+  /**
+   * 运行管线并显示加载动画
+   *
+   * @private
+   * @param text - 加载动画显示的文本
+   * @param pipelineFn - 要执行的管线函数
+   * @returns 返回的处理的文件数
+   */
+  async runPipelineWithSpinner(name) {
+    const options = {
+      ["sfc" /* SFC */]: {
+        text: "Compiling Vue files...",
+        pipeline: () => this.pipelineManager.runSfcPipeline()
+      },
+      ["script" /* SCRIPT */]: {
+        text: "Compiling script files...",
+        pipeline: () => this.pipelineManager.runScriptPipeline()
+      },
+      ["style" /* STYLE */]: {
+        text: "Compiling style files...",
+        pipeline: () => this.pipelineManager.runStylePipeline()
+      },
+      ["copied" /* ASSET */]: {
+        text: "Copying assets...",
+        pipeline: () => this.assetManager.runAssetPipeline()
+      }
+    };
+    const { text, pipeline } = options[name];
+    try {
+      this.spinner.start(text);
+      return await pipeline();
+    } catch (err) {
+      throw err;
+    } finally {
+      this.spinner.stop();
     }
   }
   /**
@@ -7006,6 +7094,7 @@ var VuReact = class extends FileCompiler {
 };
 export {
+  getDirname,
   normalizePath,
   calcElapsedTime,
   generateComponent,