@vureact/compiler-core 1.5.0 → 1.5.1

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

@@ -1,5 +1,5 @@
 /**
- * @vureact/compiler-core v1.5.0
+ * @vureact/compiler-core v1.5.1
  * (c) 2025-present Ruihong Zhong (Ryan John)
  * @license MIT
  */
@@ -1385,7 +1385,12 @@ function generateComponent(ir, ctx, options) {
       quotes: "single"
       // 使用单引号
     },
-    minified: true,
+    minified: false,
+    // 不压缩输出内容
+    retainLines: false,
+    // 不保留行号
+    retainFunctionParens: true,
+    // 保留函数括号
     ...options
   });
   const result = {
@@ -1461,6 +1466,7 @@ function resolveScript(descriptor, ctx, pResult) {
     source: scriptBlock
   };
   const options = getBabelParseOptions(scriptBlock.lang, "script", ctx.filename);
+  resolveCtxData(scriptBlock, ctx);
   if (descriptor.script) {
     const { code, ast, name } = extractSetupBodyToTopLevel(scriptBlock.content, options);
     if (ast) {
@@ -1480,12 +1486,21 @@ function resolveScript(descriptor, ctx, pResult) {
       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 resolveCtxData(scriptBlock, ctx) {
+  let { content, lang } = scriptBlock;
+  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";
+  scriptBlock.content = content;
+}
 function extractSetupBodyToTopLevel(content, options) {
   let name = "";
   try {
@@ -1549,10 +1564,6 @@ function extractSetupBodyToTopLevel(content, options) {
     return { name, code: content };
   }
 }
-function extractCompName(source) {
-  const nameMatch = source.match(/@vr-name:\s*(\w+)/);
-  return nameMatch?.[1]?.trim() || "";
-}
 
 // src/core/parse/sfc/process/resolve-script-meta.ts
 import { traverse } from "@babel/core";
@@ -1936,265 +1947,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 t17 from "@babel/types";
 function findRootVariablePath(path9) {
   const rootId = findRootIdentifier(path9.node);
   if (!rootId?.name) return null;
@@ -2205,10 +1959,10 @@ function findRootVariablePath(path9) {
 }
 function findRootIdentifier(node) {
   let current = node.object;
-  while (t19.isMemberExpression(current) || t19.isOptionalMemberExpression(current)) {
+  while (t17.isMemberExpression(current) || t17.isOptionalMemberExpression(current)) {
     current = current.object;
   }
-  return t19.isIdentifier(current) ? current : null;
+  return t17.isIdentifier(current) ? current : null;
 }
 function getVariableDeclaratorPath(path9) {
   if (path9.isVariableDeclarator()) {
@@ -2292,14 +2046,14 @@ function isPropertyName(path9) {
 }
 function replaceCallName(callExp, identifierName) {
   const { callee } = callExp;
-  if (!t19.isIdentifier(callee)) return;
+  if (!t17.isIdentifier(callee)) return;
   callee.name = identifierName;
   if (callee.loc) {
     callee.loc.identifierName = identifierName;
   }
 }
 function replaceIdName(id, newName) {
-  if (!t19.isIdentifier(id)) return;
+  if (!t17.isIdentifier(id)) return;
   id.name = newName;
   if (id.loc) {
     id.loc.identifierName = newName;
@@ -2309,69 +2063,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 ? t17.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 (t17.isStringLiteral(exp)) return t17.tsStringKeyword();
+  if (t17.isNumericLiteral(exp)) return t17.tsNumberKeyword();
+  if (t17.isBooleanLiteral(exp)) return t17.tsBooleanKeyword();
+  if (t17.isArrayExpression(exp)) return t17.tsArrayType(t17.tsAnyKeyword());
+  if (t17.isObjectExpression(exp)) {
     const members = [];
     for (const p of exp.properties) {
-      if (!t19.isObjectProperty(p)) continue;
+      if (!t17.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 (t17.isIdentifier(p.key)) key = p.key.name;
+      else if (t17.isStringLiteral(p.key)) key = p.key.value;
       if (!key) continue;
-      if (t19.isExpression(p.value)) {
+      if (t17.isExpression(p.value)) {
         members.push(
-          t19.tsPropertySignature(t19.identifier(key), t19.tsTypeAnnotation(expressionToTSType(p.value)))
+          t17.tsPropertySignature(t17.identifier(key), t17.tsTypeAnnotation(expressionToTSType(p.value)))
         );
       } else {
         members.push(
-          t19.tsPropertySignature(t19.identifier(key), t19.tsTypeAnnotation(t19.tsAnyKeyword()))
+          t17.tsPropertySignature(t17.identifier(key), t17.tsTypeAnnotation(t17.tsAnyKeyword()))
         );
       }
     }
-    return t19.tsTypeLiteral(members);
+    return t17.tsTypeLiteral(members);
   }
-  if (t19.isArrowFunctionExpression(exp) || t19.isFunctionExpression(exp)) {
+  if (t17.isArrowFunctionExpression(exp) || t17.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 = t17.isIdentifier(p) ? t17.identifier(p.name) : t17.identifier(`arg${i}`);
+      id.typeAnnotation = t17.tsTypeAnnotation(t17.tsAnyKeyword());
       return id;
     });
-    let returnType = t19.tsAnyKeyword();
-    if (t19.isBlockStatement(exp.body)) {
+    let returnType = t17.tsAnyKeyword();
+    if (t17.isBlockStatement(exp.body)) {
       for (const stmt of exp.body.body) {
-        if (t19.isReturnStatement(stmt) && stmt.argument) {
-          if (t19.isExpression(stmt.argument)) {
+        if (t17.isReturnStatement(stmt) && stmt.argument) {
+          if (t17.isExpression(stmt.argument)) {
             returnType = expressionToTSType(stmt.argument);
             break;
           }
         }
       }
-    } else if (t19.isExpression(exp.body)) {
+    } else if (t17.isExpression(exp.body)) {
       returnType = expressionToTSType(exp.body);
     }
-    return t19.tsFunctionType(null, params, t19.tsTypeAnnotation(returnType));
+    return t17.tsFunctionType(null, params, t17.tsTypeAnnotation(returnType));
   }
-  return t19.tsAnyKeyword();
+  return t17.tsAnyKeyword();
 }
 function isCalleeNamed(node, name) {
-  if (!t19.isIdentifier(node.callee)) {
+  if (!t17.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 (t17.isStringLiteral(node) || t17.isNumericLiteral(node) || t17.isBooleanLiteral(node) || t17.isNullLiteral(node) || t17.isRegExpLiteral(node) || t17.isBigIntLiteral(node) || t17.isDecimalLiteral(node)) {
     return true;
   }
   return false;
 }
+function forkNode(node, deep = true) {
+  const newNode = t17.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 t18 from "@babel/types";
+function resolveModuleChunks(path9, ir) {
+  const forked = forkNode(path9.node);
+  if (t18.isImportDeclaration(forked)) {
+    ir.imports.push(forked);
+  } else if (t18.isExportDeclaration(forked)) {
+    ir.exports.push(forked);
+  }
+  path9.remove();
+}
 
 // src/core/transform/sfc/script/shared/metadata-utils.ts
 var META_KEY = "__vureact_metadata";
@@ -2389,43 +2184,289 @@ 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 t19 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 (t19.isImportSpecifier(spec) && t19.isIdentifier(spec.imported)) {
+      currentImports.add(spec.imported.name);
+    }
+    if (t19.isImportDefaultSpecifier(spec) && t19.isIdentifier(spec.local)) {
+      currentImports.add(spec.local.name);
+    }
+  }
+  for (const item of ctxImportItems) {
+    if (currentImports.has(item.name)) {
+      continue;
+    }
+    const local = t19.identifier(item.name);
+    const newNode = !item.onDemand ? t19.importDefaultSpecifier(local) : t19.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 = t19.identifier(item.name);
+      return item.onDemand ? t19.importSpecifier(local, local) : t19.importDefaultSpecifier(local);
+    });
+    return t19.importDeclaration(specifiers, t19.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 t20 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 = t20.importDeclaration(
+    !moduleName ? [] : [t20.importDefaultSpecifier(t20.identifier(moduleName))],
+    t20.stringLiteral(`./${styleFilename}`)
+  );
+  scriptIR.imports.push(importDecl);
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-async-component.ts
@@ -2485,7 +2526,7 @@ function checkIsDynamicImport(ctx, node) {
   if (t21.isCallExpression(node)) {
     warnIsNotImport(node.callee);
     if (t21.isStringLiteral(node.arguments[0])) {
-      replaceVueSuffix(ctx, node.arguments[0]);
+      replaceVueSuffix(node.arguments[0]);
     }
     return;
   }
@@ -4266,8 +4307,8 @@ function processVueSyntax2(ast, ctx) {
       excludeBabel: [resolveTemplateSlotIface, resolveCompIProps]
     },
     postprocess: {
-      applyBabel: [resolveRequiredImports, resolveStaticHoisting],
-      excludeBabel: [insertCSSImport, collectLocalStatements]
+      applyBabel: [resolveRuntimeImports, resolveASTChunks],
+      excludeBabel: [resolveSfcCssImport]
     }
   });
 }
@@ -5650,7 +5691,7 @@ function transform(ast, ctx, options) {
 }
 
 // package.json
-var version = "1.5.0";
+var version = "1.5.1";
 var bin = {
   vureact: "./bin/vureact.js"
 };
@@ -6398,18 +6439,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;