@vureact/compiler-core 1.5.0 → 1.5.2

package/lib/{chunk-IGLKQRRZ.esm.js → chunk-UYTNAOAJ.esm.js}

@@ -1,5 +1,5 @@
 /**
- * @vureact/compiler-core v1.5.0
+ * @vureact/compiler-core v1.5.2
  * (c) 2025-present Ruihong Zhong (Ryan John)
  * @license MIT
  */
@@ -1029,7 +1029,7 @@ function buildStandardProp(nodeIR) {
     babelExp: { ast: keyAST },
     value: {
       content,
-      isStringLiteral: isStringLiteral13,
+      isStringLiteral: isStringLiteral12,
       babelExp: { ast: valueAST }
     }
   } = nodeIR;
@@ -1038,7 +1038,7 @@ function buildStandardProp(nodeIR) {
   }
   let value;
   if (content !== "true") {
-    value = isStringLiteral13 ? t9.stringLiteral(content) : buildJsxExpressionNode(valueAST);
+    value = isStringLiteral12 ? t9.stringLiteral(content) : buildJsxExpressionNode(valueAST);
   }
   return t9.jsxAttribute(keyAST, value);
 }
@@ -1385,7 +1385,12 @@ function generateComponent(ir, ctx, options) {
       quotes: "single"
       // 使用单引号
     },
-    minified: true,
+    minified: false,
+    // 不压缩输出内容
+    retainLines: false,
+    // 不保留行号
+    retainFunctionParens: true,
+    // 保留函数括号
     ...options
   });
   const result = {
@@ -1450,113 +1455,45 @@ import {
 } from "@vue/compiler-sfc";
 
 // src/core/parse/sfc/process/resolve-script.ts
-import { generate as generate2 } from "@babel/generator";
 import { parse as babelParse2 } from "@babel/parser";
-import * as t15 from "@babel/types";
-function resolveScript(descriptor, ctx, pResult) {
-  const scriptBlock = descriptor.scriptSetup || descriptor.script;
-  if (!scriptBlock) return null;
-  const result = {
-    ast: {},
-    source: scriptBlock
-  };
-  const options = getBabelParseOptions(scriptBlock.lang, "script", ctx.filename);
+function resolveScript(descriptor, ctx, parseResult) {
   if (descriptor.script) {
-    const { code, ast, name } = extractSetupBodyToTopLevel(scriptBlock.content, options);
-    if (ast) {
-      result.source.content = code;
-      result.ast = ast;
-      ctx.compName = name;
-    }
-    logger.warn(
-      "Using traditional script (instead of <script setup>) may result in unstable or non-functional React code. It is recommended to use <script setup> instead.",
-      { file: ctx.filename }
+    throw new Error(
+      `Traditional Vue <script> syntax is not supported. Please migrate to <script setup>. 
+    at <anonymous> (${ctx.filename})`
     );
-  } else {
-    result.ast = babelParse2(result.source.content, options);
   }
-  if (scriptBlock?.warnings) {
-    scriptBlock?.warnings.forEach((msg) => {
+  const { scriptSetup } = descriptor;
+  if (!scriptSetup) return null;
+  if (scriptSetup?.warnings) {
+    scriptSetup?.warnings.forEach((msg) => {
       logger.warn(msg, { file: ctx.filename });
     });
   }
-  const source = scriptBlock.content;
-  ctx.scriptData.source = source;
-  ctx.compName = extractCompName(source);
-  ctx.scriptData.lang = scriptBlock.lang || "js";
-  pResult.script = result;
-}
-function extractSetupBodyToTopLevel(content, options) {
-  let name = "";
-  try {
-    const ast = babelParse2(content, options);
-    const importNodes = [];
-    const otherTopLevel = [];
-    let setupStatements = [];
-    for (const node of ast.program.body) {
-      if (t15.isImportDeclaration(node)) {
-        importNodes.push(node);
-        continue;
-      }
-      if (t15.isExportDefaultDeclaration(node)) {
-        const decl = node.declaration;
-        if (decl && t15.isObjectExpression(decl)) {
-          const nameProp = decl.properties.find((p) => {
-            if (t15.isObjectProperty(p)) {
-              const key = p.key;
-              return t15.isIdentifier(key) && key.name === "name" || t15.isStringLiteral(key) && key.value === "name";
-            }
-            return false;
-          });
-          if (nameProp && t15.isObjectProperty(nameProp)) {
-            if (t15.isStringLiteral(nameProp.value)) {
-              name = nameProp.value.value;
-            }
-          }
-          const setupProp = decl.properties.find((p) => {
-            if (t15.isObjectMethod(p)) {
-              return p.key && p.key.name === "setup";
-            }
-            if (t15.isObjectProperty(p)) {
-              const key = p.key;
-              return t15.isIdentifier(key) && key.name === "setup" || t15.isStringLiteral(key) && key.value === "setup";
-            }
-            return false;
-          });
-          if (setupProp) {
-            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 (t15.isReturnStatement(stmt)) continue;
-                setupStatements.push(stmt);
-              }
-            }
-          }
-        }
-        continue;
-      }
-      otherTopLevel.push(node);
-    }
-    const parts = [];
-    const stmts = importNodes.concat(otherTopLevel, setupStatements);
-    for (const n of stmts) {
-      parts.push(generate2(n).code);
-    }
-    return { name, ast, code: parts.join("\n\n") };
-  } catch (e) {
-    console.error(e);
-    return { name, code: content };
-  }
+  resolveContext(scriptSetup, ctx);
+  const parseOpts = getBabelParseOptions(scriptSetup.lang, "script", ctx.filename);
+  parseResult.script = {
+    ast: babelParse2(scriptSetup.content, parseOpts),
+    source: scriptSetup
+  };
 }
-function extractCompName(source) {
-  const nameMatch = source.match(/@vr-name:\s*(\w+)/);
-  return nameMatch?.[1]?.trim() || "";
+function resolveContext(scriptSetup, ctx) {
+  let { content, lang } = scriptSetup;
+  const resolveVRComment = (source) => {
+    const regx = /\/\/\s*@vr-name:\s*(\w+)/;
+    const nameMatch = source.match(regx);
+    content = content.replace(regx, "");
+    return nameMatch?.[1]?.trim() || "";
+  };
+  ctx.compName = resolveVRComment(content);
+  ctx.scriptData.source = content;
+  ctx.scriptData.lang = lang || "js";
+  scriptSetup.content = content;
 }
 
 // src/core/parse/sfc/process/resolve-script-meta.ts
 import { traverse } from "@babel/core";
-import * as t16 from "@babel/types";
+import * as t15 from "@babel/types";
 
 // src/consts/html-tag-types.ts
 var HTML_TAG_TYPES = {
@@ -1662,10 +1599,10 @@ function resolveScriptMeta(result, ctx) {
   traverse(scriptAST, {
     VariableDeclarator(path9) {
       const { node } = path9;
-      if (!atComponentOrHookRoot(path9, scriptAST.program) || !t16.isIdentifier(node.id)) {
+      if (!atComponentOrHookRoot(path9, scriptAST.program) || !t15.isIdentifier(node.id)) {
         return;
       }
-      if (node.init && t16.isCallExpression(node.init) && t16.isIdentifier(node.init.callee)) {
+      if (node.init && t15.isCallExpression(node.init) && t15.isIdentifier(node.init.callee)) {
         collectReactiveBindings(node, ctx);
         collectRefBindings(node, ctx);
       }
@@ -1936,265 +1873,8 @@ import { parse as babelParse3 } from "@babel/parser";
 // src/core/transform/sfc/script/syntax-processor/index.ts
 import { traverse as traverse3 } from "@babel/core";
 
-// src/core/transform/sfc/script/syntax-processor/postprocess/insert-css-import.ts
-import * as t17 from "@babel/types";
-function insertCSSImport(ctx) {
-  const { inputType } = ctx;
-  if (inputType !== "sfc") return;
-  const { filePath, moduleName } = ctx.styleData;
-  if (!filePath) return;
-  const scriptIR = getScriptIR(ctx);
-  const filename = normalizePath(filePath).split("/").pop();
-  const importPath = `./${filename}`;
-  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/resolve-required-imports/index.ts
-import * as t18 from "@babel/types";
-
-// src/core/transform/shared.ts
-function recordImport(ctx, pkg, name, onDemand = true) {
-  const { imports } = ctx;
-  if (isTypeOnlyImport(name)) {
-    name = `type ${name}`;
-  }
-  if (imports.has(pkg)) {
-    const list = imports.get(pkg);
-    const foundItem = list.find((item) => item.name === name);
-    if (!foundItem) {
-      list.push({ name, onDemand });
-    }
-    return;
-  }
-  imports.set(pkg, [{ name, onDemand }]);
-}
-function isTypeOnlyImport(name) {
-  const arr = [REACT_API_MAP.ReactNode];
-  return arr.includes(name);
-}
-
-// src/core/transform/sfc/script/shared/replace-vue-suffix.ts
-function replaceVueSuffix(ctx, node) {
-  if (!node.value.endsWith(".vue")) return;
-  const jsxFile = node.value.replace(/.vue$/, "");
-  node.value = jsxFile;
-  node.extra = { rawValue: jsxFile, raw: jsxFile };
-}
-
-// src/core/transform/sfc/script/syntax-processor/postprocess/resolve-required-imports/import-strategies.ts
-var VueRouterStrategy = class {
-  matches(moduleName) {
-    return moduleName === "vue-router" || moduleName.startsWith("vue-router/");
-  }
-  process() {
-    return {
-      shouldReplaceSource: true,
-      newSource: PACKAGE_NAME.router,
-      shouldRemove: false,
-      shouldInjectRuntimeImports: false
-    };
-  }
-};
-var VueEcosystemStrategy = class {
-  matches(moduleName) {
-    if (moduleName.startsWith(".") || moduleName.startsWith("/") || moduleName.startsWith("file:")) {
-      return false;
-    }
-    if (moduleName === "vue-router" || moduleName.startsWith("vue-router/")) {
-      return false;
-    }
-    if (moduleName.startsWith("@vue/")) {
-      return true;
-    }
-    for (const pkg of VUE_PACKAGES) {
-      if (moduleName === pkg || moduleName.startsWith(`${pkg}/`)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  process() {
-    return {
-      shouldReplaceSource: false,
-      shouldRemove: true,
-      shouldInjectRuntimeImports: true
-    };
-  }
-};
-var StyleFileStrategy = class {
-  regExp = /\.(less|sass|scss)$/i;
-  matches(moduleName) {
-    return this.regExp.test(moduleName);
-  }
-  process(path9, ctx) {
-    if (!ctx.preprocessStyles) {
-      return {};
-    }
-    const importSource = path9.node.source.value;
-    if (typeof importSource !== "string") {
-      return {};
-    }
-    return {
-      shouldReplaceSource: true,
-      newSource: importSource.replace(this.regExp, ".css"),
-      shouldRemove: false,
-      shouldInjectRuntimeImports: false
-    };
-  }
-};
-
-// src/core/transform/sfc/script/syntax-processor/postprocess/resolve-required-imports/import-strategy-manager.ts
-var ImportStrategyManager = class {
-  strategies = [];
-  constructor() {
-    this.strategies.push(new VueRouterStrategy());
-    this.strategies.push(new VueEcosystemStrategy());
-    this.strategies.push(new StyleFileStrategy());
-  }
-  /** 添加自定义策略 */
-  addStrategy(strategy) {
-    this.strategies.push(strategy);
-  }
-  /** 查找匹配的策略 */
-  findStrategy(moduleName) {
-    for (const strategy of this.strategies) {
-      if (strategy.matches(moduleName)) {
-        return strategy;
-      }
-    }
-    return null;
-  }
-};
-
-// src/core/transform/sfc/script/syntax-processor/postprocess/resolve-required-imports/index.ts
-function resolveRequiredImports(ctx) {
-  const processedModules = /* @__PURE__ */ new Set();
-  let hasProcessedImports = false;
-  const strategyManager = new ImportStrategyManager();
-  if (ctx.inputType === "sfc") {
-    recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.memo);
-  }
-  function resolveRequiredImport(path9) {
-    const { node } = path9;
-    const originalModuleName = node.source.value.toLowerCase();
-    const strategy = strategyManager.findStrategy(originalModuleName);
-    if (strategy) {
-      const result = strategy.process(path9, ctx, originalModuleName);
-      if (result.shouldReplaceSource && result.newSource) {
-        node.source.value = result.newSource;
-      }
-    }
-    const normalizedModuleName = node.source.value.toLowerCase();
-    mergeImports(node, ctx, normalizedModuleName);
-    if (processedModules.has(normalizedModuleName) && !path9.removed) {
-      path9.remove();
-      return;
-    }
-    processedModules.add(normalizedModuleName);
-    if (!hasProcessedImports) {
-      const required = createRequiredImports(ctx);
-      if (strategy) {
-        const result = strategy.process(path9, ctx, originalModuleName);
-        if (result.shouldRemove) {
-          path9.replaceWithMultiple(required);
-        } else if (normalizedModuleName === PACKAGE_NAME.react) {
-          path9.insertAfter(required);
-        } else {
-          path9.insertBefore(required);
-        }
-      } else {
-        if (normalizedModuleName === PACKAGE_NAME.react) {
-          path9.insertAfter(required);
-        } else {
-          path9.insertBefore(required);
-        }
-      }
-      hasProcessedImports = true;
-    }
-    if (strategy) {
-      const result = strategy.process(path9, ctx, originalModuleName);
-      if (result.shouldRemove && !path9.removed) {
-        path9.remove();
-        return;
-      }
-    }
-    replaceVueSuffix(ctx, node.source);
-  }
-  return {
-    // 兜底：无 ImportDeclaration 的文件也要能注入必需依赖。
-    Program: {
-      exit(path9) {
-        if (hasProcessedImports) return;
-        const required = createRequiredImports(ctx);
-        path9.unshiftContainer("body", required);
-        hasProcessedImports = true;
-      }
-    },
-    ImportDeclaration(path9) {
-      resolveRequiredImport(path9);
-    }
-  };
-}
-function mergeImports(currentNode, ctx, moduleName) {
-  const ctxImportItems = ctx.imports.get(moduleName);
-  if (!ctxImportItems?.length) {
-    return;
-  }
-  const currentImports = /* @__PURE__ */ new Set();
-  for (const spec of currentNode.specifiers) {
-    if (t18.isImportSpecifier(spec) && t18.isIdentifier(spec.imported)) {
-      currentImports.add(spec.imported.name);
-    }
-    if (t18.isImportDefaultSpecifier(spec) && t18.isIdentifier(spec.local)) {
-      currentImports.add(spec.local.name);
-    }
-  }
-  for (const item of ctxImportItems) {
-    if (currentImports.has(item.name)) {
-      continue;
-    }
-    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);
-}
-function createRequiredImports(ctx) {
-  const result = [];
-  const importMap = {};
-  ctx.imports.forEach((items, moduleName) => {
-    const specifier = [];
-    for (const item of items) {
-      const local = t18.identifier(item.name);
-      if (!item.onDemand) {
-        specifier.push(t18.importDefaultSpecifier(local));
-      } else {
-        specifier.push(t18.importSpecifier(local, local));
-      }
-    }
-    importMap[moduleName] = specifier;
-  });
-  for (const name in importMap) {
-    const specifiers = importMap[name];
-    const importDecl = t18.importDeclaration(specifiers, t18.stringLiteral(name));
-    if (name === PACKAGE_NAME.react) {
-      result.unshift(importDecl);
-    } else {
-      result.push(importDecl);
-    }
-  }
-  return result;
-}
-
-// src/core/transform/sfc/script/syntax-processor/postprocess/resolve-static-hoisting.ts
-import * as t20 from "@babel/types";
-
 // src/core/transform/sfc/script/shared/babel-utils.ts
-import * as t19 from "@babel/types";
+import * as t16 from "@babel/types";
 function findRootVariablePath(path9) {
   const rootId = findRootIdentifier(path9.node);
   if (!rootId?.name) return null;
@@ -2205,10 +1885,10 @@ function findRootVariablePath(path9) {
 }
 function findRootIdentifier(node) {
   let current = node.object;
-  while (t19.isMemberExpression(current) || t19.isOptionalMemberExpression(current)) {
+  while (t16.isMemberExpression(current) || t16.isOptionalMemberExpression(current)) {
     current = current.object;
   }
-  return t19.isIdentifier(current) ? current : null;
+  return t16.isIdentifier(current) ? current : null;
 }
 function getVariableDeclaratorPath(path9) {
   if (path9.isVariableDeclarator()) {
@@ -2292,14 +1972,14 @@ function isPropertyName(path9) {
 }
 function replaceCallName(callExp, identifierName) {
   const { callee } = callExp;
-  if (!t19.isIdentifier(callee)) return;
+  if (!t16.isIdentifier(callee)) return;
   callee.name = identifierName;
   if (callee.loc) {
     callee.loc.identifierName = identifierName;
   }
 }
 function replaceIdName(id, newName) {
-  if (!t19.isIdentifier(id)) return;
+  if (!t16.isIdentifier(id)) return;
   id.name = newName;
   if (id.loc) {
     id.loc.identifierName = newName;
@@ -2309,69 +1989,110 @@ function stringValueToTSType(ctx, input, tsTypeAnnotation7) {
   const { filename, scriptData } = ctx;
   const exp = stringToExpr(input, scriptData.lang, filename);
   const ts = expressionToTSType(exp);
-  return tsTypeAnnotation7 ? t19.tsTypeAnnotation(ts) : ts;
+  return tsTypeAnnotation7 ? t16.tsTypeAnnotation(ts) : ts;
 }
 function expressionToTSType(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)) {
+  if (t16.isStringLiteral(exp)) return t16.tsStringKeyword();
+  if (t16.isNumericLiteral(exp)) return t16.tsNumberKeyword();
+  if (t16.isBooleanLiteral(exp)) return t16.tsBooleanKeyword();
+  if (t16.isArrayExpression(exp)) return t16.tsArrayType(t16.tsAnyKeyword());
+  if (t16.isObjectExpression(exp)) {
     const members = [];
     for (const p of exp.properties) {
-      if (!t19.isObjectProperty(p)) continue;
+      if (!t16.isObjectProperty(p)) continue;
       let key;
-      if (t19.isIdentifier(p.key)) key = p.key.name;
-      else if (t19.isStringLiteral(p.key)) key = p.key.value;
+      if (t16.isIdentifier(p.key)) key = p.key.name;
+      else if (t16.isStringLiteral(p.key)) key = p.key.value;
       if (!key) continue;
-      if (t19.isExpression(p.value)) {
+      if (t16.isExpression(p.value)) {
         members.push(
-          t19.tsPropertySignature(t19.identifier(key), t19.tsTypeAnnotation(expressionToTSType(p.value)))
+          t16.tsPropertySignature(t16.identifier(key), t16.tsTypeAnnotation(expressionToTSType(p.value)))
         );
       } else {
         members.push(
-          t19.tsPropertySignature(t19.identifier(key), t19.tsTypeAnnotation(t19.tsAnyKeyword()))
+          t16.tsPropertySignature(t16.identifier(key), t16.tsTypeAnnotation(t16.tsAnyKeyword()))
         );
       }
     }
-    return t19.tsTypeLiteral(members);
+    return t16.tsTypeLiteral(members);
   }
-  if (t19.isArrowFunctionExpression(exp) || t19.isFunctionExpression(exp)) {
+  if (t16.isArrowFunctionExpression(exp) || t16.isFunctionExpression(exp)) {
     const params = exp.params.map((p, i) => {
-      const id = t19.isIdentifier(p) ? t19.identifier(p.name) : t19.identifier(`arg${i}`);
-      id.typeAnnotation = t19.tsTypeAnnotation(t19.tsAnyKeyword());
+      const id = t16.isIdentifier(p) ? t16.identifier(p.name) : t16.identifier(`arg${i}`);
+      id.typeAnnotation = t16.tsTypeAnnotation(t16.tsAnyKeyword());
       return id;
     });
-    let returnType = t19.tsAnyKeyword();
-    if (t19.isBlockStatement(exp.body)) {
+    let returnType = t16.tsAnyKeyword();
+    if (t16.isBlockStatement(exp.body)) {
       for (const stmt of exp.body.body) {
-        if (t19.isReturnStatement(stmt) && stmt.argument) {
-          if (t19.isExpression(stmt.argument)) {
+        if (t16.isReturnStatement(stmt) && stmt.argument) {
+          if (t16.isExpression(stmt.argument)) {
             returnType = expressionToTSType(stmt.argument);
             break;
           }
         }
       }
-    } else if (t19.isExpression(exp.body)) {
+    } else if (t16.isExpression(exp.body)) {
       returnType = expressionToTSType(exp.body);
     }
-    return t19.tsFunctionType(null, params, t19.tsTypeAnnotation(returnType));
+    return t16.tsFunctionType(null, params, t16.tsTypeAnnotation(returnType));
   }
-  return t19.tsAnyKeyword();
+  return t16.tsAnyKeyword();
 }
 function isCalleeNamed(node, name) {
-  if (!t19.isIdentifier(node.callee)) {
+  if (!t16.isIdentifier(node.callee)) {
     return false;
   }
   return node.callee.name === name;
 }
 function isSimpleLiteral(node) {
   if (!node) return false;
-  if (t19.isStringLiteral(node) || t19.isNumericLiteral(node) || t19.isBooleanLiteral(node) || t19.isNullLiteral(node) || t19.isRegExpLiteral(node) || t19.isBigIntLiteral(node) || t19.isDecimalLiteral(node)) {
+  if (t16.isStringLiteral(node) || t16.isNumericLiteral(node) || t16.isBooleanLiteral(node) || t16.isNullLiteral(node) || t16.isRegExpLiteral(node) || t16.isBigIntLiteral(node) || t16.isDecimalLiteral(node)) {
     return true;
   }
   return false;
 }
+function forkNode(node, deep = true) {
+  const newNode = t16.cloneNode(node, deep);
+  newNode.leadingComments = node.leadingComments;
+  newNode.innerComments = node.innerComments;
+  newNode.trailingComments = null;
+  cleanNodeLoc(node);
+  cleanNodeComments(node);
+  return newNode;
+}
+function cleanNodeLoc(node) {
+  node.start = null;
+  node.end = null;
+  node.loc = null;
+}
+function cleanNodeComments(node) {
+  node.leadingComments = null;
+  node.innerComments = null;
+  node.trailingComments = null;
+}
+
+// src/core/transform/sfc/script/syntax-processor/postprocess/resolve-ast-chunks/resolve-global-type-chunk.ts
+function resolveGlobalTypeChunks(path9, ir) {
+  if (!path9.parentPath?.isProgram()) {
+    return;
+  }
+  const forked = forkNode(path9.node);
+  ir.tsTypes.push(forked);
+  path9.remove();
+}
+
+// src/core/transform/sfc/script/syntax-processor/postprocess/resolve-ast-chunks/resolve-module-chunk.ts
+import * as t17 from "@babel/types";
+function resolveModuleChunks(path9, ir) {
+  const forked = forkNode(path9.node);
+  if (t17.isImportDeclaration(forked)) {
+    ir.imports.push(forked);
+  } else if (t17.isExportDeclaration(forked)) {
+    ir.exports.push(forked);
+  }
+  path9.remove();
+}
 
 // src/core/transform/sfc/script/shared/metadata-utils.ts
 var META_KEY = "__vureact_metadata";
@@ -2389,47 +2110,293 @@ function setScriptNodeMeta(node, opts) {
   node[META_KEY] = opts;
 }
 
-// src/core/transform/sfc/script/syntax-processor/postprocess/resolve-static-hoisting.ts
-function resolveStaticHoisting(ctx) {
+// src/core/transform/sfc/script/syntax-processor/postprocess/resolve-ast-chunks/resolve-static-const-chunk.ts
+function resolveStaticConstChunks(path9, ir) {
+  const { node, parentPath } = path9;
+  const parent = parentPath.node;
+  if (!isVariableDeclTopLevel(path9) || !parentPath.isVariableDeclaration() || parent.kind !== "const" || !isSimpleLiteral(node.init) || getScriptNodeMeta(node)) {
+    return;
+  }
+  const forked = forkNode(parent);
+  ir.statement.global.push(forked);
+  parentPath.remove();
+}
+
+// src/core/transform/sfc/script/syntax-processor/postprocess/resolve-ast-chunks/index.ts
+function resolveASTChunks(ctx, ast) {
   const scriptIR = getScriptIR(ctx);
   if (ctx.inputType !== "sfc") {
     return {};
   }
+  scriptIR.statement.local = ast;
   return {
+    // 提取 import/export
     "ImportDeclaration|ExportDeclaration"(path9) {
-      if (t20.isImportDeclaration(path9.node)) {
-        scriptIR.imports.push(path9.node);
-      } else if (t20.isExportDeclaration(path9.node)) {
-        scriptIR.exports.push(path9.node);
-      }
-      path9.remove();
+      resolveModuleChunks(path9, scriptIR);
     },
+    // 提取全局类型声明
     "TSInterfaceDeclaration|TSTypeAliasDeclaration|TSEnumDeclaration|TSModuleDeclaration|TSModuleDeclaration"(path9) {
-      if (t20.isProgram(path9.parent)) {
-        scriptIR.tsTypes.push(path9.node);
-        path9.remove();
-      }
+      resolveGlobalTypeChunks(path9, scriptIR);
     },
+    // 提升顶层常量声明
     VariableDeclarator(path9) {
+      resolveStaticConstChunks(path9, scriptIR);
+    }
+  };
+}
+
+// src/core/transform/sfc/script/syntax-processor/postprocess/resolve-runtime-imports/index.ts
+import * as t18 from "@babel/types";
+
+// src/core/transform/shared.ts
+function recordImport(ctx, pkg, name, onDemand = true) {
+  const { imports } = ctx;
+  if (isTypeOnlyImport(name)) {
+    name = `type ${name}`;
+  }
+  if (imports.has(pkg)) {
+    const list = imports.get(pkg);
+    const foundItem = list.find((item) => item.name === name);
+    if (!foundItem) {
+      list.push({ name, onDemand });
+    }
+    return;
+  }
+  imports.set(pkg, [{ name, onDemand }]);
+}
+function isTypeOnlyImport(name) {
+  const arr = [REACT_API_MAP.ReactNode];
+  return arr.includes(name);
+}
+
+// src/core/transform/sfc/script/shared/replace-vue-suffix.ts
+function replaceVueSuffix(node) {
+  if (!node.value.endsWith(".vue")) return;
+  const replaced = node.value.replace(/.vue$/, "");
+  node.value = replaced;
+  node.extra = {
+    rawValue: replaced,
+    // fix: 当 minified: true 的情况下，输出内容丢失引号
+    raw: `'${replaced}'`
+  };
+}
+
+// src/core/transform/sfc/script/syntax-processor/postprocess/resolve-runtime-imports/import-strategies.ts
+var VueRouterStrategy = class {
+  matches(moduleName) {
+    return moduleName === "vue-router" || moduleName.startsWith("vue-router/");
+  }
+  process() {
+    return {
+      shouldReplaceSource: true,
+      newSource: PACKAGE_NAME.router,
+      shouldRemove: false,
+      shouldInjectRuntimeImports: false
+    };
+  }
+};
+var VueEcosystemStrategy = class {
+  matches(moduleName) {
+    if (moduleName.startsWith(".") || moduleName.startsWith("/") || moduleName.startsWith("file:")) {
+      return false;
+    }
+    if (moduleName === "vue-router" || moduleName.startsWith("vue-router/")) {
+      return false;
+    }
+    if (moduleName.startsWith("@vue/")) {
+      return true;
+    }
+    for (const pkg of VUE_PACKAGES) {
+      if (moduleName === pkg || moduleName.startsWith(`${pkg}/`)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  process() {
+    return {
+      shouldReplaceSource: false,
+      shouldRemove: true,
+      shouldInjectRuntimeImports: true
+    };
+  }
+};
+var StyleFileStrategy = class {
+  regExp = /\.(less|sass|scss)$/i;
+  matches(moduleName) {
+    return this.regExp.test(moduleName);
+  }
+  process(path9, ctx) {
+    if (!ctx.preprocessStyles) {
+      return {};
+    }
+    const importSource = path9.node.source.value;
+    if (typeof importSource !== "string") {
+      return {};
+    }
+    return {
+      shouldReplaceSource: true,
+      newSource: importSource.replace(this.regExp, ".css"),
+      shouldRemove: false,
+      shouldInjectRuntimeImports: false
+    };
+  }
+};
+
+// src/core/transform/sfc/script/syntax-processor/postprocess/resolve-runtime-imports/import-strategy-manager.ts
+var ImportStrategyManager = class {
+  strategies = [];
+  constructor() {
+    this.strategies.push(new VueRouterStrategy());
+    this.strategies.push(new VueEcosystemStrategy());
+    this.strategies.push(new StyleFileStrategy());
+  }
+  /** 添加自定义策略 */
+  addStrategy(strategy) {
+    this.strategies.push(strategy);
+  }
+  /** 查找匹配的策略 */
+  findStrategy(moduleName) {
+    for (const strategy of this.strategies) {
+      if (strategy.matches(moduleName)) {
+        return strategy;
+      }
+    }
+    return null;
+  }
+};
+
+// src/core/transform/sfc/script/syntax-processor/postprocess/resolve-runtime-imports/index.ts
+function resolveRuntimeImports(ctx) {
+  if (ctx.inputType === "sfc") {
+    recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.memo);
+  }
+  const strategyManager = new ImportStrategyManager();
+  const processedModules = /* @__PURE__ */ new Set();
+  let hasImports = false;
+  return {
+    ImportDeclaration(path9) {
       const { node } = path9;
-      if (!isVariableDeclTopLevel(path9) || !isSimpleLiteral(node.init) || getScriptNodeMeta(node)) {
+      const originalModuleName = node.source.value.toLowerCase();
+      const strategy = strategyManager.findStrategy(originalModuleName);
+      let strategyResult = null;
+      if (strategy) {
+        strategyResult = strategy.process(path9, ctx, originalModuleName);
+        if (strategyResult.shouldReplaceSource && strategyResult.newSource) {
+          node.source.value = strategyResult.newSource;
+        }
+        if (strategyResult.shouldRemove && !path9.removed) {
+          path9.remove();
+          return;
+        }
+      }
+      replaceVueSuffix(node.source);
+      const finalModuleName = node.source.value.toLowerCase();
+      if (processedModules.has(finalModuleName) && !path9.removed) {
+        path9.remove();
         return;
       }
-      const declarationPath = path9.findParent((p) => p.isVariableDeclaration());
-      if (!declarationPath) return;
-      scriptIR.statement.global.push(declarationPath.node);
-      declarationPath.remove();
+      processedModules.add(finalModuleName);
+      mergeImports(node, ctx, finalModuleName);
+      if (!hasImports) {
+        const importNodes = createImportNodes(ctx);
+        if (importNodes.length) {
+          if (strategyResult?.shouldInjectRuntimeImports) {
+            path9.insertAfter(importNodes);
+          } else if (finalModuleName === PACKAGE_NAME.react) {
+            path9.insertAfter(importNodes);
+          } else {
+            forkLeadingComments(importNodes[0], node);
+            path9.insertBefore(importNodes);
+          }
+        }
+        hasImports = true;
+      }
+    },
+    // 兜底：无 ImportDeclaration 的文件也要能注入必需依赖。
+    Program: {
+      exit(path9) {
+        if (hasImports) return;
+        hasImports = true;
+        const { node } = path9;
+        const importNodes = createImportNodes(ctx);
+        if (!importNodes.length) return;
+        forkLeadingComments(importNodes[0], node);
+        path9.unshiftContainer("body", importNodes);
+      }
     }
   };
 }
-function collectLocalStatements(ctx, ast) {
+function mergeImports(currentNode, ctx, moduleName) {
+  const ctxImportItems = ctx.imports.get(moduleName);
+  if (!ctxImportItems?.length) {
+    return;
+  }
+  const currentImports = /* @__PURE__ */ new Set();
+  for (const spec of currentNode.specifiers) {
+    if (t18.isImportSpecifier(spec) && t18.isIdentifier(spec.imported)) {
+      currentImports.add(spec.imported.name);
+    }
+    if (t18.isImportDefaultSpecifier(spec) && t18.isIdentifier(spec.local)) {
+      currentImports.add(spec.local.name);
+    }
+  }
+  for (const item of ctxImportItems) {
+    if (currentImports.has(item.name)) {
+      continue;
+    }
+    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);
+}
+function createImportNodes(ctx) {
+  const result = [];
+  const importDeclarations = Array.from(ctx.imports).map(([moduleName, items]) => {
+    const specifiers = items.map((item) => {
+      const local = t18.identifier(item.name);
+      return item.onDemand ? t18.importSpecifier(local, local) : t18.importDefaultSpecifier(local);
+    });
+    return t18.importDeclaration(specifiers, t18.stringLiteral(moduleName));
+  });
+  for (const decl of importDeclarations) {
+    const name = decl.source.value;
+    if (name === PACKAGE_NAME.react) {
+      result.unshift(decl);
+    } else {
+      result.push(decl);
+    }
+  }
+  return result;
+}
+function forkLeadingComments(target, source) {
+  const { leadingComments } = source;
+  if (!leadingComments?.length) {
+    return;
+  }
+  const newComments = [...leadingComments];
+  source.leadingComments = null;
+  target.leadingComments = newComments;
+}
+
+// src/core/transform/sfc/script/syntax-processor/postprocess/resolve-sfc-css-import.ts
+import * as t19 from "@babel/types";
+function resolveSfcCssImport(ctx) {
   if (ctx.inputType !== "sfc") return;
   const scriptIR = getScriptIR(ctx);
-  scriptIR.statement.local = ast;
+  const { filePath, moduleName } = ctx.styleData;
+  if (!filePath) return;
+  const styleFilename = normalizePath(filePath).split("/").pop();
+  const importDecl = t19.importDeclaration(
+    !moduleName ? [] : [t19.importDefaultSpecifier(t19.identifier(moduleName))],
+    t19.stringLiteral(`./${styleFilename}`)
+  );
+  scriptIR.imports.push(importDecl);
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-async-component.ts
-import * as t21 from "@babel/types";
+import * as t20 from "@babel/types";
 function resolveDefineAsyncComponent(ctx) {
   return {
     CallExpression(path9) {
@@ -2445,11 +2412,11 @@ function resolveDefineAsyncComponent(ctx) {
   };
 }
 function checkIsUnsupported(ctx, arg) {
-  if (t21.isFunction(arg)) {
+  if (t20.isFunction(arg)) {
     checkIsDynamicImport(ctx, arg);
-  } else if (t21.isObjectExpression(arg)) {
+  } else if (t20.isObjectExpression(arg)) {
     const { value } = arg.properties.find(
-      (p) => t21.isObjectProperty(p) && t21.isIdentifier(p.key) && p.key.name === "loader"
+      (p) => t20.isObjectProperty(p) && t20.isIdentifier(p.key) && p.key.name === "loader"
     );
     checkIsDynamicImport(ctx, value);
     if (arg.properties.length > 1) {
@@ -2460,7 +2427,7 @@ function checkIsUnsupported(ctx, arg) {
 function checkIsDynamicImport(ctx, node) {
   const { scriptData, filename } = ctx;
   const warnIsNotImport = (target) => {
-    if (!target || !t21.isImport(target)) {
+    if (!target || !t20.isImport(target)) {
       logger.error(
         `Only ES module dynamic imports are supported. You must use and return import('...').`,
         {
@@ -2471,21 +2438,21 @@ function checkIsDynamicImport(ctx, node) {
       );
     }
   };
-  if (t21.isFunction(node)) {
+  if (t20.isFunction(node)) {
     checkIsDynamicImport(ctx, node.body);
     return;
   }
-  if (t21.isBlockStatement(node)) {
+  if (t20.isBlockStatement(node)) {
     const [returnSmt] = node.body;
-    if (t21.isReturnStatement(returnSmt)) {
+    if (t20.isReturnStatement(returnSmt)) {
       warnIsNotImport(returnSmt.argument);
     }
     return;
   }
-  if (t21.isCallExpression(node)) {
+  if (t20.isCallExpression(node)) {
     warnIsNotImport(node.callee);
-    if (t21.isStringLiteral(node.arguments[0])) {
-      replaceVueSuffix(ctx, node.arguments[0]);
+    if (t20.isStringLiteral(node.arguments[0])) {
+      replaceVueSuffix(node.arguments[0]);
     }
     return;
   }
@@ -2533,24 +2500,24 @@ function pushToGlobalScope(path9, ctx) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-expose.ts
-import * as t23 from "@babel/types";
+import * as t22 from "@babel/types";
 
 // src/core/transform/sfc/script/shared/hook-creator.ts
-import * as t22 from "@babel/types";
+import * as t21 from "@babel/types";
 function createUseCallback(body, deps) {
-  return t22.callExpression(t22.identifier(REACT_API_MAP.useCallback), [
+  return t21.callExpression(t21.identifier(REACT_API_MAP.useCallback), [
     body,
-    deps ?? t22.arrayExpression([])
+    deps ?? t21.arrayExpression([])
   ]);
 }
 function createUseMemo(body, deps) {
-  return t22.callExpression(t22.identifier(REACT_API_MAP.useMemo), [
-    t22.arrowFunctionExpression([], body),
-    deps ?? t22.arrayExpression([])
+  return t21.callExpression(t21.identifier(REACT_API_MAP.useMemo), [
+    t21.arrowFunctionExpression([], body),
+    deps ?? t21.arrayExpression([])
   ]);
 }
 function createUseImperativeHandle(refId, init) {
-  return t22.callExpression(t22.identifier(REACT_API_MAP.useImperativeHandle), [refId, init]);
+  return t21.callExpression(t21.identifier(REACT_API_MAP.useImperativeHandle), [refId, init]);
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-expose.ts
@@ -2571,16 +2538,16 @@ function resolveDefineExpose(ctx) {
       const adapter = ADAPTER_RULES.react[MACRO_API_NAMES.expose];
       recordImport(ctx, adapter.package, REACT_API_MAP.forwardRef);
       recordImport(ctx, adapter.package, adapter.target);
-      if (!t23.isObjectExpression(expose) && !t23.isFunction(expose)) {
+      if (!t22.isObjectExpression(expose) && !t22.isFunction(expose)) {
         logger.warn("Non-deterministic object literal may cause unknown risks.", {
           file: filename,
           loc: expose.loc,
           source: scriptData.source
         });
       }
-      const init = !t23.isFunction(expose) ? t23.arrowFunctionExpression([], expose) : expose;
+      const init = !t22.isFunction(expose) ? t22.arrowFunctionExpression([], expose) : expose;
       const { forwardRef } = scriptData;
-      const newNode = createUseImperativeHandle(t23.identifier(forwardRef.refField), init);
+      const newNode = createUseImperativeHandle(t22.identifier(forwardRef.refField), init);
       forwardRef.enabled = true;
       path9.replaceWith(newNode);
     }
@@ -2588,7 +2555,7 @@ function resolveDefineExpose(ctx) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-options.ts
-import * as t24 from "@babel/types";
+import * as t23 from "@babel/types";
 function resolveDefineOptions(ctx) {
   return {
     CallExpression(path9) {
@@ -2607,7 +2574,7 @@ function resolveDefineOptions(ctx) {
         path9.remove();
         return;
       }
-      if (!t24.isObjectExpression(options)) {
+      if (!t23.isObjectExpression(options)) {
         logger.warn("Argument for defineOptions must be an object expression.", {
           source: scriptData.source,
           file: filename,
@@ -2615,7 +2582,7 @@ function resolveDefineOptions(ctx) {
         });
       } else {
         for (const prop of options.properties) {
-          if (!t24.isObjectProperty(prop) || !t24.isIdentifier(prop.key)) {
+          if (!t23.isObjectProperty(prop) || !t23.isIdentifier(prop.key)) {
             continue;
           }
           extractName(prop, ctx);
@@ -2629,7 +2596,7 @@ function extractName(prop, ctx) {
   if (ctx.compName) return;
   const { filename, scriptData } = ctx;
   if (!prop.computed && prop.key.name === "name") {
-    if (t24.isStringLiteral(prop.value)) {
+    if (t23.isStringLiteral(prop.value)) {
       ctx.compName = prop.value.value;
       return;
     }
@@ -2642,7 +2609,7 @@ function extractName(prop, ctx) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-emit-calls.ts
-import * as t25 from "@babel/types";
+import * as t24 from "@babel/types";
 function resolveEmitCalls(ctx) {
   const formatEmitEventName = (raw) => {
     if (raw.startsWith("update:")) {
@@ -2656,7 +2623,7 @@ function resolveEmitCalls(ctx) {
     CallExpression(path9) {
       const { node } = path9;
       const { filename, templateData, scriptData } = ctx;
-      if (!t25.isIdentifier(node.callee)) return;
+      if (!t24.isIdentifier(node.callee)) return;
       const { name } = node.callee;
       const checkIfFromDefineEmits = () => {
         let result = false;
@@ -2668,7 +2635,7 @@ function resolveEmitCalls(ctx) {
           const binding = path9.scope.getBinding(name);
           if (binding) {
             const parent = binding.path.node;
-            if (t25.isVariableDeclarator(parent) && t25.isCallExpression(parent.init) && t25.isIdentifier(parent.init.callee)) {
+            if (t24.isVariableDeclarator(parent) && t24.isCallExpression(parent.init) && t24.isIdentifier(parent.init.callee)) {
               result = parent.init.callee.name === MACRO_API_NAMES.emits;
             }
           }
@@ -2677,7 +2644,7 @@ function resolveEmitCalls(ctx) {
       };
       if (!checkIfFromDefineEmits()) return;
       const [callee, ...args] = node.arguments;
-      const eventName = t25.isStringLiteral(callee) ? formatEmitEventName(callee.value) : void 0;
+      const eventName = t24.isStringLiteral(callee) ? formatEmitEventName(callee.value) : void 0;
       if (!eventName) {
         logger.warn(`Expected String type but got ${callee?.type}, expression will be removed`, {
           file: filename,
@@ -2687,10 +2654,10 @@ function resolveEmitCalls(ctx) {
         path9.remove();
         return;
       }
-      const propCall = t25.optionalCallExpression(
-        t25.optionalMemberExpression(
-          t25.identifier(ctx.propField),
-          t25.identifier(eventName),
+      const propCall = t24.optionalCallExpression(
+        t24.optionalMemberExpression(
+          t24.identifier(ctx.propField),
+          t24.identifier(eventName),
           false,
           true
         ),
@@ -2703,30 +2670,30 @@ function resolveEmitCalls(ctx) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/index.ts
-import * as t30 from "@babel/types";
+import * as t29 from "@babel/types";
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-emits.ts
-import * as t27 from "@babel/types";
+import * as t26 from "@babel/types";
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/shared.ts
-import * as t26 from "@babel/types";
+import * as t25 from "@babel/types";
 function cloneCallableParams(params) {
   const cloneCallableParam = (param, index) => {
-    if (t26.isRestElement(param)) {
+    if (t25.isRestElement(param)) {
       const arg = param.argument;
-      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()));
+      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()));
       return rest;
     }
-    if (t26.isIdentifier(param)) {
-      const id = t26.identifier(param.name || `arg${index}`);
+    if (t25.isIdentifier(param)) {
+      const id = t25.identifier(param.name || `arg${index}`);
       id.optional = param.optional;
-      id.typeAnnotation = param.typeAnnotation || t26.tsTypeAnnotation(t26.tsAnyKeyword());
+      id.typeAnnotation = param.typeAnnotation || t25.tsTypeAnnotation(t25.tsAnyKeyword());
       return id;
     }
-    const fallback = t26.identifier(`arg${index}`);
-    fallback.typeAnnotation = t26.tsTypeAnnotation(t26.tsAnyKeyword());
+    const fallback = t25.identifier(`arg${index}`);
+    fallback.typeAnnotation = t25.tsTypeAnnotation(t25.tsAnyKeyword());
     return fallback;
   };
   return params.map(cloneCallableParam);
@@ -2736,18 +2703,18 @@ function cloneCallableParams(params) {
 function resolveEmitsTopLevelTypes(ctx) {
   return {
     "TSInterfaceDeclaration|TSTypeAliasDeclaration"(path9) {
-      if (!t27.isProgram(path9.parent)) return;
+      if (!t26.isProgram(path9.parent)) return;
       const { node } = path9;
-      if (t27.isTSInterfaceDeclaration(node)) {
-        const typeLiteral = t27.tsTypeLiteral(node.body.body);
+      if (t26.isTSInterfaceDeclaration(node)) {
+        const typeLiteral = t26.tsTypeLiteral(node.body.body);
         if (!hasEmitsSignatureInType(typeLiteral)) return;
         const resolved = resolveTopLevelEmitType(typeLiteral);
-        if (resolved && t27.isTSTypeLiteral(resolved)) {
+        if (resolved && t26.isTSTypeLiteral(resolved)) {
           node.body.body = resolved.members;
         }
         return;
       }
-      if (t27.isTSTypeAliasDeclaration(node)) {
+      if (t26.isTSTypeAliasDeclaration(node)) {
         if (!hasEmitsSignatureInType(node.typeAnnotation)) return;
         const resolved = resolveTopLevelEmitType(node.typeAnnotation);
         if (resolved) {
@@ -2758,47 +2725,47 @@ function resolveEmitsTopLevelTypes(ctx) {
   };
 }
 function resolveTopLevelEmitType(tsType) {
-  if (t27.isTSParenthesizedType(tsType)) {
+  if (t26.isTSParenthesizedType(tsType)) {
     return resolveTopLevelEmitType(tsType.typeAnnotation);
   }
-  if (t27.isTSTypeReference(tsType)) {
+  if (t26.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return tsType;
     }
     const params = tsType.typeParameters.params.map((param) => resolveTopLevelEmitType(param)).filter(Boolean);
-    return t27.tsTypeReference(
+    return t26.tsTypeReference(
       tsType.typeName,
-      t27.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
+      t26.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
     );
   }
-  if (t27.isTSIntersectionType(tsType)) {
+  if (t26.isTSIntersectionType(tsType)) {
     const types = tsType.types.map(resolveTopLevelEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t27.tsIntersectionType(types);
+    return t26.tsIntersectionType(types);
   }
-  if (t27.isTSUnionType(tsType)) {
+  if (t26.isTSUnionType(tsType)) {
     const types = tsType.types.map(resolveTopLevelEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t27.tsUnionType(types);
+    return t26.tsUnionType(types);
   }
-  if (t27.isTSTypeLiteral(tsType)) {
+  if (t26.isTSTypeLiteral(tsType)) {
     const members = [];
     for (const member of tsType.members) {
-      if (t27.isTSCallSignatureDeclaration(member)) {
+      if (t26.isTSCallSignatureDeclaration(member)) {
         members.push(...resolveEmitPropsFromCallSignature(member));
         continue;
       }
       members.push(member);
     }
     if (!members.length) return null;
-    return t27.tsTypeLiteral(members);
+    return t26.tsTypeLiteral(members);
   }
-  if (t27.isTSFunctionType(tsType)) {
+  if (t26.isTSFunctionType(tsType)) {
     const props = resolveEmitPropsFromCallable(tsType.parameters, tsType.typeAnnotation);
     if (!props.length) return null;
-    return t27.tsTypeLiteral(props);
+    return t26.tsTypeLiteral(props);
   }
   return tsType;
 }
@@ -2819,41 +2786,41 @@ function processInferredTypes(ctx, runtimeArg) {
     propsTSIface: { emitTypes }
   } = ctx.scriptData;
   const members = [];
-  if (t27.isArrayExpression(runtimeArg)) {
+  if (t26.isArrayExpression(runtimeArg)) {
     for (const element of runtimeArg.elements) {
-      if (!element || !t27.isStringLiteral(element)) continue;
+      if (!element || !t26.isStringLiteral(element)) continue;
       const handlerName = resolveEmitHandlerName(element.value);
       const key = buildKey(handlerName);
-      const fnType = t27.tsFunctionType(
+      const fnType = t26.tsFunctionType(
         null,
         [createRestAnyParam("args")],
-        t27.tsTypeAnnotation(t27.tsAnyKeyword())
+        t26.tsTypeAnnotation(t26.tsAnyKeyword())
       );
-      const prop = t27.tsPropertySignature(key, t27.tsTypeAnnotation(fnType));
+      const prop = t26.tsPropertySignature(key, t26.tsTypeAnnotation(fnType));
       prop.optional = true;
       members.push(prop);
     }
     if (members.length) {
-      emitTypes.push(t27.tsTypeLiteral(members));
+      emitTypes.push(t26.tsTypeLiteral(members));
     }
     return;
   }
-  if (t27.isObjectExpression(runtimeArg)) {
+  if (t26.isObjectExpression(runtimeArg)) {
     for (const prop of runtimeArg.properties) {
-      if (!t27.isObjectProperty(prop)) continue;
-      if (t27.isSpreadElement(prop)) continue;
+      if (!t26.isObjectProperty(prop)) continue;
+      if (t26.isSpreadElement(prop)) continue;
       const rawName = resolvePropName(prop.key);
       if (!rawName) continue;
       const handlerName = resolveEmitHandlerName(rawName);
       const key = buildKey(handlerName);
-      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));
+      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));
       propSig.optional = true;
       members.push(propSig);
     }
     if (members.length) {
-      emitTypes.push(t27.tsTypeLiteral(members));
+      emitTypes.push(t26.tsTypeLiteral(members));
     }
   }
 }
@@ -2874,129 +2841,129 @@ function resolveEmitHandlerName(rawName) {
   return `on${name}`;
 }
 function resolvePropName(key) {
-  if (t27.isIdentifier(key)) return key.name;
-  if (t27.isStringLiteral(key)) return key.value;
-  if (t27.isNumericLiteral(key)) return String(key.value);
+  if (t26.isIdentifier(key)) return key.name;
+  if (t26.isStringLiteral(key)) return key.value;
+  if (t26.isNumericLiteral(key)) return String(key.value);
   return null;
 }
 function buildKey(name) {
-  return t27.isValidIdentifier(name) ? t27.identifier(name) : t27.stringLiteral(name);
+  return t26.isValidIdentifier(name) ? t26.identifier(name) : t26.stringLiteral(name);
 }
 function createRestAnyParam(name) {
-  const id = t27.identifier(name);
-  const rest = t27.restElement(id);
-  rest.typeAnnotation = t27.tsTypeAnnotation(t27.tsArrayType(t27.tsAnyKeyword()));
+  const id = t26.identifier(name);
+  const rest = t26.restElement(id);
+  rest.typeAnnotation = t26.tsTypeAnnotation(t26.tsArrayType(t26.tsAnyKeyword()));
   return rest;
 }
 function resolveRuntimeTupleParams(value) {
   const params = [];
   value.elements.forEach((element, index) => {
     if (!element) return;
-    if (t27.isSpreadElement(element)) {
+    if (t26.isSpreadElement(element)) {
       params.push(createRestAnyParam(`args${index}`));
       return;
     }
-    if (t27.isIdentifier(element)) {
-      const id = t27.identifier(element.name);
-      id.typeAnnotation = element.typeAnnotation || t27.tsTypeAnnotation(t27.tsAnyKeyword());
+    if (t26.isIdentifier(element)) {
+      const id = t26.identifier(element.name);
+      id.typeAnnotation = element.typeAnnotation || t26.tsTypeAnnotation(t26.tsAnyKeyword());
       params.push(id);
       return;
     }
-    if (t27.isTSAsExpression(element)) {
-      const id = t27.identifier(`arg${index}`);
-      id.typeAnnotation = t27.tsTypeAnnotation(element.typeAnnotation);
+    if (t26.isTSAsExpression(element)) {
+      const id = t26.identifier(`arg${index}`);
+      id.typeAnnotation = t26.tsTypeAnnotation(element.typeAnnotation);
       params.push(id);
       return;
     }
-    const fallback = t27.identifier(`arg${index}`);
-    fallback.typeAnnotation = t27.tsTypeAnnotation(t27.tsAnyKeyword());
+    const fallback = t26.identifier(`arg${index}`);
+    fallback.typeAnnotation = t26.tsTypeAnnotation(t26.tsAnyKeyword());
     params.push(fallback);
   });
   return params;
 }
 function resolveExplicitEmitType(tsType) {
-  if (t27.isTSParenthesizedType(tsType)) {
+  if (t26.isTSParenthesizedType(tsType)) {
     return resolveExplicitEmitType(tsType.typeAnnotation);
   }
-  if (t27.isTSTypeReference(tsType)) {
+  if (t26.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return tsType;
     }
     const params = tsType.typeParameters.params.map((param) => resolveExplicitEmitType(param)).filter(Boolean);
-    return t27.tsTypeReference(
+    return t26.tsTypeReference(
       tsType.typeName,
-      t27.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
+      t26.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
     );
   }
-  if (t27.isTSIntersectionType(tsType)) {
+  if (t26.isTSIntersectionType(tsType)) {
     const types = tsType.types.map(resolveExplicitEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t27.tsIntersectionType(types);
+    return t26.tsIntersectionType(types);
   }
-  if (t27.isTSUnionType(tsType)) {
+  if (t26.isTSUnionType(tsType)) {
     const types = tsType.types.map(resolveExplicitEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t27.tsUnionType(types);
+    return t26.tsUnionType(types);
   }
-  if (t27.isTSTypeLiteral(tsType)) {
+  if (t26.isTSTypeLiteral(tsType)) {
     const members = [];
     for (const member of tsType.members) {
-      if (t27.isTSPropertySignature(member)) {
+      if (t26.isTSPropertySignature(member)) {
         const prop = resolveEmitPropFromPropertySignature(member);
         if (prop) members.push(prop);
         continue;
       }
-      if (t27.isTSCallSignatureDeclaration(member)) {
+      if (t26.isTSCallSignatureDeclaration(member)) {
         members.push(...resolveEmitPropsFromCallSignature(member));
         continue;
       }
     }
     if (!members.length) return null;
-    return t27.tsTypeLiteral(members);
+    return t26.tsTypeLiteral(members);
   }
-  if (t27.isTSFunctionType(tsType)) {
+  if (t26.isTSFunctionType(tsType)) {
     const props = resolveEmitPropsFromCallable(tsType.parameters, tsType.typeAnnotation);
     if (!props.length) return null;
-    return t27.tsTypeLiteral(props);
+    return t26.tsTypeLiteral(props);
   }
   return tsType;
 }
 function hasEmitsSignatureInType(tsType) {
-  if (t27.isTSParenthesizedType(tsType)) {
+  if (t26.isTSParenthesizedType(tsType)) {
     return hasEmitsSignatureInType(tsType.typeAnnotation);
   }
-  if (t27.isTSTypeReference(tsType)) {
+  if (t26.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return false;
     }
     return tsType.typeParameters.params.some(hasEmitsSignatureInType);
   }
-  if (t27.isTSIntersectionType(tsType) || t27.isTSUnionType(tsType)) {
+  if (t26.isTSIntersectionType(tsType) || t26.isTSUnionType(tsType)) {
     return tsType.types.some(hasEmitsSignatureInType);
   }
-  if (t27.isTSTypeLiteral(tsType)) {
+  if (t26.isTSTypeLiteral(tsType)) {
     return tsType.members.some(hasEmitsSignatureInMember);
   }
-  if (t27.isTSFunctionType(tsType)) {
+  if (t26.isTSFunctionType(tsType)) {
     return isEmitsCallable(tsType.parameters);
   }
   return false;
 }
 function hasEmitsSignatureInMember(member) {
-  if (t27.isTSCallSignatureDeclaration(member)) {
+  if (t26.isTSCallSignatureDeclaration(member)) {
     return isEmitsCallable(member.parameters);
   }
   return false;
 }
 function isEmitsCallable(parameters) {
   const [eventParam] = parameters;
-  if (!eventParam || !t27.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
+  if (!eventParam || !t26.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
     return false;
   }
   const { typeAnnotation } = eventParam;
-  if (t27.isNoop(typeAnnotation)) return false;
+  if (t26.isNoop(typeAnnotation)) return false;
   return resolveEventNames(typeAnnotation.typeAnnotation).length > 0;
 }
 function resolveEmitPropFromPropertySignature(member) {
@@ -3006,19 +2973,19 @@ function resolveEmitPropFromPropertySignature(member) {
   const key = buildKey(handlerName);
   const typeAnnotation = member.typeAnnotation?.typeAnnotation;
   let params = [];
-  let returnType = t27.tsAnyKeyword();
-  if (typeAnnotation && t27.isTSFunctionType(typeAnnotation)) {
+  let returnType = t26.tsAnyKeyword();
+  if (typeAnnotation && t26.isTSFunctionType(typeAnnotation)) {
     params = cloneCallableParams(typeAnnotation.parameters);
     returnType = typeAnnotation.typeAnnotation?.typeAnnotation ?? returnType;
-  } else if (typeAnnotation && t27.isTSTupleType(typeAnnotation)) {
+  } else if (typeAnnotation && t26.isTSTupleType(typeAnnotation)) {
     params = resolveTupleTypeParams(typeAnnotation);
   } else if (typeAnnotation) {
-    const id = t27.identifier("value");
-    id.typeAnnotation = t27.tsTypeAnnotation(typeAnnotation);
+    const id = t26.identifier("value");
+    id.typeAnnotation = t26.tsTypeAnnotation(typeAnnotation);
     params = [id];
   }
-  const fnType = t27.tsFunctionType(null, params, t27.tsTypeAnnotation(returnType));
-  const prop = t27.tsPropertySignature(key, t27.tsTypeAnnotation(fnType));
+  const fnType = t26.tsFunctionType(null, params, t26.tsTypeAnnotation(returnType));
+  const prop = t26.tsPropertySignature(key, t26.tsTypeAnnotation(fnType));
   prop.optional = !!member.optional;
   return prop;
 }
@@ -3027,32 +2994,32 @@ function resolveEmitPropsFromCallSignature(member) {
 }
 function resolveEmitPropsFromCallable(parameters, typeAnnotation) {
   const [eventParam, ...restParams] = parameters;
-  if (!eventParam || !t27.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
+  if (!eventParam || !t26.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
     return [];
   }
   const { typeAnnotation: paramTypeAnnotation } = eventParam;
-  if (t27.isNoop(paramTypeAnnotation)) return [];
+  if (t26.isNoop(paramTypeAnnotation)) return [];
   const eventNames = resolveEventNames(paramTypeAnnotation.typeAnnotation);
   if (!eventNames.length) return [];
-  const returnType = typeAnnotation?.typeAnnotation ?? t27.tsAnyKeyword();
+  const returnType = typeAnnotation?.typeAnnotation ?? t26.tsAnyKeyword();
   return eventNames.map((eventName) => {
     const handlerName = resolveEmitHandlerName(eventName);
     const key = buildKey(handlerName);
     const params = cloneCallableParams(restParams);
-    const fnType = t27.tsFunctionType(null, params, t27.tsTypeAnnotation(returnType));
-    const prop = t27.tsPropertySignature(key, t27.tsTypeAnnotation(fnType));
+    const fnType = t26.tsFunctionType(null, params, t26.tsTypeAnnotation(returnType));
+    const prop = t26.tsPropertySignature(key, t26.tsTypeAnnotation(fnType));
     prop.optional = true;
     return prop;
   });
 }
 function resolveEventNames(type) {
-  if (t27.isTSLiteralType(type) && t27.isStringLiteral(type.literal)) {
+  if (t26.isTSLiteralType(type) && t26.isStringLiteral(type.literal)) {
     return [type.literal.value];
   }
-  if (t27.isTSUnionType(type)) {
+  if (t26.isTSUnionType(type)) {
     return type.types.flatMap(resolveEventNames);
   }
-  if (t27.isTSParenthesizedType(type)) {
+  if (t26.isTSParenthesizedType(type)) {
     return resolveEventNames(type.typeAnnotation);
   }
   return [];
@@ -3065,44 +3032,44 @@ function resolveTupleTypeParams(tuple) {
   return params;
 }
 function resolveTupleElementParam(element, index) {
-  const isNamedTuple = typeof t27.isTSNamedTupleMember === "function" && t27.isTSNamedTupleMember(element);
+  const isNamedTuple = typeof t26.isTSNamedTupleMember === "function" && t26.isTSNamedTupleMember(element);
   if (isNamedTuple) {
     const tupleMember = element;
     const name = tupleMember.label?.name || `arg${index}`;
     let innerType = tupleMember.elementType;
     let optional = tupleMember.optional;
-    if (t27.isTSOptionalType(innerType)) {
+    if (t26.isTSOptionalType(innerType)) {
       optional = true;
       innerType = innerType.typeAnnotation;
     }
-    if (t27.isTSRestType(innerType)) {
-      const rest = t27.restElement(t27.identifier(name));
-      rest.typeAnnotation = t27.tsTypeAnnotation(innerType.typeAnnotation);
+    if (t26.isTSRestType(innerType)) {
+      const rest = t26.restElement(t26.identifier(name));
+      rest.typeAnnotation = t26.tsTypeAnnotation(innerType.typeAnnotation);
       return rest;
     }
-    const id2 = t27.identifier(name);
+    const id2 = t26.identifier(name);
     id2.optional = optional;
-    id2.typeAnnotation = t27.tsTypeAnnotation(innerType);
+    id2.typeAnnotation = t26.tsTypeAnnotation(innerType);
     return id2;
   }
-  if (t27.isTSRestType(element)) {
-    const rest = t27.restElement(t27.identifier(`args${index}`));
-    rest.typeAnnotation = t27.tsTypeAnnotation(element.typeAnnotation);
+  if (t26.isTSRestType(element)) {
+    const rest = t26.restElement(t26.identifier(`args${index}`));
+    rest.typeAnnotation = t26.tsTypeAnnotation(element.typeAnnotation);
     return rest;
   }
-  if (t27.isTSOptionalType(element)) {
-    const id2 = t27.identifier(`arg${index}`);
+  if (t26.isTSOptionalType(element)) {
+    const id2 = t26.identifier(`arg${index}`);
     id2.optional = true;
-    id2.typeAnnotation = t27.tsTypeAnnotation(element.typeAnnotation);
+    id2.typeAnnotation = t26.tsTypeAnnotation(element.typeAnnotation);
     return id2;
   }
-  const id = t27.identifier(`arg${index}`);
-  id.typeAnnotation = t27.tsTypeAnnotation(element);
+  const id = t26.identifier(`arg${index}`);
+  id.typeAnnotation = t26.tsTypeAnnotation(element);
   return id;
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-props.ts
-import * as t28 from "@babel/types";
+import * as t27 from "@babel/types";
 function resolveDefinePropsIface(path9, ctx) {
   const { node } = path9;
   const [runtimeArg] = node.arguments;
@@ -3122,38 +3089,38 @@ function processInferredTypes2(ctx, runtimeArg) {
   } = scriptData;
   if (!runtimeArg) return;
   const members = [];
-  if (t28.isArrayExpression(runtimeArg)) {
+  if (t27.isArrayExpression(runtimeArg)) {
     for (const element of runtimeArg.elements) {
-      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()));
+      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()));
       prop.optional = true;
       members.push(prop);
     }
     if (members.length) {
-      propsTypes.push(t28.tsTypeLiteral(members));
+      propsTypes.push(t27.tsTypeLiteral(members));
     }
     return;
   }
-  if (t28.isObjectExpression(runtimeArg)) {
+  if (t27.isObjectExpression(runtimeArg)) {
     for (const prop of runtimeArg.properties) {
-      if (!t28.isObjectProperty(prop)) continue;
-      if (t28.isSpreadElement(prop)) continue;
+      if (!t27.isObjectProperty(prop)) continue;
+      if (t27.isSpreadElement(prop)) continue;
       const key = prop.key;
       let propName = null;
-      if (t28.isIdentifier(key)) propName = key.name;
-      if (t28.isStringLiteral(key)) propName = key.value;
-      if (t28.isNumericLiteral(key)) propName = String(key.value);
+      if (t27.isIdentifier(key)) propName = key.name;
+      if (t27.isStringLiteral(key)) propName = key.value;
+      if (t27.isNumericLiteral(key)) propName = String(key.value);
       if (!propName) continue;
       const { type, required } = resolveRuntimePropMeta(prop.value);
-      const tsType = type ?? t28.tsAnyKeyword();
-      const tsKey = t28.isValidIdentifier(propName) ? t28.identifier(propName) : t28.stringLiteral(propName);
-      const tsProp = t28.tsPropertySignature(tsKey, t28.tsTypeAnnotation(tsType));
+      const tsType = type ?? t27.tsAnyKeyword();
+      const tsKey = t27.isValidIdentifier(propName) ? t27.identifier(propName) : t27.stringLiteral(propName);
+      const tsProp = t27.tsPropertySignature(tsKey, t27.tsTypeAnnotation(tsType));
       tsProp.optional = !required;
       members.push(tsProp);
     }
     if (members.length) {
-      propsTypes.push(t28.tsTypeLiteral(members));
+      propsTypes.push(t27.tsTypeLiteral(members));
     }
     return;
   }
@@ -3167,42 +3134,42 @@ function processInferredTypes2(ctx, runtimeArg) {
   );
 }
 function resolveRuntimePropMeta(value) {
-  if (t28.isIdentifier(value)) {
+  if (t27.isIdentifier(value)) {
     return {
       type: mapRuntimeTypeToTSType(value),
       required: false
     };
   }
-  if (t28.isArrayExpression(value)) {
+  if (t27.isArrayExpression(value)) {
     return {
       type: resolveRuntimeUnionType(value),
       required: false
     };
   }
-  if (!t28.isObjectExpression(value)) {
+  if (!t27.isObjectExpression(value)) {
     return { required: false };
   }
   let type;
   let required = false;
   for (const prop of value.properties) {
-    if (!t28.isObjectProperty(prop)) continue;
-    if (t28.isSpreadElement(prop)) continue;
+    if (!t27.isObjectProperty(prop)) continue;
+    if (t27.isSpreadElement(prop)) continue;
     const key = prop.key;
-    const propName = t28.isIdentifier(key) ? key.name : t28.isStringLiteral(key) ? key.value : null;
+    const propName = t27.isIdentifier(key) ? key.name : t27.isStringLiteral(key) ? key.value : null;
     if (!propName) continue;
     if (propName === "type") {
       const valueNode = prop.value;
-      if (t28.isArrayExpression(valueNode)) {
+      if (t27.isArrayExpression(valueNode)) {
         type = resolveRuntimeUnionType(valueNode);
         continue;
       }
-      if (t28.isIdentifier(valueNode)) {
+      if (t27.isIdentifier(valueNode)) {
         type = mapRuntimeTypeToTSType(valueNode);
         continue;
       }
     }
     if (propName === "required") {
-      if (t28.isBooleanLiteral(prop.value)) {
+      if (t27.isBooleanLiteral(prop.value)) {
         required = prop.value.value;
       }
     }
@@ -3212,39 +3179,39 @@ function resolveRuntimePropMeta(value) {
 function resolveRuntimeUnionType(value) {
   const types = [];
   for (const element of value.elements) {
-    if (!element || !t28.isIdentifier(element)) continue;
+    if (!element || !t27.isIdentifier(element)) continue;
     const resolved = mapRuntimeTypeToTSType(element);
     if (resolved) types.push(resolved);
   }
-  if (!types.length) return t28.tsAnyKeyword();
+  if (!types.length) return t27.tsAnyKeyword();
   if (types.length === 1) return types[0];
-  return t28.tsUnionType(types);
+  return t27.tsUnionType(types);
 }
 function mapRuntimeTypeToTSType(value) {
   switch (value.name) {
     case "String":
-      return t28.tsStringKeyword();
+      return t27.tsStringKeyword();
     case "Number":
-      return t28.tsNumberKeyword();
+      return t27.tsNumberKeyword();
     case "Boolean":
-      return t28.tsBooleanKeyword();
+      return t27.tsBooleanKeyword();
     case "Object":
-      return t28.tsTypeLiteral([]);
+      return t27.tsTypeLiteral([]);
     case "Array":
-      return t28.tsArrayType(t28.tsAnyKeyword());
+      return t27.tsArrayType(t27.tsAnyKeyword());
     case "Function":
-      return t28.tsFunctionType(null, [], t28.tsTypeAnnotation(t28.tsAnyKeyword()));
+      return t27.tsFunctionType(null, [], t27.tsTypeAnnotation(t27.tsAnyKeyword()));
     case "Symbol":
-      return t28.tsSymbolKeyword();
+      return t27.tsSymbolKeyword();
     case "BigInt":
-      return t28.tsBigIntKeyword();
+      return t27.tsBigIntKeyword();
     default:
-      return t28.tsAnyKeyword();
+      return t27.tsAnyKeyword();
   }
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot.ts
-import * as t29 from "@babel/types";
+import * as t28 from "@babel/types";
 var SLOT_DEFAULT_NAME = "default";
 var SLOT_CHILDREN_NAME = "children";
 var SLOT_FN_PARAM_NAME = "props";
@@ -3254,19 +3221,19 @@ function resolveSlotsTopLevelTypes(ctx) {
   }
   return {
     "TSInterfaceDeclaration|TSTypeAliasDeclaration"(path9) {
-      if (!t29.isProgram(path9.parent)) return;
+      if (!t28.isProgram(path9.parent)) return;
       const { node } = path9;
-      if (t29.isTSInterfaceDeclaration(node)) {
-        const typeLiteral = t29.tsTypeLiteral(node.body.body);
+      if (t28.isTSInterfaceDeclaration(node)) {
+        const typeLiteral = t28.tsTypeLiteral(node.body.body);
         if (!hasSlotsSignatureInType(typeLiteral)) return;
         const resolved = resolveSlotType(typeLiteral);
-        if (resolved && t29.isTSTypeLiteral(resolved)) {
+        if (resolved && t28.isTSTypeLiteral(resolved)) {
           node.body.body = resolved.members;
           recordReactNode(ctx);
         }
         return;
       }
-      if (t29.isTSTypeAliasDeclaration(node)) {
+      if (t28.isTSTypeAliasDeclaration(node)) {
         if (!hasSlotsSignatureInType(node.typeAnnotation)) return;
         const resolved = resolveSlotType(node.typeAnnotation);
         if (resolved) {
@@ -3311,7 +3278,7 @@ function resolveTemplateSlotIface(ctx) {
   }
   if (tsMembers.length) {
     recordReactNode(ctx);
-    slotTypes.push(t29.tsTypeLiteral(tsMembers));
+    slotTypes.push(t28.tsTypeLiteral(tsMembers));
   }
 }
 function recordReactNode(ctx) {
@@ -3321,32 +3288,32 @@ function recordReactNode(ctx) {
   recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.ReactNode);
 }
 function resolveSlotType(tsType) {
-  if (t29.isTSParenthesizedType(tsType)) {
+  if (t28.isTSParenthesizedType(tsType)) {
     return resolveSlotType(tsType.typeAnnotation);
   }
-  if (t29.isTSTypeReference(tsType)) {
+  if (t28.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return tsType;
     }
     const params = tsType.typeParameters.params.map((param) => resolveSlotType(param)).filter(Boolean);
-    return t29.tsTypeReference(
+    return t28.tsTypeReference(
       tsType.typeName,
-      t29.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
+      t28.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
     );
   }
-  if (t29.isTSIntersectionType(tsType)) {
+  if (t28.isTSIntersectionType(tsType)) {
     const types = tsType.types.map(resolveSlotType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t29.tsIntersectionType(types);
+    return t28.tsIntersectionType(types);
   }
-  if (t29.isTSUnionType(tsType)) {
+  if (t28.isTSUnionType(tsType)) {
     const types = tsType.types.map(resolveSlotType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t29.tsUnionType(types);
+    return t28.tsUnionType(types);
   }
-  if (t29.isTSTypeLiteral(tsType)) {
+  if (t28.isTSTypeLiteral(tsType)) {
     const members = [];
     for (const member of tsType.members) {
       const resolved = resolveSlotPropFromMember(member);
@@ -3357,56 +3324,56 @@ function resolveSlotType(tsType) {
       members.push(member);
     }
     if (!members.length) return null;
-    return t29.tsTypeLiteral(members);
+    return t28.tsTypeLiteral(members);
   }
-  if (t29.isTSFunctionType(tsType)) {
+  if (t28.isTSFunctionType(tsType)) {
     const props = buildSlotPropSignature(
       SLOT_DEFAULT_NAME,
       cloneCallableParams(tsType.parameters),
       false
     );
-    return t29.tsTypeLiteral([props]);
+    return t28.tsTypeLiteral([props]);
   }
   return tsType;
 }
 function hasSlotsSignatureInType(tsType) {
-  if (t29.isTSParenthesizedType(tsType)) {
+  if (t28.isTSParenthesizedType(tsType)) {
     return hasSlotsSignatureInType(tsType.typeAnnotation);
   }
-  if (t29.isTSTypeReference(tsType)) {
+  if (t28.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return false;
     }
     return tsType.typeParameters.params.some(hasSlotsSignatureInType);
   }
-  if (t29.isTSIntersectionType(tsType) || t29.isTSUnionType(tsType)) {
+  if (t28.isTSIntersectionType(tsType) || t28.isTSUnionType(tsType)) {
     return tsType.types.some(hasSlotsSignatureInType);
   }
-  if (t29.isTSTypeLiteral(tsType)) {
+  if (t28.isTSTypeLiteral(tsType)) {
     return tsType.members.some(hasSlotsSignatureInMember);
   }
-  if (t29.isTSFunctionType(tsType)) {
+  if (t28.isTSFunctionType(tsType)) {
     return true;
   }
   return false;
 }
 function hasSlotsSignatureInMember(member) {
-  if (t29.isTSMethodSignature(member)) return true;
-  if (t29.isTSCallSignatureDeclaration(member)) return true;
-  if (t29.isTSPropertySignature(member)) {
+  if (t28.isTSMethodSignature(member)) return true;
+  if (t28.isTSCallSignatureDeclaration(member)) return true;
+  if (t28.isTSPropertySignature(member)) {
     const typeAnnotation = member.typeAnnotation?.typeAnnotation;
     return !!(typeAnnotation && resolveCallableType(typeAnnotation));
   }
   return false;
 }
 function resolveSlotPropFromMember(member) {
-  if (t29.isTSMethodSignature(member)) {
+  if (t28.isTSMethodSignature(member)) {
     const rawName = resolvePropName2(member.key);
     if (!rawName) return null;
     const params = cloneCallableParams(member.parameters);
     return buildSlotPropSignature(rawName, params, !!member.optional);
   }
-  if (t29.isTSPropertySignature(member)) {
+  if (t28.isTSPropertySignature(member)) {
     const rawName = resolvePropName2(member.key);
     if (!rawName) return null;
     const typeAnnotation = member.typeAnnotation?.typeAnnotation;
@@ -3415,53 +3382,53 @@ function resolveSlotPropFromMember(member) {
     const params = cloneCallableParams(callable.parameters);
     return buildSlotPropSignature(rawName, params, !!member.optional);
   }
-  if (t29.isTSCallSignatureDeclaration(member)) {
+  if (t28.isTSCallSignatureDeclaration(member)) {
     const params = cloneCallableParams(member.parameters);
     return buildSlotPropSignature(SLOT_DEFAULT_NAME, params, true);
   }
   return null;
 }
 function resolveCallableType(tsType) {
-  if (t29.isTSFunctionType(tsType)) return tsType;
-  if (t29.isTSParenthesizedType(tsType)) return resolveCallableType(tsType.typeAnnotation);
+  if (t28.isTSFunctionType(tsType)) return tsType;
+  if (t28.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 = t29.isValidIdentifier(propName) ? t29.identifier(propName) : t29.stringLiteral(propName);
-  const reactNodeType = t29.tsTypeAnnotation(
-    t29.tsTypeReference(t29.identifier(REACT_API_MAP.ReactNode))
+  const key = t28.isValidIdentifier(propName) ? t28.identifier(propName) : t28.stringLiteral(propName);
+  const reactNodeType = t28.tsTypeAnnotation(
+    t28.tsTypeReference(t28.identifier(REACT_API_MAP.ReactNode))
   );
   let typeAnnotation;
   if (rawName === SLOT_DEFAULT_NAME && params.length === 0 || params.length === 0) {
     typeAnnotation = reactNodeType;
   } else {
-    const fnType = t29.tsFunctionType(null, params, reactNodeType);
-    typeAnnotation = t29.tsTypeAnnotation(fnType);
+    const fnType = t28.tsFunctionType(null, params, reactNodeType);
+    typeAnnotation = t28.tsTypeAnnotation(fnType);
   }
-  const prop = t29.tsPropertySignature(key, typeAnnotation);
+  const prop = t28.tsPropertySignature(key, typeAnnotation);
   prop.optional = optional;
   return prop;
 }
 function createSlotScopeParam(props, ctx) {
-  const paramId = t29.identifier(SLOT_FN_PARAM_NAME);
+  const paramId = t28.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 ? t29.tsTypeAnnotation(foundBindingTypes) : tsType;
-    const key = t29.isValidIdentifier(prop) ? t29.identifier(prop) : t29.stringLiteral(prop);
-    const propSign = t29.tsPropertySignature(key, typeAnnotation);
+    const typeAnnotation = foundBindingTypes ? t28.tsTypeAnnotation(foundBindingTypes) : tsType;
+    const key = t28.isValidIdentifier(prop) ? t28.identifier(prop) : t28.stringLiteral(prop);
+    const propSign = t28.tsPropertySignature(key, typeAnnotation);
     propsSigns.push(propSign);
   });
-  paramId.typeAnnotation = t29.tsTypeAnnotation(t29.tsTypeLiteral(propsSigns));
+  paramId.typeAnnotation = t28.tsTypeAnnotation(t28.tsTypeLiteral(propsSigns));
   return paramId;
 }
 function resolvePropName2(key) {
-  if (t29.isIdentifier(key)) return key.name;
-  if (t29.isStringLiteral(key)) return key.value;
-  if (t29.isNumericLiteral(key)) return String(key.value);
+  if (t28.isIdentifier(key)) return key.name;
+  if (t28.isStringLiteral(key)) return key.value;
+  if (t28.isNumericLiteral(key)) return String(key.value);
   return null;
 }
 
@@ -3513,9 +3480,9 @@ function resolveCompIProps(ctx, ast) {
   }
   const n = ctx.compName || "Comp";
   const ns = `I${camelCase(capitalize(n))}Props`;
-  const typeNode = t30.tsIntersectionType(tsTypes);
-  const typeAliasDecl = t30.tsTypeAliasDeclaration(t30.identifier(ns), null, typeNode);
-  const exportDecl = t30.exportNamedDeclaration(typeAliasDecl);
+  const typeNode = t29.tsIntersectionType(tsTypes);
+  const typeAliasDecl = t29.tsTypeAliasDeclaration(t29.identifier(ns), null, typeNode);
+  const exportDecl = t29.exportNamedDeclaration(typeAliasDecl);
   propsTSIface.name = ns;
   const scriptIR = getScriptIR(ctx);
   scriptIR.exports.push(exportDecl);
@@ -3523,17 +3490,17 @@ function resolveCompIProps(ctx, ast) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-analysis-only-adapter.ts
-import * as t32 from "@babel/types";
+import * as t31 from "@babel/types";
 
 // src/core/transform/sfc/script/shared/dependency-analyzer.ts
 import { traverse as traverse2 } from "@babel/core";
-import * as t31 from "@babel/types";
+import * as t30 from "@babel/types";
 var TRACE_MAX_DEPTH = 20;
 function analyzeDeps(node, ctx, parentPath) {
   if (!parentPath) {
-    return t31.arrayExpression([]);
+    return t30.arrayExpression([]);
   }
-  const isFnExpr = t31.isArrowFunctionExpression(node) || t31.isFunctionExpression(node);
+  const isFnExpr = t30.isArrowFunctionExpression(node) || t30.isFunctionExpression(node);
   const analyzeTarget = isFnExpr ? node.body : node;
   const bindingLocalBoundary = isFnExpr ? node : analyzeTarget;
   const reactiveStateApis = getReactiveStateApis();
@@ -3544,13 +3511,13 @@ function analyzeDeps(node, ctx, parentPath) {
   }
   const analyzeTargetPath = parentPath && parentPath.node === analyzeTarget ? parentPath : null;
   if (analyzeTargetPath) {
-    if (t31.isMemberExpression(analyzeTarget) || t31.isOptionalMemberExpression(analyzeTarget)) {
+    if (t30.isMemberExpression(analyzeTarget) || t30.isOptionalMemberExpression(analyzeTarget)) {
       const rootId = findRootIdentifier(analyzeTarget);
       if (rootId) {
         tryAddDependency(analyzeTargetPath, rootId.name, analyzeTargetPath.scope);
         processedIdentifiers.add(rootId);
       }
-    } else if (t31.isIdentifier(analyzeTarget)) {
+    } else if (t30.isIdentifier(analyzeTarget)) {
       tryAddDependency(analyzeTargetPath, analyzeTarget.name, analyzeTargetPath.scope);
     }
   }
@@ -3601,55 +3568,55 @@ function analyzeDeps(node, ctx, parentPath) {
     }
   }
   function normalizeDependencyExpr(path9, rootName) {
-    if (t31.isIdentifier(path9.node)) {
-      return t31.identifier(path9.node.name);
+    if (t30.isIdentifier(path9.node)) {
+      return t30.identifier(path9.node.name);
     }
-    if (t31.isMemberExpression(path9.node) || t31.isOptionalMemberExpression(path9.node)) {
+    if (t30.isMemberExpression(path9.node) || t30.isOptionalMemberExpression(path9.node)) {
       const normalizedExp = normalizeMemberForCallSite(path9, path9.node);
-      const safeExp = t31.isMemberExpression(normalizedExp) || t31.isOptionalMemberExpression(normalizedExp) ? ensureOptionalForMemberChain(normalizedExp) : normalizedExp;
+      const safeExp = t30.isMemberExpression(normalizedExp) || t30.isOptionalMemberExpression(normalizedExp) ? ensureOptionalForMemberChain(normalizedExp) : normalizedExp;
       if (isReactValidDependencyExpr(safeExp)) {
-        return t31.cloneNode(safeExp, true);
+        return t30.cloneNode(safeExp, true);
       }
-      return t31.identifier(rootName);
+      return t30.identifier(rootName);
     }
     return null;
   }
   function normalizeSourcedDependency(exp) {
-    if (t31.isIdentifier(exp)) {
-      return t31.identifier(exp.name);
+    if (t30.isIdentifier(exp)) {
+      return t30.identifier(exp.name);
     }
-    if (t31.isMemberExpression(exp) || t31.isOptionalMemberExpression(exp)) {
+    if (t30.isMemberExpression(exp) || t30.isOptionalMemberExpression(exp)) {
       const root = findRootIdentifier(exp);
       if (!root) return null;
-      const safeExp = t31.isMemberExpression(exp) || t31.isOptionalMemberExpression(exp) ? ensureOptionalForMemberChain(exp) : exp;
+      const safeExp = t30.isMemberExpression(exp) || t30.isOptionalMemberExpression(exp) ? ensureOptionalForMemberChain(exp) : exp;
       if (isReactValidDependencyExpr(safeExp)) {
-        return t31.cloneNode(safeExp, true);
+        return t30.cloneNode(safeExp, true);
       }
-      return t31.identifier(root.name);
+      return t30.identifier(root.name);
     }
     return null;
   }
   function isReactValidDependencyExpr(node2) {
-    if (t31.isIdentifier(node2)) {
+    if (t30.isIdentifier(node2)) {
       return true;
     }
-    if (t31.isMemberExpression(node2) || t31.isOptionalMemberExpression(node2)) {
+    if (t30.isMemberExpression(node2) || t30.isOptionalMemberExpression(node2)) {
       return isStaticMemberChain(node2);
     }
     return false;
   }
   function isStaticMemberChain(node2) {
     let current = node2;
-    while (t31.isMemberExpression(current) || t31.isOptionalMemberExpression(current)) {
-      if (!current.computed && !t31.isIdentifier(current.property)) {
+    while (t30.isMemberExpression(current) || t30.isOptionalMemberExpression(current)) {
+      if (!current.computed && !t30.isIdentifier(current.property)) {
         return false;
       }
-      if (current.computed && !t31.isStringLiteral(current.property) && !t31.isNumericLiteral(current.property)) {
+      if (current.computed && !t30.isStringLiteral(current.property) && !t30.isNumericLiteral(current.property)) {
         return false;
       }
       current = current.object;
     }
-    return t31.isIdentifier(current);
+    return t30.isIdentifier(current);
   }
   function isBindingDeclaredInsideBoundary(binding, boundary) {
     let current = binding.path;
@@ -3667,7 +3634,7 @@ function analyzeDeps(node, ctx, parentPath) {
     if (!isDirectCallee) {
       return node2;
     }
-    if (!t31.isExpression(node2.object)) {
+    if (!t30.isExpression(node2.object)) {
       return node2;
     }
     return node2.object;
@@ -3676,15 +3643,15 @@ function analyzeDeps(node, ctx, parentPath) {
     if (!hasTrailingMemberAccess(node2)) {
       return node2;
     }
-    if (t31.isOptionalMemberExpression(node2) && node2.optional) {
+    if (t30.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);
+    const object = t30.cloneNode(node2.object, true);
+    const property = t30.cloneNode(node2.property, true);
+    return t30.optionalMemberExpression(object, property, node2.computed, true);
   }
   function hasTrailingMemberAccess(node2) {
-    return t31.isMemberExpression(node2.object) || t31.isOptionalMemberExpression(node2.object);
+    return t30.isMemberExpression(node2.object) || t30.isOptionalMemberExpression(node2.object);
   }
   function isEligibleBindingSource(binding) {
     if (binding.kind === "param") {
@@ -3694,17 +3661,17 @@ function analyzeDeps(node, ctx, parentPath) {
     const declaratorPath = getVariableDeclaratorPath(bindingPath);
     const isReactiveVarBinding = !!declaratorPath && isReactiveBinding(declaratorPath.node);
     const nodeInit = declaratorPath?.node.init;
-    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));
+    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));
     const isReactiveFunctionBinding = isFunctionBinding && (isReactiveBinding(declaratorPath?.node) || isReactiveBinding(bindingPath.node));
     return isReactiveVarBinding || isReactiveApiCallVarBinding || isHookCallVarBinding || isReactiveFunctionBinding;
   }
   function isHookLikeCallee(callee) {
-    if (t31.isIdentifier(callee)) {
+    if (t30.isIdentifier(callee)) {
       return callee.name.startsWith("use");
     }
-    if (t31.isMemberExpression(callee) && !callee.computed && t31.isIdentifier(callee.property)) {
+    if (t30.isMemberExpression(callee) && !callee.computed && t30.isIdentifier(callee.property)) {
       return callee.property.name.startsWith("use");
     }
     return false;
@@ -3720,7 +3687,7 @@ function analyzeDeps(node, ctx, parentPath) {
   }
   function isExpressionSourcedFromEligibleBinding(exp, scope, seen, depth) {
     if (depth <= 0) return null;
-    if (t31.isIdentifier(exp)) {
+    if (t30.isIdentifier(exp)) {
       const sourceBinding = scope.getBinding(exp.name);
       if (!sourceBinding) return null;
       if (isEligibleBindingSource(sourceBinding)) {
@@ -3728,13 +3695,13 @@ function analyzeDeps(node, ctx, parentPath) {
       }
       return traceBindingSource(sourceBinding, seen, depth - 1);
     }
-    if (t31.isMemberExpression(exp) || t31.isOptionalMemberExpression(exp)) {
+    if (t30.isMemberExpression(exp) || t30.isOptionalMemberExpression(exp)) {
       const root = findRootIdentifier(exp);
       if (!root) return null;
       const sourceBinding = scope.getBinding(root.name);
       if (!sourceBinding) return null;
       if (isEligibleBindingSource(sourceBinding)) {
-        return t31.cloneNode(exp);
+        return t30.cloneNode(exp);
       }
       const sourcedRoot = traceBindingSource(sourceBinding, seen, depth - 1);
       if (sourcedRoot) {
@@ -3742,17 +3709,17 @@ function analyzeDeps(node, ctx, parentPath) {
         if (rebuilt) {
           return rebuilt;
         }
-        return t31.cloneNode(sourcedRoot, true);
+        return t30.cloneNode(sourcedRoot, true);
       }
     }
     return null;
   }
   function rebuildMemberWithNewRoot(node2, nextRoot) {
     const replacedObject = (() => {
-      if (t31.isIdentifier(node2.object)) {
-        return t31.cloneNode(nextRoot, true);
+      if (t30.isIdentifier(node2.object)) {
+        return t30.cloneNode(nextRoot, true);
       }
-      if (t31.isMemberExpression(node2.object) || t31.isOptionalMemberExpression(node2.object)) {
+      if (t30.isMemberExpression(node2.object) || t30.isOptionalMemberExpression(node2.object)) {
         return rebuildMemberWithNewRoot(node2.object, nextRoot);
       }
       return null;
@@ -3760,34 +3727,34 @@ function analyzeDeps(node, ctx, parentPath) {
     if (!replacedObject) {
       return null;
     }
-    const property = t31.cloneNode(node2.property, true);
-    if (t31.isMemberExpression(node2)) {
-      return t31.memberExpression(
+    const property = t30.cloneNode(node2.property, true);
+    if (t30.isMemberExpression(node2)) {
+      return t30.memberExpression(
         replacedObject,
         property,
         node2.computed
       );
     }
-    return t31.optionalMemberExpression(
+    return t30.optionalMemberExpression(
       replacedObject,
       property,
       node2.computed,
       node2.optional
     );
   }
-  return t31.arrayExpression(Array.from(deps.values()));
+  return t30.arrayExpression(Array.from(deps.values()));
 }
 function getDependencyKey(exp) {
-  if (t31.isIdentifier(exp)) {
+  if (t30.isIdentifier(exp)) {
     return exp.name;
   }
-  if (t31.isMemberExpression(exp) || t31.isOptionalMemberExpression(exp)) {
+  if (t30.isMemberExpression(exp) || t30.isOptionalMemberExpression(exp)) {
     const objectKey = getDependencyKey(exp.object);
     const opt = exp.optional ? "?" : "";
-    if (!exp.computed && t31.isIdentifier(exp.property)) {
+    if (!exp.computed && t30.isIdentifier(exp.property)) {
       return `${objectKey}${opt}.${exp.property.name}`;
     }
-    if (t31.isStringLiteral(exp.property) || t31.isNumericLiteral(exp.property)) {
+    if (t30.isStringLiteral(exp.property) || t30.isNumericLiteral(exp.property)) {
       return `${objectKey}${opt}[${JSON.stringify(exp.property.value)}]`;
     }
     return `${objectKey}${opt}[*]`;
@@ -3820,7 +3787,7 @@ function resolveAnalysisOnlyAdapter(ctx) {
       if (!isVueApiReference(path9, apiName)) {
         return;
       }
-      if (t32.isCallExpression(node)) {
+      if (t31.isCallExpression(node)) {
         resolveCallNode(path9, adapter, ctx);
       } else {
         replaceIdName(node, adapter.target);
@@ -3830,11 +3797,11 @@ function resolveAnalysisOnlyAdapter(ctx) {
   };
 }
 function getApiName(node) {
-  const isCallNode = t32.isCallExpression(node);
+  const isCallNode = t31.isCallExpression(node);
   let apiName = "";
-  if (t32.isIdentifier(node)) {
+  if (t31.isIdentifier(node)) {
     apiName = node.name;
-  } else if (isCallNode && t32.isIdentifier(node.callee)) {
+  } else if (isCallNode && t31.isIdentifier(node.callee)) {
     apiName = node.callee.name;
   }
   return apiName;
@@ -3844,7 +3811,7 @@ function resolveCallNode(path9, adapter, ctx) {
   const { arguments: args } = node;
   if (!args.length) return;
   const fn = args[0];
-  if (!t32.isArrowFunctionExpression(fn) && !t32.isFunctionExpression(fn)) {
+  if (!t31.isArrowFunctionExpression(fn) && !t31.isFunctionExpression(fn)) {
     return;
   }
   const fnPath = path9.get("arguments")[0];
@@ -3876,7 +3843,7 @@ function isVueImportBinding(binding) {
     return false;
   }
   const parent = bindingPath.parentPath?.node;
-  if (!parent || !t32.isImportDeclaration(parent)) {
+  if (!parent || !t31.isImportDeclaration(parent)) {
     return false;
   }
   const source = parent.source.value.toLowerCase();
@@ -3944,7 +3911,7 @@ function isSkip(path9) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-element-ref.ts
-import * as t33 from "@babel/types";
+import * as t32 from "@babel/types";
 function resolveElementRef(ctx) {
   return {
     CallExpression(path9) {
@@ -3962,14 +3929,14 @@ function resolveElementRef(ctx) {
       }
       if (isCompRefBindings) {
         const varDeclaratorPath = getVariableDeclaratorPath(path9)?.node;
-        if (!t33.isIdentifier(varDeclaratorPath?.id)) {
+        if (!t32.isIdentifier(varDeclaratorPath?.id)) {
           return;
         }
         const varName = varDeclaratorPath.id.name;
         const compRef = refBindings.componentRefs[varName];
         if (!compRef) return;
       }
-      node.arguments[0] = t33.identifier("null");
+      node.arguments[0] = t32.identifier("null");
       resolveTypeParameters(ctx, path9);
       replaceCallName(node, REACT_API_MAP.useRef);
       recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.useRef);
@@ -3994,27 +3961,27 @@ function resolveTypeParameters(ctx, path9) {
   const compBindingMeta = refBindings.componentRefs[idName];
   if (!node.typeParameters && (domBindingMeta || compBindingMeta)) {
     const type = compBindingMeta ? "any" : domBindingMeta.htmlType;
-    node.typeParameters = t33.tsTypeParameterInstantiation([t33.tsTypeReference(t33.identifier(type))]);
+    node.typeParameters = t32.tsTypeParameterInstantiation([t32.tsTypeReference(t32.identifier(type))]);
   }
 }
 function resolveRefValueToCurrent(path9) {
   const { node } = path9;
-  if (node.computed || !t33.isIdentifier(node.property) || node.property.name !== "value") {
+  if (node.computed || !t32.isIdentifier(node.property) || node.property.name !== "value") {
     return;
   }
   const rootPath = findRootVariablePath(path9);
-  if (!rootPath?.node || !t33.isCallExpression(rootPath.node.init) || !isCalleeNamed(rootPath.node.init, REACT_API_MAP.useRef)) {
+  if (!rootPath?.node || !t32.isCallExpression(rootPath.node.init) || !isCalleeNamed(rootPath.node.init, REACT_API_MAP.useRef)) {
     return;
   }
   const rootId = findRootIdentifier(node);
-  if (!t33.isIdentifier(node.object) || node.object.name !== rootId?.name) {
+  if (!t32.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 t34 from "@babel/types";
+import * as t33 from "@babel/types";
 function resolveExprMemo(ctx, ast) {
   const isScriptFile = ctx.inputType !== "sfc";
   return {
@@ -4026,11 +3993,11 @@ function resolveExprMemo(ctx, ast) {
         if (!atComponentOrHookRoot(path9, ast.program, isScriptFile)) {
           return false;
         }
-        if (!t34.isVariableDeclaration(path9.parent) || path9.parent.kind !== "const") {
+        if (!t33.isVariableDeclaration(path9.parent) || path9.parent.kind !== "const") {
           return false;
         }
-        if (t34.isFunction(init)) return false;
-        if (t34.isCallExpression(init) && t34.isIdentifier(init.callee) && init.callee.name.startsWith("use")) {
+        if (t33.isFunction(init)) return false;
+        if (t33.isCallExpression(init) && t33.isIdentifier(init.callee) && init.callee.name.startsWith("use")) {
           return false;
         }
         return true;
@@ -4048,16 +4015,16 @@ function resolveExprMemo(ctx, ast) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-lint-rules.ts
-import * as t35 from "@babel/types";
+import * as t34 from "@babel/types";
 function resolveLintRules(ctx, ast) {
   const inScriptFile = ctx.inputType !== "sfc";
   return {
     CallExpression(path9) {
       const { node, parentPath } = path9;
-      if (!t35.isIdentifier(node.callee)) return;
+      if (!t34.isIdentifier(node.callee)) return;
       const { name: callName } = node.callee;
-      const addLog = (t41) => {
-        logger.error(t41, {
+      const addLog = (t40) => {
+        logger.error(t40, {
           file: ctx.filename,
           source: ctx.scriptData.source,
           loc: node.loc
@@ -4101,8 +4068,8 @@ function resolveLintRules(ctx, ast) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-provide.ts
-import { generate as generate3 } from "@babel/generator";
-import * as t36 from "@babel/types";
+import { generate as generate2 } from "@babel/generator";
+import * as t35 from "@babel/types";
 function resolveProvide(ctx) {
   if (ctx.inputType === "style") return {};
   return {
@@ -4134,17 +4101,17 @@ function findOrCreateCtxProvider(root) {
 function assignProviderValue(target, key, value) {
   const getRawExp = (exp) => {
     if (!exp) return "''";
-    if (t36.isStringLiteral(exp)) {
+    if (t35.isStringLiteral(exp)) {
       return JSON.stringify(exp.value);
     }
-    if (t36.isNumericLiteral(exp)) {
+    if (t35.isNumericLiteral(exp)) {
       return exp.value.toString();
     }
-    if (t36.isIdentifier(exp)) {
+    if (t35.isIdentifier(exp)) {
       return exp.name;
     }
     try {
-      return generate3(exp).code;
+      return generate2(exp).code;
     } catch {
       return "null";
     }
@@ -4156,16 +4123,16 @@ function assignProviderValue(target, key, value) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-rename-adapter.ts
-import * as t37 from "@babel/types";
+import * as t36 from "@babel/types";
 function resolveRenameAdapter(ctx) {
   return {
     "CallExpression|Identifier"(path9) {
       const node = path9.node;
-      const isCallNode = t37.isCallExpression(node);
+      const isCallNode = t36.isCallExpression(node);
       let apiName = "";
-      if (t37.isIdentifier(node)) {
+      if (t36.isIdentifier(node)) {
         apiName = node.name;
-      } else if (isCallNode && t37.isIdentifier(node.callee)) {
+      } else if (isCallNode && t36.isIdentifier(node.callee)) {
         apiName = node.callee.name;
       }
       if (!apiName) {
@@ -4223,7 +4190,7 @@ function isVueImportBinding2(binding) {
     return false;
   }
   const parent = bindingPath.parentPath?.node;
-  if (!parent || !t37.isImportDeclaration(parent)) {
+  if (!parent || !t36.isImportDeclaration(parent)) {
     return false;
   }
   const source = parent.source.value.toLowerCase();
@@ -4266,8 +4233,8 @@ function processVueSyntax2(ast, ctx) {
       excludeBabel: [resolveTemplateSlotIface, resolveCompIProps]
     },
     postprocess: {
-      applyBabel: [resolveRequiredImports, resolveStaticHoisting],
-      excludeBabel: [insertCSSImport, collectLocalStatements]
+      applyBabel: [resolveRuntimeImports, resolveASTChunks],
+      excludeBabel: [resolveSfcCssImport]
     }
   });
 }
@@ -4359,15 +4326,15 @@ function isRouterLinkBooleanCustomProp(prop) {
 }
 
 // src/core/transform/sfc/template/shared/prop-ir-utils.ts
-import * as t39 from "@babel/types";
+import * as t38 from "@babel/types";
 
 // src/shared/string-code-types.ts
 import { parseExpression as parseExpression3 } from "@babel/parser";
-import * as t38 from "@babel/types";
+import * as t37 from "@babel/types";
 var strCodeTypes = {
-  isIdentifier: isIdentifier20,
+  isIdentifier: isIdentifier19,
   isSimpleExpression,
-  isStringLiteral: isStringLiteral12
+  isStringLiteral: isStringLiteral11
 };
 function isSimpleExpression(code, excludeVar = false) {
   let node;
@@ -4376,38 +4343,38 @@ function isSimpleExpression(code, excludeVar = false) {
   } catch {
     return false;
   }
-  if (t38.isLiteral(node)) {
+  if (t37.isLiteral(node)) {
     return true;
   }
-  if (!excludeVar && t38.isIdentifier(node)) {
+  if (!excludeVar && t37.isIdentifier(node)) {
     return true;
   }
-  if (t38.isMemberExpression(node)) {
-    return isSimpleExpression(node.object) && t38.isIdentifier(node.property);
+  if (t37.isMemberExpression(node)) {
+    return isSimpleExpression(node.object) && t37.isIdentifier(node.property);
   }
-  if (t38.isObjectExpression(node) || t38.isArrayExpression(node)) {
+  if (t37.isObjectExpression(node) || t37.isArrayExpression(node)) {
     return false;
   }
-  if (t38.isCallExpression(node) || t38.isAssignmentExpression(node)) {
+  if (t37.isCallExpression(node) || t37.isAssignmentExpression(node)) {
     return false;
   }
-  if (t38.isBinaryExpression(node) || t38.isUnaryExpression(node)) {
+  if (t37.isBinaryExpression(node) || t37.isUnaryExpression(node)) {
     return true;
   }
   return false;
 }
-function isIdentifier20(code) {
+function isIdentifier19(code) {
   try {
     const node = parseExpression3(code);
-    return t38.isIdentifier(node);
+    return t37.isIdentifier(node);
   } catch {
     return false;
   }
 }
-function isStringLiteral12(code) {
+function isStringLiteral11(code) {
   try {
     const node = parseExpression3(code);
-    return t38.isStringLiteral(node);
+    return t37.isStringLiteral(node);
   } catch {
     return false;
   }
@@ -4549,23 +4516,23 @@ function resolvePropAsBabelExp(ir, ctx) {
   const mergedItems = value.merge;
   const setNameIdentifier = (target, valueName) => {
     target.content = valueName;
-    target.ast = t39.jsxIdentifier(valueName);
+    target.ast = t38.jsxIdentifier(valueName);
   };
-  const setValueExpression = (target, content, isStringLiteral13) => {
+  const setValueExpression = (target, content, isStringLiteral12) => {
     target.content = content;
-    target.ast = resolveStringExpr(content, ctx, isStringLiteral13);
+    target.ast = resolveStringExpr(content, ctx, isStringLiteral12);
   };
   const createRuntimeCall = (fnName, args) => {
     const fnArgs = args.filter(Boolean).join(",");
     return `${fnName}(${fnArgs})`;
   };
-  const applyRuntimeExpression = (expression, setName = false, nameIdentifier, isStringLiteral13) => {
+  const applyRuntimeExpression = (expression, setName = false, nameIdentifier, isStringLiteral12) => {
     if (setName && nameIdentifier) {
       setNameIdentifier(nameExp, nameIdentifier);
     }
     const dir = ADAPTER_RULES.runtime.dir;
     recordImport(ctx, dir.package, dir.target);
-    setValueExpression(value.babelExp, expression, isStringLiteral13);
+    setValueExpression(value.babelExp, expression, isStringLiteral12);
   };
   if (ir.isKeyLessVBind) {
     const dirKeyless = ADAPTER_RULES.runtime.dirKeyless;
@@ -4941,12 +4908,12 @@ function resolvePropertyIR(node, ir, ctx, nodeIR, isDynamic = false) {
     content = node.value.content = parseStyleString(content);
   }
   if (isDynamic) {
-    const isStringLiteral13 = strCodeTypes.isStringLiteral(content);
-    if (isStringLiteral13) {
+    const isStringLiteral12 = strCodeTypes.isStringLiteral(content);
+    if (isStringLiteral12) {
       content = normalizeString(content);
       node.value.content = content;
     }
-    node.value.isStringLiteral = isStringLiteral13;
+    node.value.isStringLiteral = isStringLiteral12;
   }
   const existing = findSameProp(nodeIR.props, node);
   if (existing) {
@@ -5180,7 +5147,7 @@ function applyValueModifiers(valueExp, modifiers) {
 }
 
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-on.ts
-import * as t40 from "@babel/types";
+import * as t39 from "@babel/types";
 function resolveVOn(node, _ir, ctx, nodeIR) {
   const arg = node.arg;
   const exp = node.exp;
@@ -5197,7 +5164,7 @@ function resolveVOn(node, _ir, ctx, nodeIR) {
     originalVueEventName = `${arg.content}.${modifiers.join(".")}`;
   } else {
     const expr = stringToExpr(handler);
-    if (!t40.isFunctionExpression(expr) && !t40.isArrowFunctionExpression(expr) && !t40.isIdentifier(expr)) {
+    if (!t39.isFunctionExpression(expr) && !t39.isArrowFunctionExpression(expr) && !t39.isIdentifier(expr)) {
       handler = `() => {${handler}}`;
     }
   }
@@ -5650,7 +5617,7 @@ function transform(ast, ctx, options) {
 }
 
 // package.json
-var version = "1.5.0";
+var version = "1.5.2";
 var bin = {
   vureact: "./bin/vureact.js"
 };
@@ -6398,18 +6365,10 @@ var BaseCompiler = class extends Helper {
   }
   prepareGenerateOptions(filename) {
     const userOptions = this.options.generate || {};
-    const mergedOptions = {
-      jsescOption: {
-        minimal: true,
-        quotes: "single"
-      },
-      minified: true,
-      ...userOptions
-    };
-    if (mergedOptions.sourceMaps && filename) {
-      mergedOptions.sourceFileName = mergedOptions.sourceFileName || filename;
+    if (userOptions.sourceMaps && filename) {
+      userOptions.sourceFileName = userOptions.sourceFileName || filename;
     }
-    return mergedOptions;
+    return userOptions;
   }
   resolveMainResult(ir, gen, ctxData) {
     const { fileId, filename, scriptData, styleData, inputType } = ctxData;