@vureact/compiler-core 1.7.0 → 1.8.1

package/lib/{chunk-Q7HZAZHD.esm.js → chunk-QXYYGKFW.esm.js}

@@ -1,5 +1,5 @@
 /**
- * @vureact/compiler-core v1.7.0
+ * @vureact/compiler-core v1.8.1
  * (c) 2025-present Ruihong Zhong (Ryan John)
  * @license MIT
  */
@@ -451,8 +451,8 @@ function getBabelParseOptions(lang = "js", context = "script", filename) {
 function stringToExpr(input, lang, filename = "") {
   return parseExpression(input, getBabelParseOptions(lang, "expression", filename));
 }
-function atComponentOrHookRoot(path9, rootScope, inScriptFile = false) {
-  const { parentPath, scope } = path9;
+function atComponentOrHookRoot(path8, rootScope, inScriptFile = false) {
+  const { parentPath, scope } = path8;
   const parentBlock = scope.block;
   if (!parentPath) return !inScriptFile;
   if (parentBlock === rootScope) {
@@ -1521,10 +1521,10 @@ import * as t16 from "@babel/types";
 
 // src/core/transform/sfc/script/shared/babel-utils.ts
 import * as t15 from "@babel/types";
-function findRootVariablePath(path9) {
-  const rootId = findRootIdentifier(path9.node);
+function findRootVariablePath(path8) {
+  const rootId = findRootIdentifier(path8.node);
   if (!rootId?.name) return null;
-  const binding = path9.scope.getBinding(rootId.name);
+  const binding = path8.scope.getBinding(rootId.name);
   if (!binding) return null;
   const rootPath = getVariableDeclaratorPath(binding.path);
   return rootPath;
@@ -1536,14 +1536,14 @@ function findRootIdentifier(node) {
   }
   return t15.isIdentifier(current) ? current : null;
 }
-function getVariableDeclaratorPath(path9) {
-  if (path9.isVariableDeclarator()) {
-    return path9;
+function getVariableDeclaratorPath(path8) {
+  if (path8.isVariableDeclarator()) {
+    return path8;
   }
-  return path9.findParent((p) => p.isVariableDeclarator());
+  return path8.findParent((p) => p.isVariableDeclarator());
 }
-function isVariableDeclTopLevel(path9) {
-  const variableDeclaratorPath = path9;
+function isVariableDeclTopLevel(path8) {
+  const variableDeclaratorPath = path8;
   const variableDeclarationPath = variableDeclaratorPath.parentPath;
   if (!variableDeclarationPath) {
     return false;
@@ -1557,61 +1557,61 @@ function isVariableDeclTopLevel(path9) {
   }
   return false;
 }
-function isRealVariableAccess(path9) {
-  return isIdentifierAccess(path9) && !isPropertyName(path9);
+function isRealVariableAccess(path8) {
+  return isIdentifierAccess(path8) && !isPropertyName(path8);
 }
-function isIdentifierAccess(path9) {
-  if (isIdentifierDeclaration(path9)) {
+function isIdentifierAccess(path8) {
+  if (isIdentifierDeclaration(path8)) {
     return false;
   }
-  const binding = path9.scope.getBinding(path9.node.name);
+  const binding = path8.scope.getBinding(path8.node.name);
   if (!binding) {
     return true;
   }
-  return binding.identifier !== path9.node;
+  return binding.identifier !== path8.node;
 }
-function isIdentifierDeclaration(path9) {
-  const parent = path9.parentPath;
+function isIdentifierDeclaration(path8) {
+  const parent = path8.parentPath;
   if (!parent) return false;
-  if (parent.isVariableDeclarator() && parent.node.id === path9.node) {
+  if (parent.isVariableDeclarator() && parent.node.id === path8.node) {
     return true;
   }
-  if (parent.isFunctionDeclaration() && parent.node.id === path9.node) {
+  if (parent.isFunctionDeclaration() && parent.node.id === path8.node) {
     return true;
   }
-  if (parent.isFunctionExpression() && parent.node.id === path9.node) {
+  if (parent.isFunctionExpression() && parent.node.id === path8.node) {
     return true;
   }
-  if (parent.isClassDeclaration() && parent.node.id === path9.node) {
+  if (parent.isClassDeclaration() && parent.node.id === path8.node) {
     return true;
   }
-  if (parent.isImportSpecifier() && parent.node.local === path9.node) {
+  if (parent.isImportSpecifier() && parent.node.local === path8.node) {
     return true;
   }
-  if (parent.isImportDefaultSpecifier() && parent.node.local === path9.node) {
+  if (parent.isImportDefaultSpecifier() && parent.node.local === path8.node) {
     return true;
   }
-  if (parent.isImportNamespaceSpecifier() && parent.node.local === path9.node) {
+  if (parent.isImportNamespaceSpecifier() && parent.node.local === path8.node) {
     return true;
   }
-  if (parent.isFunction() && parent.node.params.includes(path9.node)) {
+  if (parent.isFunction() && parent.node.params.includes(path8.node)) {
     return true;
   }
-  if (parent.isCatchClause() && parent.node.param === path9.node) {
+  if (parent.isCatchClause() && parent.node.param === path8.node) {
     return true;
   }
   return false;
 }
-function isPropertyName(path9) {
-  const parent = path9.parentPath;
+function isPropertyName(path8) {
+  const parent = path8.parentPath;
   if (!parent) return false;
-  if (parent.isObjectProperty() && parent.node.key === path9.node) {
+  if (parent.isObjectProperty() && parent.node.key === path8.node) {
     return true;
   }
-  if (parent.isClassProperty() && parent.node.key === path9.node) {
+  if (parent.isClassProperty() && parent.node.key === path8.node) {
     return true;
   }
-  if (parent.isMemberExpression() && parent.node.property === path9.node) {
+  if (parent.isMemberExpression() && parent.node.property === path8.node) {
     return true;
   }
   return false;
@@ -1707,7 +1707,7 @@ function forkNode(node, deep = true) {
   cleanNodeComments(node);
   return newNode;
 }
-function replaceNode(path9, target, source) {
+function replaceNode(path8, target, source) {
   const { start, end, loc, leadingComments, innerComments, trailingComments } = source;
   target.start = start;
   target.end = end;
@@ -1717,7 +1717,7 @@ function replaceNode(path9, target, source) {
   target.trailingComments = trailingComments;
   cleanNodeLoc(source);
   cleanNodeComments(source);
-  path9.replaceWith(target);
+  path8.replaceWith(target);
 }
 function cleanNodeLoc(node) {
   node.start = null;
@@ -1731,8 +1731,8 @@ function cleanNodeComments(node) {
 }
 
 // src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-declared-options.ts
-function resolveDeclaredOptions(path9, ctx) {
-  const { node } = path9;
+function resolveDeclaredOptions(path8, ctx) {
+  const { node } = path8;
   const { filename, scriptData } = ctx;
   if (!isCalleeNamed(node, MACRO_API_NAMES.options)) {
     return;
@@ -1854,11 +1854,11 @@ function resolveStaticName(key) {
   }
   return null;
 }
-function resolveLocalTypeFromReference(path9, typeRef, ctx, macroName, visitedTypeRefs, warnedImportedTypeRefs) {
+function resolveLocalTypeFromReference(path8, typeRef, ctx, macroName, visitedTypeRefs, warnedImportedTypeRefs) {
   const refName = resolveTypeReferenceName(typeRef.typeName);
   if (!refName) return null;
   if (visitedTypeRefs.has(refName)) return null;
-  const binding = path9.scope.getBinding(refName);
+  const binding = path8.scope.getBinding(refName);
   if (binding) {
     if (binding.path.isImportSpecifier() || binding.path.isImportDefaultSpecifier() || binding.path.isImportNamespaceSpecifier()) {
       const key = `${macroName}:${refName}`;
@@ -1869,7 +1869,7 @@ function resolveLocalTypeFromReference(path9, typeRef, ctx, macroName, visitedTy
           {
             file: ctx.filename,
             source: ctx.source,
-            loc: typeRef.loc || path9.node.loc
+            loc: typeRef.loc || path8.node.loc
           }
         );
       }
@@ -1883,7 +1883,7 @@ function resolveLocalTypeFromReference(path9, typeRef, ctx, macroName, visitedTy
       return binding.path.node.typeAnnotation;
     }
   }
-  const programPath = path9.findParent((p) => p.isProgram());
+  const programPath = path8.findParent((p) => p.isProgram());
   if (!programPath?.isProgram()) {
     return null;
   }
@@ -1902,7 +1902,7 @@ function resolveLocalTypeFromReference(path9, typeRef, ctx, macroName, visitedTy
         {
           file: ctx.filename,
           source: ctx.source,
-          loc: typeRef.loc || path9.node.loc
+          loc: typeRef.loc || path8.node.loc
         }
       );
     }
@@ -1959,8 +1959,8 @@ function resolveImportedTypeSourceInProgram(body, typeName) {
 }
 
 // src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-declared-props-emits/resolve-declared-emits.ts
-function resolveDeclaredEmits(path9, ctx) {
-  const { node } = path9;
+function resolveDeclaredEmits(path8, ctx) {
+  const { node } = path8;
   const { templateData, scriptData } = ctx;
   if (!isCalleeNamed(node, MACRO_API_NAMES.emits)) {
     return;
@@ -1971,28 +1971,28 @@ function resolveDeclaredEmits(path9, ctx) {
     mergeNames(templateData.declaredEmits, resolveObjectOrArrayLiteralNames(initValue));
     return;
   }
-  const namesFromType = resolveDeclaredEmitsFromTypeParams(tsTypeDef, path9, ctx);
+  const namesFromType = resolveDeclaredEmitsFromTypeParams(tsTypeDef, path8, ctx);
   if (namesFromType.size) {
     mergeNames(templateData.declaredEmits, namesFromType);
     return;
   }
   mergeNames(templateData.declaredEmits, resolveObjectOrArrayLiteralNames(initValue));
 }
-function resolveDeclaredEmitsFromTypeParams(typeParams, path9, ctx) {
+function resolveDeclaredEmitsFromTypeParams(typeParams, path8, ctx) {
   const names = /* @__PURE__ */ new Set();
   const visitedTypeRefs = /* @__PURE__ */ new Set();
   const warnedImportedTypeRefs = /* @__PURE__ */ new Set();
   for (const tsType of resolveTsTypes(typeParams)) {
-    collectEmitsFromTsType(tsType, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs);
+    collectEmitsFromTsType(tsType, names, path8, ctx, visitedTypeRefs, warnedImportedTypeRefs);
   }
   return names;
 }
-function collectEmitsFromTsType(tsType, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs) {
+function collectEmitsFromTsType(tsType, names, path8, ctx, visitedTypeRefs, warnedImportedTypeRefs) {
   if (t18.isTSParenthesizedType(tsType)) {
     collectEmitsFromTsType(
       tsType.typeAnnotation,
       names,
-      path9,
+      path8,
       ctx,
       visitedTypeRefs,
       warnedImportedTypeRefs
@@ -2001,17 +2001,17 @@ function collectEmitsFromTsType(tsType, names, path9, ctx, visitedTypeRefs, warn
   }
   if (t18.isTSIntersectionType(tsType) || t18.isTSUnionType(tsType)) {
     for (const type of tsType.types) {
-      collectEmitsFromTsType(type, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs);
+      collectEmitsFromTsType(type, names, path8, ctx, visitedTypeRefs, warnedImportedTypeRefs);
     }
     return;
   }
   if (t18.isTSTypeReference(tsType)) {
     const innerTypes = tsType.typeParameters?.params || [];
     for (const type of innerTypes) {
-      collectEmitsFromTsType(type, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs);
+      collectEmitsFromTsType(type, names, path8, ctx, visitedTypeRefs, warnedImportedTypeRefs);
     }
     const localType = resolveLocalTypeFromReference(
-      path9,
+      path8,
       tsType,
       ctx,
       MACRO_API_NAMES.emits,
@@ -2019,7 +2019,7 @@ function collectEmitsFromTsType(tsType, names, path9, ctx, visitedTypeRefs, warn
       warnedImportedTypeRefs
     );
     if (localType) {
-      collectEmitsFromTsType(localType, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs);
+      collectEmitsFromTsType(localType, names, path8, ctx, visitedTypeRefs, warnedImportedTypeRefs);
     }
     return;
   }
@@ -2095,8 +2095,8 @@ function resolveStringLiteralTypeNames(type) {
 
 // src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-declared-props-emits/resolve-declared-props.ts
 import * as t19 from "@babel/types";
-function resolveDeclaredProps(path9, ctx) {
-  const { node } = path9;
+function resolveDeclaredProps(path8, ctx) {
+  const { node } = path8;
   const { templateData, scriptData } = ctx;
   if (!isCalleeNamed(node, MACRO_API_NAMES.props)) {
     return;
@@ -2107,28 +2107,28 @@ function resolveDeclaredProps(path9, ctx) {
     mergeNames(templateData.declaredProps, resolveObjectOrArrayLiteralNames(initValue));
     return;
   }
-  const namesFromType = resolveDeclaredPropsFromTypeParams(tsTypeDef, path9, ctx);
+  const namesFromType = resolveDeclaredPropsFromTypeParams(tsTypeDef, path8, ctx);
   if (namesFromType.size) {
     mergeNames(templateData.declaredProps, namesFromType);
     return;
   }
   mergeNames(templateData.declaredProps, resolveObjectOrArrayLiteralNames(initValue));
 }
-function resolveDeclaredPropsFromTypeParams(typeParams, path9, ctx) {
+function resolveDeclaredPropsFromTypeParams(typeParams, path8, ctx) {
   const names = /* @__PURE__ */ new Set();
   const visitedTypeRefs = /* @__PURE__ */ new Set();
   const warnedImportedTypeRefs = /* @__PURE__ */ new Set();
   for (const tsType of resolveTsTypes(typeParams)) {
-    collectPropsFromTsType(tsType, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs);
+    collectPropsFromTsType(tsType, names, path8, ctx, visitedTypeRefs, warnedImportedTypeRefs);
   }
   return names;
 }
-function collectPropsFromTsType(tsType, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs) {
+function collectPropsFromTsType(tsType, names, path8, ctx, visitedTypeRefs, warnedImportedTypeRefs) {
   if (t19.isTSParenthesizedType(tsType)) {
     collectPropsFromTsType(
       tsType.typeAnnotation,
       names,
-      path9,
+      path8,
       ctx,
       visitedTypeRefs,
       warnedImportedTypeRefs
@@ -2137,17 +2137,17 @@ function collectPropsFromTsType(tsType, names, path9, ctx, visitedTypeRefs, warn
   }
   if (t19.isTSIntersectionType(tsType) || t19.isTSUnionType(tsType)) {
     for (const type of tsType.types) {
-      collectPropsFromTsType(type, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs);
+      collectPropsFromTsType(type, names, path8, ctx, visitedTypeRefs, warnedImportedTypeRefs);
     }
     return;
   }
   if (t19.isTSTypeReference(tsType)) {
     const innerTypes = tsType.typeParameters?.params || [];
     for (const type of innerTypes) {
-      collectPropsFromTsType(type, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs);
+      collectPropsFromTsType(type, names, path8, ctx, visitedTypeRefs, warnedImportedTypeRefs);
     }
     const localType = resolveLocalTypeFromReference(
-      path9,
+      path8,
       tsType,
       ctx,
       MACRO_API_NAMES.props,
@@ -2155,7 +2155,7 @@ function collectPropsFromTsType(tsType, names, path9, ctx, visitedTypeRefs, warn
       warnedImportedTypeRefs
     );
     if (localType) {
-      collectPropsFromTsType(localType, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs);
+      collectPropsFromTsType(localType, names, path8, ctx, visitedTypeRefs, warnedImportedTypeRefs);
     }
     return;
   }
@@ -2174,15 +2174,15 @@ function collectPropsFromTsType(tsType, names, path9, ctx, visitedTypeRefs, warn
 }
 
 // src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-declared-props-emits/index.ts
-function resolveDeclaredPropsAndEmits(path9, ctx) {
-  resolveDeclaredProps(path9, ctx);
-  resolveDeclaredEmits(path9, ctx);
+function resolveDeclaredPropsAndEmits(path8, ctx) {
+  resolveDeclaredProps(path8, ctx);
+  resolveDeclaredEmits(path8, ctx);
 }
 
 // src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-use-attrs-exists.ts
 import * as t20 from "@babel/types";
-function resolveUseAttrsExists(path9, ctx) {
-  const { node } = path9;
+function resolveUseAttrsExists(path8, ctx) {
+  const { node } = path8;
   const { templateData, scriptData } = ctx;
   if (!isCalleeNamed(node, VUE_API_MAP.useAttrs)) {
     return;
@@ -2191,7 +2191,7 @@ function resolveUseAttrsExists(path9, ctx) {
     return;
   }
   scriptData.hasUseAttrsCall = true;
-  const parent = path9.parentPath?.node;
+  const parent = path8.parentPath?.node;
   if (parent && t20.isVariableDeclarator(parent) && t20.isIdentifier(parent.id)) {
     templateData.declaredAttrs = parent.id.name;
   }
@@ -2356,16 +2356,16 @@ function resolveScriptMeta(result, ctx) {
     return;
   }
   traverse(scriptAst, {
-    VariableDeclarator(path9) {
-      if (!atComponentOrHookRoot(path9, scriptAst.program)) {
+    VariableDeclarator(path8) {
+      if (!atComponentOrHookRoot(path8, scriptAst.program)) {
         return;
       }
-      resolveVarBindings(path9.node, ctx);
+      resolveVarBindings(path8.node, ctx);
     },
-    CallExpression(path9) {
-      resolveDeclaredOptions(path9, ctx);
-      resolveDeclaredPropsAndEmits(path9, ctx);
-      resolveUseAttrsExists(path9, ctx);
+    CallExpression(path8) {
+      resolveDeclaredOptions(path8, ctx);
+      resolveDeclaredPropsAndEmits(path8, ctx);
+      resolveUseAttrsExists(path8, ctx);
     }
   });
 }
@@ -2877,25 +2877,25 @@ import { parse as babelParse3 } from "@babel/parser";
 import { traverse as traverse3 } from "@babel/core";
 
 // src/core/transform/sfc/script/syntax-processor/postprocess/resolve-ast-chunks/resolve-global-type-chunk.ts
-function resolveGlobalTypeChunks(path9, ir) {
-  if (!path9.parentPath?.isProgram()) {
+function resolveGlobalTypeChunks(path8, ir) {
+  if (!path8.parentPath?.isProgram()) {
     return;
   }
-  const forked = forkNode(path9.node);
+  const forked = forkNode(path8.node);
   ir.tsTypes.push(forked);
-  path9.remove();
+  path8.remove();
 }
 
 // src/core/transform/sfc/script/syntax-processor/postprocess/resolve-ast-chunks/resolve-module-chunk.ts
 import * as t22 from "@babel/types";
-function resolveModuleChunks(path9, ir) {
-  const forked = forkNode(path9.node);
+function resolveModuleChunks(path8, ir) {
+  const forked = forkNode(path8.node);
   if (t22.isImportDeclaration(forked)) {
     ir.imports.push(forked);
   } else if (t22.isExportDeclaration(forked)) {
     ir.exports.push(forked);
   }
-  path9.remove();
+  path8.remove();
 }
 
 // src/core/transform/sfc/script/shared/metadata-utils.ts
@@ -2915,10 +2915,10 @@ function setScriptNodeMeta(node, opts) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/postprocess/resolve-ast-chunks/resolve-static-const-chunk.ts
-function resolveStaticConstChunks(path9, ir) {
-  const { node, parentPath } = path9;
+function resolveStaticConstChunks(path8, ir) {
+  const { node, parentPath } = path8;
   const parent = parentPath.node;
-  if (!isVariableDeclTopLevel(path9) || !parentPath.isVariableDeclaration() || parent.kind !== "const" || !isSimpleLiteral(node.init) || getScriptNodeMeta(node)) {
+  if (!isVariableDeclTopLevel(path8) || !parentPath.isVariableDeclaration() || parent.kind !== "const" || !isSimpleLiteral(node.init) || getScriptNodeMeta(node)) {
     return;
   }
   const forked = forkNode(parent);
@@ -2935,16 +2935,16 @@ function resolveASTChunks(ctx, ast) {
   scriptIR.statement.local = ast;
   return {
     // 提取 import/export
-    "ImportDeclaration|ExportDeclaration"(path9) {
-      resolveModuleChunks(path9, scriptIR);
+    "ImportDeclaration|ExportDeclaration"(path8) {
+      resolveModuleChunks(path8, scriptIR);
     },
     // 提取全局类型声明
-    "TSInterfaceDeclaration|TSTypeAliasDeclaration|TSEnumDeclaration|TSModuleDeclaration|TSModuleDeclaration"(path9) {
-      resolveGlobalTypeChunks(path9, scriptIR);
+    "TSInterfaceDeclaration|TSTypeAliasDeclaration|TSEnumDeclaration|TSModuleDeclaration|TSModuleDeclaration"(path8) {
+      resolveGlobalTypeChunks(path8, scriptIR);
     },
     // 提升顶层常量声明
-    VariableDeclarator(path9) {
-      resolveStaticConstChunks(path9, scriptIR);
+    VariableDeclarator(path8) {
+      resolveStaticConstChunks(path8, scriptIR);
     }
   };
 }
@@ -3030,11 +3030,11 @@ var StyleFileStrategy = class {
   matches(moduleName) {
     return this.regExp.test(moduleName);
   }
-  process(path9, ctx) {
+  process(path8, ctx) {
     if (!ctx.preprocessStyles) {
       return {};
     }
-    const importSource = path9.node.source.value;
+    const importSource = path8.node.source.value;
     if (typeof importSource !== "string") {
       return {};
     }
@@ -3079,25 +3079,25 @@ function resolveRuntimeImports(ctx) {
   const processedModules = /* @__PURE__ */ new Set();
   let hasImports = false;
   return {
-    ImportDeclaration(path9) {
-      const { node } = path9;
+    ImportDeclaration(path8) {
+      const { node } = path8;
       const originalModuleName = node.source.value.toLowerCase();
       const strategy = strategyManager.findStrategy(originalModuleName);
       let strategyResult = null;
       if (strategy) {
-        strategyResult = strategy.process(path9, ctx, originalModuleName);
+        strategyResult = strategy.process(path8, ctx, originalModuleName);
         if (strategyResult.shouldReplaceSource && strategyResult.newSource) {
           node.source.value = strategyResult.newSource;
         }
-        if (strategyResult.shouldRemove && !path9.removed) {
-          path9.remove();
+        if (strategyResult.shouldRemove && !path8.removed) {
+          path8.remove();
           return;
         }
       }
       replaceVueSuffix(node.source);
       const finalModuleName = node.source.value.toLowerCase();
-      if (processedModules.has(finalModuleName) && !path9.removed) {
-        path9.remove();
+      if (processedModules.has(finalModuleName) && !path8.removed) {
+        path8.remove();
         return;
       }
       processedModules.add(finalModuleName);
@@ -3106,12 +3106,12 @@ function resolveRuntimeImports(ctx) {
         const importNodes = createImportNodes(ctx);
         if (importNodes.length) {
           if (strategyResult?.shouldInjectRuntimeImports) {
-            path9.insertAfter(importNodes);
+            path8.insertAfter(importNodes);
           } else if (finalModuleName === PACKAGE_NAME.react) {
-            path9.insertAfter(importNodes);
+            path8.insertAfter(importNodes);
           } else {
             forkFilePreambleLeadingComments(importNodes[0], node);
-            path9.insertBefore(importNodes);
+            path8.insertBefore(importNodes);
           }
         }
         hasImports = true;
@@ -3119,14 +3119,14 @@ function resolveRuntimeImports(ctx) {
     },
     // 兜底：无 ImportDeclaration 的文件也要能注入必需依赖。
     Program: {
-      exit(path9) {
+      exit(path8) {
         if (hasImports) return;
         hasImports = true;
-        const { node } = path9;
+        const { node } = path8;
         const importNodes = createImportNodes(ctx);
         if (!importNodes.length) return;
         forkProgramTopLeadingComments(importNodes[0], node);
-        path9.unshiftContainer("body", importNodes);
+        path8.unshiftContainer("body", importNodes);
       }
     }
   };
@@ -3227,8 +3227,8 @@ function resolveSfcCssImport(ctx) {
 import * as t25 from "@babel/types";
 function resolveDefineAsyncComponent(ctx) {
   return {
-    CallExpression(path9) {
-      const { node } = path9;
+    CallExpression(path8) {
+      const { node } = path8;
       if (!isCalleeNamed(node, VUE_API_MAP.defineAsyncComponent)) {
         return;
       }
@@ -3276,15 +3276,15 @@ function createUseImperativeHandle(refId, init) {
 function resolveDefineExpose(ctx) {
   if (ctx.inputType !== "sfc") return {};
   return {
-    CallExpression(path9) {
-      const { node } = path9;
+    CallExpression(path8) {
+      const { node } = path8;
       const { filename, scriptData } = ctx;
       if (!isCalleeNamed(node, MACRO_API_NAMES.expose)) {
         return;
       }
       const [expose] = node.arguments;
       if (!expose) {
-        path9.remove();
+        path8.remove();
         return;
       }
       const adapter = ADAPTER_RULES.react[MACRO_API_NAMES.expose];
@@ -3301,7 +3301,7 @@ function resolveDefineExpose(ctx) {
       const { forwardRef } = scriptData;
       const newNode = createUseImperativeHandle(t27.identifier(forwardRef.refField), init);
       forwardRef.enabled = true;
-      replaceNode(path9, newNode, node);
+      replaceNode(path8, newNode, node);
     }
   };
 }
@@ -3309,12 +3309,12 @@ function resolveDefineExpose(ctx) {
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-options.ts
 function resolveDefineOptions(ctx) {
   return {
-    CallExpression(path9) {
-      const { node } = path9;
+    CallExpression(path8) {
+      const { node } = path8;
       if (!isCalleeNamed(node, MACRO_API_NAMES.options)) {
         return;
       }
-      path9.remove();
+      path8.remove();
     }
   };
 }
@@ -3331,8 +3331,8 @@ function resolveEmitCalls(ctx) {
     return `on${capitalize(camelCase(normalized))}`;
   };
   return {
-    CallExpression(path9) {
-      const { node } = path9;
+    CallExpression(path8) {
+      const { node } = path8;
       const { filename, templateData, scriptData } = ctx;
       if (!t28.isIdentifier(node.callee)) return;
       const { name } = node.callee;
@@ -3343,7 +3343,7 @@ function resolveEmitCalls(ctx) {
           result = meta.source === MACRO_API_NAMES.emits;
         }
         if (!result) {
-          const binding = path9.scope.getBinding(name);
+          const binding = path8.scope.getBinding(name);
           if (binding) {
             const parent = binding.path.node;
             if (t28.isVariableDeclarator(parent) && t28.isCallExpression(parent.init) && t28.isIdentifier(parent.init.callee)) {
@@ -3370,7 +3370,7 @@ function resolveEmitCalls(ctx) {
           }
         );
       }
-      replaceNode(path9, propCall, node);
+      replaceNode(path8, propCall, node);
     }
   };
 }
@@ -3415,9 +3415,9 @@ function cloneCallableParams(params) {
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-emits.ts
 function resolveEmitsTopLevelTypes(ctx) {
   return {
-    "TSInterfaceDeclaration|TSTypeAliasDeclaration"(path9) {
-      if (!t30.isProgram(path9.parent)) return;
-      const { node } = path9;
+    "TSInterfaceDeclaration|TSTypeAliasDeclaration"(path8) {
+      if (!t30.isProgram(path8.parent)) return;
+      const { node } = path8;
       if (t30.isTSInterfaceDeclaration(node)) {
         const typeLiteral = t30.tsTypeLiteral(node.body.body);
         if (!hasEmitsSignatureInType(typeLiteral)) return;
@@ -3482,8 +3482,8 @@ function resolveTopLevelEmitType(tsType) {
   }
   return tsType;
 }
-function resolveDefineEmitsIface(path9, ctx) {
-  const { node } = path9;
+function resolveDefineEmitsIface(path8, ctx) {
+  const { node } = path8;
   const [runtimeArg] = node.arguments;
   const tsParams = node.typeParameters?.params;
   if (tsParams?.length) {
@@ -3783,8 +3783,8 @@ function resolveTupleElementParam(element, index) {
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-props.ts
 import * as t31 from "@babel/types";
-function resolveDefinePropsIface(path9, ctx) {
-  const { node } = path9;
+function resolveDefinePropsIface(path8, ctx) {
+  const { node } = path8;
   const [runtimeArg] = node.arguments;
   const tsParams = node.typeParameters?.params;
   if (tsParams?.length) {
@@ -3972,9 +3972,9 @@ function recordReactNode(ctx) {
   }
   recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.ReactNode);
 }
-function collectLocalTypeDeclarations(path9) {
+function collectLocalTypeDeclarations(path8) {
   const declarations = /* @__PURE__ */ new Map();
-  const programPath = path9.findParent(
+  const programPath = path8.findParent(
     (parentPath) => parentPath.isProgram()
   );
   if (!programPath) {
@@ -4244,14 +4244,14 @@ function resolveSlotPropFromMember(member) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/define-slots.ts
-function resolveDefineSlotsIface(path9, ctx) {
-  const { node } = path9;
+function resolveDefineSlotsIface(path8, ctx) {
+  const { node } = path8;
   const tsParams = node.typeParameters?.params;
   if (!tsParams?.length) return;
   const {
     propsTSIface: { slotTypes }
   } = ctx.scriptData;
-  const localTypeDeclarations = collectLocalTypeDeclarations(path9);
+  const localTypeDeclarations = collectLocalTypeDeclarations(path8);
   let shouldRecordReactNode = false;
   for (const tsType of tsParams) {
     const { type: resolved, shouldRecordReactNode: needsReactNode } = resolveSlotType(tsType, {
@@ -4295,8 +4295,8 @@ function resolveTemplateSlotIface(ctx) {
 function resolvePropsIface(ctx) {
   const isTS = ctx.scriptData.lang.startsWith("ts");
   return {
-    CallExpression(path9) {
-      const { node, parentPath } = path9;
+    CallExpression(path8) {
+      const { node, parentPath } = path8;
       const name = node.callee.name;
       if (!isCalleeNamed(node, MACRO_API_NAMES.props) && !isCalleeNamed(node, MACRO_API_NAMES.emits) && !isCalleeNamed(node, MACRO_API_NAMES.slots)) {
         return;
@@ -4305,7 +4305,7 @@ function resolvePropsIface(ctx) {
         if (parentPath.isVariableDeclaration() || parentPath.isVariableDeclarator()) {
           parentPath.remove();
         } else {
-          path9.remove();
+          path8.remove();
         }
       };
       if (ctx.inputType !== "sfc") {
@@ -4319,11 +4319,11 @@ function resolvePropsIface(ctx) {
         propsTSIface.hasPropsInJsEnv = true;
       } else {
         if (name === MACRO_API_NAMES.props) {
-          resolveDefinePropsIface(path9, ctx);
+          resolveDefinePropsIface(path8, ctx);
         } else if (name === MACRO_API_NAMES.emits) {
-          resolveDefineEmitsIface(path9, ctx);
+          resolveDefineEmitsIface(path8, ctx);
         } else if (name === MACRO_API_NAMES.slots) {
-          resolveDefineSlotsIface(path9, ctx);
+          resolveDefineSlotsIface(path8, ctx);
         }
       }
       removePath();
@@ -4352,10 +4352,10 @@ function resolveCompIProps(ctx, ast) {
 import * as t37 from "@babel/types";
 function resolveUseAttrs(ctx) {
   return {
-    VariableDeclarator(path9) {
-      const { init, id } = path9.node;
+    VariableDeclarator(path8) {
+      const { init, id } = path8.node;
       if (!init) return;
-      const initPath = path9.get("init");
+      const initPath = path8.get("init");
       const propsIdentifier = t37.identifier(ctx.propField);
       if (t37.isTSAsExpression(init) && isUseAttrsCall(init.expression)) {
         const typeAssertion = createPropsTypeAssertion(propsIdentifier, init.typeAnnotation);
@@ -4486,19 +4486,19 @@ function getDependencyKey(exp) {
 
 // src/core/transform/sfc/script/shared/dependency-analyzer/dep-normalizer.ts
 import * as t40 from "@babel/types";
-function normalizeDependencyExpr(path9, rootName, ctx) {
-  if (t40.isIdentifier(path9.node)) {
-    return t40.identifier(path9.node.name);
+function normalizeDependencyExpr(path8, rootName, ctx) {
+  if (t40.isIdentifier(path8.node)) {
+    return t40.identifier(path8.node.name);
   }
-  if (t40.isMemberExpression(path9.node) || t40.isOptionalMemberExpression(path9.node)) {
+  if (t40.isMemberExpression(path8.node) || t40.isOptionalMemberExpression(path8.node)) {
     if (rootName === ctx.propField) {
-      const safePropsExp = ensureOptionalForMemberChain(path9.node);
+      const safePropsExp = ensureOptionalForMemberChain(path8.node);
       if (isReactValidDependencyExpr(safePropsExp)) {
         return t40.cloneNode(safePropsExp, true);
       }
       return t40.identifier(rootName);
     }
-    const normalizedExp = normalizeMemberForCallSite(path9, path9.node);
+    const normalizedExp = normalizeMemberForCallSite(path8, path8.node);
     const safeExp = t40.isMemberExpression(normalizedExp) || t40.isOptionalMemberExpression(normalizedExp) ? ensureOptionalForMemberChain(normalizedExp) : normalizedExp;
     if (isReactValidDependencyExpr(safeExp)) {
       return t40.cloneNode(safeExp, true);
@@ -4522,8 +4522,8 @@ function normalizeSourcedDependency(exp) {
   }
   return null;
 }
-function normalizeMemberForCallSite(path9, node) {
-  const parent = path9.parentPath;
+function normalizeMemberForCallSite(path8, node) {
+  const parent = path8.parentPath;
   const isDirectCallee = !!parent && (parent.isCallExpression() && parent.node.callee === node || parent.isOptionalCallExpression() && parent.node.callee === node);
   if (!isDirectCallee) {
     return node;
@@ -4550,11 +4550,11 @@ function hasTrailingMemberAccess(node) {
 
 // src/core/transform/sfc/script/shared/dependency-analyzer/shared-utils.ts
 var TRACE_MAX_DEPTH = 20;
-function isNestedMemberObject(path9) {
-  const parent = path9.parentPath;
+function isNestedMemberObject(path8) {
+  const parent = path8.parentPath;
   if (!parent) return false;
   if (parent.isMemberExpression() || parent.isOptionalMemberExpression()) {
-    return parent.node.object === path9.node;
+    return parent.node.object === path8.node;
   }
   return false;
 }
@@ -4657,11 +4657,11 @@ function analyzeDeps(node, ctx, parentPath) {
     analyzeTarget,
     {
       "MemberExpression|OptionalMemberExpression"(memberPath) {
-        const path9 = memberPath;
-        if (isNestedMemberObject(path9)) return;
-        const rootId = findRootIdentifier(path9.node);
+        const path8 = memberPath;
+        if (isNestedMemberObject(path8)) return;
+        const rootId = findRootIdentifier(path8.node);
         if (!rootId) return;
-        tryAddDependency(path9, rootId.name, path9.scope);
+        tryAddDependency(path8, rootId.name, path8.scope);
         processedIdentifiers.add(rootId);
       },
       Identifier(idPath) {
@@ -4707,18 +4707,18 @@ function analyzeDeps(node, ctx, parentPath) {
 // src/core/transform/sfc/script/syntax-processor/process/resolve-analysis-only-adapter.ts
 function resolveAnalysisOnlyAdapter(ctx) {
   return {
-    "CallExpression|Identifier"(path9) {
-      const node = path9.node;
+    "CallExpression|Identifier"(path8) {
+      const node = path8.node;
       const apiName = getApiName(node);
       const adapter = ADAPTER_RULES.runtime[apiName];
       if (!adapter || adapter.type !== "analyzed-deps") {
         return;
       }
-      if (!isVueApiReference(path9, apiName)) {
+      if (!isVueApiReference(path8, apiName)) {
         return;
       }
       if (t43.isCallExpression(node)) {
-        resolveCallNode(path9, adapter, ctx);
+        resolveCallNode(path8, adapter, ctx);
       } else {
         replaceIdName(node, adapter.target);
       }
@@ -4736,35 +4736,35 @@ function getApiName(node) {
   }
   return apiName;
 }
-function resolveCallNode(path9, adapter, ctx) {
-  const { node } = path9;
+function resolveCallNode(path8, adapter, ctx) {
+  const { node } = path8;
   const { arguments: args } = node;
   if (!args.length) return;
   const fn = args[0];
   if (!t43.isArrowFunctionExpression(fn) && !t43.isFunctionExpression(fn)) {
     return;
   }
-  const fnPath = path9.get("arguments")[0];
+  const fnPath = path8.get("arguments")[0];
   const deps = analyzeDeps(fn, ctx, fnPath);
   args.push(deps);
   replaceCallName(node, adapter.target);
   recordImport(ctx, adapter.package, adapter.target);
 }
-function isVueApiReference(path9, apiName) {
-  if (path9.isIdentifier()) {
-    if (path9.parentPath.isCallExpression() && path9.parentPath.node.callee === path9.node) {
+function isVueApiReference(path8, apiName) {
+  if (path8.isIdentifier()) {
+    if (path8.parentPath.isCallExpression() && path8.parentPath.node.callee === path8.node) {
       return false;
     }
-    if (!path9.isReferencedIdentifier()) {
+    if (!path8.isReferencedIdentifier()) {
       return false;
     }
   }
-  if (path9.isCallExpression()) {
-    const callee = path9.get("callee");
+  if (path8.isCallExpression()) {
+    const callee = path8.get("callee");
     if (!callee.isIdentifier()) return false;
     return isVueImportBinding(callee.scope.getBinding(apiName));
   }
-  return isVueImportBinding(path9.scope.getBinding(apiName));
+  return isVueImportBinding(path8.scope.getBinding(apiName));
 }
 function isVueImportBinding(binding) {
   if (!binding) return false;
@@ -4789,24 +4789,24 @@ function isVueImportBinding(binding) {
 // src/core/transform/sfc/script/syntax-processor/process/resolve-arrow-deps.ts
 function resolveArrowFnDeps(ctx, ast) {
   return {
-    ArrowFunctionExpression(path9) {
-      const { node, parentPath } = path9;
-      if (isSkip(path9) || !atComponentOrHookRoot(parentPath, ast.program)) {
+    ArrowFunctionExpression(path8) {
+      const { node, parentPath } = path8;
+      if (isSkip(path8) || !atComponentOrHookRoot(parentPath, ast.program)) {
         return;
       }
-      const deps = analyzeDeps(node, ctx, path9);
+      const deps = analyzeDeps(node, ctx, path8);
       if (!deps.elements.length) return;
       const newNode = createUseCallback(node, deps);
-      const declaratorPath = getVariableDeclaratorPath(path9);
+      const declaratorPath = getVariableDeclaratorPath(path8);
       recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.useCallback);
       setScriptNodeMeta(declaratorPath?.node, { is_reactive: true, reactive_type: "indirect" });
-      replaceNode(path9, newNode, node);
+      replaceNode(path8, newNode, node);
     }
   };
 }
-function isSkip(path9) {
-  const { parentPath } = path9;
-  const isVariableDecl = () => getVariableDeclaratorPath(path9) !== null;
+function isSkip(path8) {
+  const { parentPath } = path8;
+  const isVariableDecl = () => getVariableDeclaratorPath(path8) !== null;
   const isReturnFunc = () => !isVariableDecl() && parentPath.isReturnStatement();
   const isCallback = () => {
     if (!parentPath) {
@@ -4815,12 +4815,12 @@ function isSkip(path9) {
     if (parentPath.isCallExpression()) {
       const callExpressionPath = parentPath;
       const args = callExpressionPath.node.arguments;
-      return args.some((arg) => arg === path9.node);
+      return args.some((arg) => arg === path8.node);
     }
     if (parentPath.isArrayExpression()) {
       const arrayExpressionPath = parentPath;
       const elements = arrayExpressionPath.node.elements;
-      return elements.some((element) => element === path9.node);
+      return elements.some((element) => element === path8.node);
     }
     return false;
   };
@@ -4844,13 +4844,13 @@ function isSkip(path9) {
 import * as t44 from "@babel/types";
 function resolveElementRef(ctx) {
   return {
-    CallExpression(path9) {
+    CallExpression(path8) {
       const {
         inputType,
         templateData: { refBindings }
       } = ctx;
       if (inputType !== "sfc") return;
-      const { node } = path9;
+      const { node } = path8;
       const isUseTemplateRef = isCalleeNamed(node, VUE_API_MAP.useTemplateRef);
       const isCompRefBindings = Object.keys(refBindings.componentRefs).length > 0 && isCalleeNamed(node, VUE_API_MAP.ref);
       const shouldProcess = isUseTemplateRef || isCompRefBindings;
@@ -4858,7 +4858,7 @@ function resolveElementRef(ctx) {
         return;
       }
       if (isCompRefBindings) {
-        const varDeclaratorPath = getVariableDeclaratorPath(path9)?.node;
+        const varDeclaratorPath = getVariableDeclaratorPath(path8)?.node;
         if (!t44.isIdentifier(varDeclaratorPath?.id)) {
           return;
         }
@@ -4867,22 +4867,22 @@ function resolveElementRef(ctx) {
         if (!compRef) return;
       }
       node.arguments[0] = t44.identifier("null");
-      resolveTypeParameters(ctx, path9);
+      resolveTypeParameters(ctx, path8);
       replaceCallName(node, REACT_API_MAP.useRef);
       recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.useRef);
     },
-    MemberExpression(path9) {
-      resolveRefValueToCurrent(path9);
+    MemberExpression(path8) {
+      resolveRefValueToCurrent(path8);
     }
   };
 }
-function resolveTypeParameters(ctx, path9) {
+function resolveTypeParameters(ctx, path8) {
   const {
     templateData: { refBindings },
     scriptData
   } = ctx;
-  const { node } = path9;
-  const varDeclaratorNode = getVariableDeclaratorPath(path9)?.node;
+  const { node } = path8;
+  const varDeclaratorNode = getVariableDeclaratorPath(path8)?.node;
   if (!scriptData.lang.startsWith("ts") || !varDeclaratorNode) {
     return;
   }
@@ -4894,12 +4894,12 @@ function resolveTypeParameters(ctx, path9) {
     node.typeParameters = t44.tsTypeParameterInstantiation([t44.tsTypeReference(t44.identifier(type))]);
   }
 }
-function resolveRefValueToCurrent(path9) {
-  const { node } = path9;
+function resolveRefValueToCurrent(path8) {
+  const { node } = path8;
   if (node.computed || !t44.isIdentifier(node.property) || node.property.name !== "value") {
     return;
   }
-  const rootPath = findRootVariablePath(path9);
+  const rootPath = findRootVariablePath(path8);
   if (!rootPath?.node || !t44.isCallExpression(rootPath.node.init) || !isCalleeNamed(rootPath.node.init, REACT_API_MAP.useRef)) {
     return;
   }
@@ -4915,15 +4915,15 @@ import * as t45 from "@babel/types";
 function resolveExprMemo(ctx, ast) {
   const isScriptFile = ctx.inputType !== "sfc";
   return {
-    VariableDeclarator(path9) {
-      const { node } = path9;
+    VariableDeclarator(path8) {
+      const { node } = path8;
       const { init } = node;
       const shouldMemo = () => {
         if (!init) return false;
-        if (!atComponentOrHookRoot(path9, ast.program, isScriptFile)) {
+        if (!atComponentOrHookRoot(path8, ast.program, isScriptFile)) {
           return false;
         }
-        if (!t45.isVariableDeclaration(path9.parent) || path9.parent.kind !== "const") {
+        if (!t45.isVariableDeclaration(path8.parent) || path8.parent.kind !== "const") {
           return false;
         }
         if (t45.isFunction(init)) return false;
@@ -4933,7 +4933,7 @@ function resolveExprMemo(ctx, ast) {
         return true;
       };
       if (!shouldMemo()) return;
-      const initPath = path9.get("init");
+      const initPath = path8.get("init");
       if (!initPath.isExpression()) return;
       const deps = analyzeDeps(initPath.node, ctx, initPath);
       if (!deps.elements.length) return;
@@ -4950,8 +4950,8 @@ import * as t46 from "@babel/types";
 function resolveLintRules(ctx, ast) {
   const inScriptFile = ctx.inputType !== "sfc";
   return {
-    CallExpression(path9) {
-      const { node, parentPath } = path9;
+    CallExpression(path8) {
+      const { node, parentPath } = path8;
       if (!t46.isIdentifier(node.callee)) return;
       const { name: callName } = node.callee;
       const addLog = (t52) => {
@@ -4970,7 +4970,7 @@ function resolveLintRules(ctx, ast) {
           );
           return;
         }
-        if (!atComponentOrHookRoot(path9, ast.program)) {
+        if (!atComponentOrHookRoot(path8, ast.program)) {
           addLog(
             `The ${macro} must be defined at the top level of the component, not inside blocks or functions.`
           );
@@ -4986,7 +4986,7 @@ function resolveLintRules(ctx, ast) {
       };
       const lintHooks = () => {
         if (!callName.startsWith("use")) return;
-        if (!atComponentOrHookRoot(path9, ast.program, inScriptFile)) {
+        if (!atComponentOrHookRoot(path8, ast.program, inScriptFile)) {
           addLog(
             `The ${callName} hook must be called at the top level, not inside loops, conditions, or nested functions.`
           );
@@ -5004,8 +5004,8 @@ import * as t47 from "@babel/types";
 function resolveProvide(ctx) {
   if (ctx.inputType === "style") return {};
   return {
-    CallExpression(path9) {
-      const { node } = path9;
+    CallExpression(path8) {
+      const { node } = path8;
       const providerTarget = ADAPTER_RULES.runtime[VUE_API_MAP.provide]?.target;
       const isProvideCall = isCalleeNamed(node, VUE_API_MAP.provide) || providerTarget && isCalleeNamed(node, providerTarget);
       if (!isProvideCall) return;
@@ -5015,7 +5015,7 @@ function resolveProvide(ctx) {
       const adapter = ADAPTER_RULES.runtime[VUE_API_MAP.provide];
       assignProviderValue(target, key, value);
       recordImport(ctx, adapter.package, adapter.target);
-      path9.parentPath.remove();
+      path8.parentPath.remove();
     }
   };
 }
@@ -5057,8 +5057,8 @@ function assignProviderValue(target, key, value) {
 import * as t48 from "@babel/types";
 function resolveRenameAdapter(ctx) {
   return {
-    "CallExpression|Identifier"(path9) {
-      const node = path9.node;
+    "CallExpression|Identifier"(path8) {
+      const node = path8.node;
       const isCallNode = t48.isCallExpression(node);
       let apiName = "";
       if (t48.isIdentifier(node)) {
@@ -5075,12 +5075,12 @@ function resolveRenameAdapter(ctx) {
       if (!adapter || adapter.type !== "rename") {
         return;
       }
-      if (!isVueApiReference2(path9, apiName)) {
+      if (!isVueApiReference2(path8, apiName)) {
         return;
       }
       if (adapter.isTrackable) {
         const reactiveType = getReactiveType(apiName);
-        const declaratorPath = getVariableDeclaratorPath(path9);
+        const declaratorPath = getVariableDeclaratorPath(path8);
         setScriptNodeMeta(declaratorPath?.node, {
           is_reactive: true,
           reactive_type: reactiveType
@@ -5098,25 +5098,25 @@ function resolveRenameAdapter(ctx) {
     }
   };
 }
-function isVueApiReference2(path9, apiName) {
+function isVueApiReference2(path8, apiName) {
   const whitelist = [VUE_API_MAP.defineAsyncComponent];
   if (whitelist.includes(apiName)) {
     return true;
   }
-  if (path9.isIdentifier()) {
-    if (path9.parentPath.isCallExpression() && path9.parentPath.node.callee === path9.node) {
+  if (path8.isIdentifier()) {
+    if (path8.parentPath.isCallExpression() && path8.parentPath.node.callee === path8.node) {
       return false;
     }
-    if (!path9.isReferencedIdentifier()) {
+    if (!path8.isReferencedIdentifier()) {
       return false;
     }
   }
-  if (path9.isCallExpression()) {
-    const callee = path9.get("callee");
+  if (path8.isCallExpression()) {
+    const callee = path8.get("callee");
     if (!callee.isIdentifier()) return false;
     return isVueImportBinding2(callee.scope.getBinding(apiName));
   }
-  return isVueImportBinding2(path9.scope.getBinding(apiName));
+  return isVueImportBinding2(path8.scope.getBinding(apiName));
 }
 function isVueImportBinding2(binding) {
   if (!binding) return false;
@@ -6612,20 +6612,11 @@ function transform(ast, ctx, options) {
 }
 
 // package.json
-var version = "1.7.0";
+var version = "1.8.1";
 var bin = {
-  vureact: "./bin/vureact.js"
+  vureact: "bin/vureact.js"
 };
 
-// src/compiler/shared/types/cache-types.ts
-var CacheKey = /* @__PURE__ */ ((CacheKey2) => {
-  CacheKey2["SFC"] = "sfc";
-  CacheKey2["SCRIPT"] = "script";
-  CacheKey2["STYLE"] = "style";
-  CacheKey2["ASSET"] = "copied";
-  return CacheKey2;
-})(CacheKey || {});
-
 // src/plugins/prettier.ts
 async function formatWithPrettier(code, lang, opts) {
   try {
@@ -6826,13 +6817,6 @@ var Helper = class {
     const { input = "src" } = this.compilerOpts;
     return path3.resolve(this.getProjectRoot(), input);
   }
-  /**
-   * 检查 input 路径是否是单个文件
-   */
-  isSingleFile() {
-    const inputPath = this.getInputPath();
-    return fs2.existsSync(inputPath) && fs2.statSync(inputPath).isFile();
-  }
   /**
    * 获取输出文件的路径。如：'[root]/.vureact/dist/'
    * @param addInput 会输出如：'[root]/.vureact/dist/[input]/'
@@ -6891,6 +6875,13 @@ var Helper = class {
   getOutputPkgPath() {
     return path3.join(this.getOuputPath(), "package.json");
   }
+  /**
+   * 获取缓存文件路径
+   */
+  getCachePath() {
+    const filename = "_metadata";
+    return path3.resolve(this.getProjectRoot(), this.workspaceDir, "cache", `${filename}.json`);
+  }
   /**
    * 返回文件相对工作区的路径
    */
@@ -6988,95 +6979,15 @@ var Helper = class {
   }
   async rmFile(filePath) {
     try {
-      await fs2.promises.rm(filePath, { recursive: true, force: true });
-    } catch {
-    }
-  }
-  async loadCache(key) {
-    const cacheFile = this.getCachePath();
-    const defaultData = this.createCacheData(key);
-    if (!fs2.existsSync(cacheFile)) {
-      return defaultData;
-    }
-    try {
-      const content = await fs2.promises.readFile(cacheFile, "utf-8");
-      const data = JSON.parse(content);
-      return {
-        key,
-        target: data[key] || [],
-        source: data
-      };
-    } catch {
-      return defaultData;
-    }
-  }
-  createCacheData(key) {
-    return {
-      key,
-      target: [],
-      source: {
-        ["sfc" /* SFC */]: [],
-        ["script" /* SCRIPT */]: [],
-        ["style" /* STYLE */]: [],
-        ["copied" /* ASSET */]: []
+      if (fs2.existsSync(filePath)) {
+        await fs2.promises.rm(filePath, { recursive: true, force: true });
       }
-    };
-  }
-  /**
-   * 获取缓存文件路径
-   */
-  getCachePath() {
-    const filename = "_metadata";
-    return path3.resolve(this.getProjectRoot(), this.workspaceDir, "cache", `${filename}.json`);
-  }
-  async saveCache(data) {
-    if (!this.getIsCache() || !data) {
-      return;
+    } catch {
     }
-    const getDefaultValue = () => ({
-      ["sfc" /* SFC */]: [],
-      ["script" /* SCRIPT */]: [],
-      ["style" /* STYLE */]: [],
-      ["copied" /* ASSET */]: []
-    });
-    const cachePath = this.getCachePath();
-    await fileLock.updateFile(cachePath, (currentData) => {
-      const { key, target } = data;
-      const mergedData = currentData || getDefaultValue();
-      mergedData[key] = target;
-      return mergedData;
-    });
   }
   genHash(content) {
     return genHashByXXH(content);
   }
-  /**
-   * 扫描指定目录下的所有文件
-   * @param dir 目标目录
-   * @param filter 筛选指定的文件后缀名
-   */
-  scanFiles(dir, filter) {
-    const results = [];
-    if (!fs2.existsSync(dir)) {
-      return results;
-    }
-    const stats = fs2.statSync(dir);
-    if (stats.isFile()) {
-      return filter(dir) ? [dir] : [];
-    }
-    const list = fs2.readdirSync(dir);
-    for (const file of list) {
-      const fullPath = path3.resolve(dir, file);
-      if (this.shouldSkipPath(fullPath)) continue;
-      const stat = fs2.statSync(fullPath);
-      if (stat.isDirectory() && this.compilerOpts.recursive !== false) {
-        results.push(...this.scanFiles(fullPath, filter));
-      } else if (filter(fullPath)) {
-        results.push(fullPath);
-      }
-    }
-    return results;
-  }
   getAbsPath(filePath) {
     return path3.isAbsolute(filePath) ? filePath : path3.resolve(this.getProjectRoot(), filePath);
   }
@@ -7088,9 +6999,9 @@ var Helper = class {
     };
   }
   async removeOutputFile(filePath, resolveOutputPath) {
-    const path9 = resolveOutputPath ? this.resolveOutputPath(filePath) : filePath;
-    if (!fs2.existsSync(path9)) return;
-    await fs2.promises.unlink(path9);
+    const path8 = resolveOutputPath ? this.resolveOutputPath(filePath) : filePath;
+    if (!fs2.existsSync(path8)) return;
+    await fs2.promises.unlink(path8);
   }
   updateCache(targetFile, newData, cache) {
     const index = cache.target.findIndex((c) => c.file === targetFile);
@@ -7143,18 +7054,18 @@ var Helper = class {
   /**
    * 读取 package.json 文件内容，并处理成对象返回
    */
-  async resolvePackageFile(path9) {
-    if (!fs2.existsSync(path9)) {
+  async resolvePackageFile(path8) {
+    if (!fs2.existsSync(path8)) {
       return {};
     }
     try {
-      const content = await fs2.promises.readFile(path9, "utf-8");
+      const content = await fs2.promises.readFile(path8, "utf-8");
       if (!content.trim()) {
         return {};
       }
       return JSON.parse(content);
     } catch (error) {
-      console.error(kleur4.red("\u274C"), `Failed to parse JSON file ${path9}:
+      console.error(kleur4.red("\u274C"), `Failed to parse JSON file ${path8}:
 `, error);
       return {};
     }
@@ -7414,6 +7325,15 @@ var BaseCompiler = class extends Helper {
   }
 };
 
+// src/compiler/shared/types/cache-types.ts
+var CacheKey = /* @__PURE__ */ ((CacheKey2) => {
+  CacheKey2["SFC"] = "sfc";
+  CacheKey2["SCRIPT"] = "script";
+  CacheKey2["STYLE"] = "style";
+  CacheKey2["ASSET"] = "copied";
+  return CacheKey2;
+})(CacheKey || {});
+
 // src/utils/calc-elapsed-time.ts
 function calcElapsedTime(start) {
   const end = performance.now();
@@ -7436,9 +7356,10 @@ import ora2 from "ora";
 import fs3 from "fs";
 import path5 from "path";
 var AssetManager = class {
-  constructor(fileCompiler, cleanupManager) {
+  constructor(fileCompiler, cleanupManager, cacheManager) {
     this.fileCompiler = fileCompiler;
     this.cleanupManager = cleanupManager;
+    this.cacheManager = cacheManager;
   }
   // 需要经过管线编译处理的文件类型
   pipelineFiles = [".js", ".ts", ".less", ".scss", ".sass"];
@@ -7446,70 +7367,40 @@ var AssetManager = class {
   /**
    * 运行资源文件处理管线
    */
-  async runAssetPipeline() {
-    const { options } = this.fileCompiler;
-    const rootPath = this.fileCompiler.getProjectRoot();
-    const inputPath = this.fileCompiler.getInputPath();
-    const exclusions = this.fileCompiler.getIgnoreAssets();
-    const assetFiles = this.fileCompiler.scanFiles(rootPath, (p) => {
-      if (this.fileCompiler.shouldSkipPath(p)) return false;
-      const relativeToRoot = normalizePath(this.fileCompiler.relativePath(p));
-      const filename = path5.basename(p).toLowerCase();
-      const ext = path5.extname(p).toLowerCase();
-      if (!options.output?.ignoreAssets) {
-        const shouldExclude = Array.from(exclusions).some((pattern) => {
-          if (pattern.endsWith(".")) {
-            return filename.startsWith(pattern);
-          }
-          if (pattern.startsWith(".")) {
-            return ext === pattern;
-          }
-          return relativeToRoot === pattern || filename === pattern;
-        });
-        if (shouldExclude) return false;
-      } else if (exclusions.has(relativeToRoot) || exclusions.has(filename)) {
-        return false;
-      }
-      if (ext === ".vue") return false;
-      const isInsideSrc = p.startsWith(inputPath + path5.sep);
-      if (isInsideSrc && this.pipelineFiles.includes(ext)) {
-        return false;
-      }
-      return true;
-    });
-    const absFiles = new Set(assetFiles.map((f) => this.fileCompiler.getAbsPath(f)));
-    await this.cleanupManager.cleanupOldOutput("copied" /* ASSET */, (u) => !absFiles.has(u.file));
-    if (!assetFiles.length) return 0;
-    const cache = await this.fileCompiler.loadCache("copied" /* ASSET */);
-    const copied = await Promise.all(
-      assetFiles.map((file) => {
-        return this.processAsset(file, cache);
-      })
+  async runAsset(files, cacheMap) {
+    const absPaths = new Set(files.map((f) => this.fileCompiler.getAbsPath(f)));
+    const cache = cacheMap["copied" /* ASSET */];
+    await this.cleanupManager.removeMatchedFromCache(
+      "copied" /* ASSET */,
+      cache,
+      (u) => !absPaths.has(u.file)
     );
-    await this.fileCompiler.saveCache(cache);
+    if (!files.length) return 0;
+    const copied = await Promise.all(files.map((file) => this.processAsset(file, cache)));
     return copied.filter(Boolean).length;
   }
   /**
    * Process single asset file, compare with cache and decide whether to copy.
    */
   async processAsset(filePath, existingCache) {
-    const absPath = this.fileCompiler.getAbsPath(filePath);
+    const { fileCompiler, cacheManager } = this;
+    const absPath = fileCompiler.getAbsPath(filePath);
     const fileMeta = {
       file: absPath,
-      ...await this.fileCompiler.getFileMeta(absPath)
+      ...await fileCompiler.getFileMeta(absPath)
     };
-    const cache = (this.fileCompiler.getIsCache() ? existingCache : void 0) || await this.fileCompiler.loadCache("copied" /* ASSET */);
+    const cache = (fileCompiler.getIsCache() ? existingCache : void 0) || await cacheManager.loadCache("copied" /* ASSET */);
     const record = cache.target.find((f) => f.file === absPath);
-    if (record && this.fileCompiler.compareFileMeta(record, fileMeta)) {
+    if (record && fileCompiler.compareFileMeta(record, fileMeta)) {
       this.skippedCount++;
       return;
     }
-    const outputPath = this.fileCompiler.resolveOutputPath(absPath);
+    const outputPath = fileCompiler.resolveOutputPath(absPath);
     await fs3.promises.mkdir(path5.dirname(outputPath), { recursive: true });
     await fs3.promises.copyFile(absPath, outputPath);
     this.updateCache(absPath, fileMeta, cache);
-    if (this.fileCompiler.getIsCache() && !existingCache) {
-      await this.fileCompiler.saveCache(cache);
+    if (fileCompiler.getIsCache() && !existingCache) {
+      await cacheManager.saveCache(cache);
     }
     return fileMeta;
   }
@@ -7540,11 +7431,14 @@ var AssetManager = class {
 };
 
 // src/compiler/shared/file-compiler/cache-manager.ts
+import fs4 from "fs";
 var CacheManager = class {
   constructor(fileCompiler) {
     this.fileCompiler = fileCompiler;
   }
   pendingUpdates = /* @__PURE__ */ new Map();
+  /** 缓存文件仅读取一次，之后复用此副本 */
+  cachedData = null;
   /**
    * 批量更新缓存记录
    */
@@ -7566,94 +7460,200 @@ var CacheManager = class {
     this.pendingUpdates.get(key).push({ unit, meta });
   }
   /**
-   * 批量保存缓存
+   * 一次性刷新所有缓存（只写一次文件）
    */
-  async flushCache(key) {
-    if (!this.fileCompiler.getIsCache() || !this.pendingUpdates.has(key)) {
+  async flushAllCache() {
+    if (!this.fileCompiler.getIsCache()) {
       return;
     }
+    const keys = Object.values(CacheKey);
+    if (!this.cachedData) {
+      await this.loadAllCache();
+    }
+    for (const key of keys) {
+      const updates = this.pendingUpdates.get(key);
+      if (!updates?.length) continue;
+      const entries = [...this.cachedData[key] || []];
+      updates.forEach(({ unit, meta }) => {
+        const idx = entries.findIndex((c) => c.file === unit.file);
+        if (idx > -1) {
+          entries[idx] = meta;
+        } else {
+          entries.push(meta);
+        }
+      });
+      this.cachedData[key] = entries;
+      this.pendingUpdates.set(key, []);
+    }
+    await fileLock.updateFile(this.fileCompiler.getCachePath(), () => this.cachedData);
+  }
+  /**
+   * 一次性加载所有缓存（只读一次文件）
+   */
+  async loadAllCache() {
+    const filePath = this.fileCompiler.getCachePath();
+    const result = {};
+    let raw = null;
+    if (fs4.existsSync(filePath)) {
+      try {
+        const content = await fs4.promises.readFile(filePath, "utf-8");
+        raw = JSON.parse(content);
+      } catch {
+      }
+    }
+    this.cachedData = raw || this.getEmptyList();
+    const keys = Object.values(CacheKey);
+    for (const key of keys) {
+      result[key] = this.buildLoadedCache(key, raw);
+    }
+    return result;
+  }
+  /**
+   * 加载指定类型的缓存（watch 等场景使用）
+   */
+  async loadCache(key) {
+    if (this.cachedData) {
+      return this.buildLoadedCache(key, this.cachedData);
+    }
+    const filePath = this.fileCompiler.getCachePath();
+    if (fs4.existsSync(filePath)) {
+      try {
+        const content = await fs4.promises.readFile(filePath, "utf-8");
+        const data = JSON.parse(content);
+        return this.buildLoadedCache(key, data);
+      } catch {
+      }
+    }
+    return this.buildLoadedCache(key, null);
+  }
+  /**
+   * 刷新指定 key 的缓存（统一由 flushAllCache 写入，此方法仅用于外部兼容调用）
+   */
+  async flushCache(key) {
+    if (!this.fileCompiler.getIsCache()) return;
+    if (!this.pendingUpdates.has(key)) return;
     const updates = this.pendingUpdates.get(key);
-    if (updates.length === 0) return;
-    const cache = await this.fileCompiler.loadCache(key);
-    for (const { unit, meta } of updates) {
-      this.updateCache(unit.file, meta, cache);
+    if (!updates.length) return;
+    if (!this.cachedData) {
+      const filePath = this.fileCompiler.getCachePath();
+      if (fs4.existsSync(filePath)) {
+        try {
+          const content = await fs4.promises.readFile(filePath, "utf-8");
+          this.cachedData = JSON.parse(content);
+        } catch {
+        }
+      }
     }
-    await this.fileCompiler.saveCache(cache);
+    const entries = [...(this.cachedData || this.getEmptyList())[key] || []];
+    updates.forEach(({ unit, meta }) => {
+      const idx = entries.findIndex((c) => c.file === unit.file);
+      if (idx > -1) {
+        entries[idx] = meta;
+      } else {
+        entries.push(meta);
+      }
+    });
+    (this.cachedData || this.getEmptyList())[key] = entries;
     this.pendingUpdates.set(key, []);
+    await this.saveCache(this.buildLoadedCache(key, this.cachedData));
+  }
+  getEmptyList() {
+    return {
+      ["sfc" /* SFC */]: [],
+      ["script" /* SCRIPT */]: [],
+      ["style" /* STYLE */]: [],
+      ["copied" /* ASSET */]: []
+    };
   }
   /**
-   * 更新缓存
+   * 保存缓存数据到文件（watch 等场景使用）
    */
-  updateCache(targetFile, newData, cache) {
-    const index = cache.target.findIndex((c) => c.file === targetFile);
-    if (index > -1) {
-      cache.target[index] = newData;
-    } else {
-      cache.target.push(newData);
-    }
+  async saveCache(data) {
+    if (!this.fileCompiler.getIsCache() || !data) return;
+    if (this.cachedData) {
+      this.cachedData[data.key] = data.target;
+    }
+    await fileLock.updateFile(this.fileCompiler.getCachePath(), (currentData) => {
+      const merged = currentData || this.getEmptyList();
+      merged[data.key] = data.target;
+      return merged;
+    });
+  }
+  buildLoadedCache(key, raw) {
+    const emptySource = {
+      ["sfc" /* SFC */]: [],
+      ["script" /* SCRIPT */]: [],
+      ["style" /* STYLE */]: [],
+      ["copied" /* ASSET */]: []
+    };
+    const source = raw || emptySource;
+    return {
+      key,
+      target: source[key] || [],
+      source
+    };
   }
 };
 
 // src/compiler/shared/file-compiler/cleanup-manager.ts
 import path6 from "path";
 var CleanupManager = class {
-  constructor(fileCompiler) {
+  constructor(fileCompiler, cacheManager) {
     this.fileCompiler = fileCompiler;
+    this.cacheManager = cacheManager;
   }
   /**
-   * Delete the build artifacts and cache corresponding to the specified path.
+   * 删除指定路径对应的构建产物和缓存
    */
   async removeOutputPath(targetPath, type) {
     const absPath = this.fileCompiler.getAbsPath(targetPath);
-    await this.cleanupOldOutput(
-      type,
-      (u) => u.file === absPath || // 加 path.sep 是因为假如删除了 src/components 文件夹，
-      // 为了防止误删名为 src/components-old 的文件夹，
-      // 所以必须确保路径后跟着一个分隔符，确保精准匹配子目录内容。
-      u.file.startsWith(absPath + path6.sep)
-    );
+    const cache = await this.cacheManager.loadCache(type);
+    await this.removeMatchedFromCache(type, cache, (m) => {
+      return m.file === absPath || m.file.startsWith(absPath + path6.sep);
+    });
+    await this.cacheManager.saveCache(cache);
   }
   /**
-   * Delete the build artifacts or asset files and cache corresponding to the specified path.
+   * 删除匹配的输出文件，并从内存缓存中移除对应条目（不写磁盘）
    */
-  async cleanupOldOutput(key, filter) {
-    const cache = await this.fileCompiler.loadCache(key);
+  async removeMatchedFromCache(key, cache, filter) {
     if (!cache.target.length) return;
     const toRemove = cache.target.filter(filter);
     if (!toRemove.length) return;
-    const removeFn = async (m) => {
-      let meta;
-      switch (key) {
-        case "sfc" /* SFC */: {
-          meta = m;
-          const { jsx, css } = meta.output;
-          await this.fileCompiler.removeOutputFile(jsx.file);
-          if (css?.file) {
-            await this.fileCompiler.removeOutputFile(css.file);
-          }
-          break;
-        }
-        case "script" /* SCRIPT */: {
-          meta = m;
-          await this.fileCompiler.removeOutputFile(meta.output.script.file);
-          break;
-        }
-        case "style" /* STYLE */: {
-          meta = m;
-          await this.fileCompiler.removeOutputFile(meta.output.style.file);
-          break;
-        }
-        // 静态资产缓存直接删除对应文件
-        default: {
-          await this.fileCompiler.removeOutputFile(m.file, true);
-          break;
-        }
-      }
-    };
-    await Promise.all(toRemove.map(removeFn));
+    await Promise.all(toRemove.map((m) => this.removeCacheMeta(key, m)));
     const removedFiles = new Set(toRemove.map((m) => m.file));
     cache.target = cache.target.filter((m) => !removedFiles.has(m.file));
-    await this.fileCompiler.saveCache(cache);
+  }
+  /**
+   * 删除单个缓存元数据对应的输出文件（不操作缓存）
+   */
+  async removeCacheMeta(key, meta) {
+    switch (key) {
+      case "sfc" /* SFC */: {
+        const sfcMeta = meta;
+        const { jsx, css } = sfcMeta.output;
+        await this.fileCompiler.removeOutputFile(jsx.file);
+        if (css?.file) {
+          await this.fileCompiler.removeOutputFile(css.file);
+        }
+        break;
+      }
+      case "script" /* SCRIPT */: {
+        const scriptMeta = meta;
+        await this.fileCompiler.removeOutputFile(scriptMeta.output.script.file);
+        break;
+      }
+      case "style" /* STYLE */: {
+        const styleMeta = meta;
+        await this.fileCompiler.removeOutputFile(styleMeta.output.style.file);
+        break;
+      }
+      // 静态资产缓存直接删除对应文件
+      default: {
+        await this.fileCompiler.removeOutputFile(meta.file, true);
+        break;
+      }
+    }
   }
 };
 
@@ -7754,7 +7754,7 @@ var CompilationUnitProcessor = class {
 };
 
 // src/compiler/shared/file-compiler/file-processor.ts
-import fs4 from "fs";
+import fs5 from "fs";
 import kleur6 from "kleur";
 import path7 from "path";
 var FileProcessor = class {
@@ -7785,18 +7785,18 @@ var FileProcessor = class {
   async processFile(key, filePath, existingCache) {
     const absPath = this.fileCompiler.getAbsPath(filePath);
     const fileMeta = await this.fileCompiler.getFileMeta(absPath);
-    const cache = (this.fileCompiler.getIsCache() ? existingCache : void 0) || await this.fileCompiler.loadCache(key);
+    const cache = (this.fileCompiler.getIsCache() ? existingCache : void 0) || await this.cacheManager.loadCache(key);
     const record = cache?.target.find((c) => c.file === absPath);
     const { shouldCompile, hash } = await this.fileCompiler.checkCacheStatus(
       fileMeta,
       record,
-      () => fs4.promises.readFile(absPath, "utf-8")
+      () => fs5.promises.readFile(absPath, "utf-8")
     );
     if (!shouldCompile) {
       this.skippedCount++;
       return;
     }
-    const source = await fs4.promises.readFile(absPath, "utf-8");
+    const source = await fs5.promises.readFile(absPath, "utf-8");
     if (!source.trim()) return;
     const initUnit = {
       ...fileMeta,
@@ -7856,7 +7856,7 @@ var FileProcessor = class {
     const getMainFile = async (filename) => {
       const filePath = path7.resolve(outputPath, filename);
       try {
-        return { filePath, content: await fs4.promises.readFile(filePath, "utf-8") };
+        return { filePath, content: await fs5.promises.readFile(filePath, "utf-8") };
       } catch {
         return;
       }
@@ -7910,64 +7910,160 @@ ${routerImport}`);
   resetSkippedCount() {
     this.skippedCount = 0;
   }
+  /**
+   * 扫描项目中的编译文件和资产文件
+   * @param recursive 是否递归扫描子目录
+   * @param ignoreAssets 需要忽略的资产文件列表
+   */
+  scanFiles() {
+    const { fileCompiler } = this;
+    const rootPath = fileCompiler.getProjectRoot();
+    const inputPath = fileCompiler.getInputPath();
+    const scriptExt = /\.(js|ts|jsx|tsx)$/i;
+    const styleExt = /\.(css|less|sass|scss)$/i;
+    const result = {
+      assets: [],
+      script: [],
+      style: [],
+      vue: []
+    };
+    const getInputStat = (path8) => {
+      if (!fs5.existsSync(path8)) return;
+      return fs5.statSync(path8);
+    };
+    const resolveDirectory = (file, walk, fallback) => {
+      const directory = fs5.readdirSync(file);
+      directory.forEach((p) => {
+        const fullPath = path7.resolve(file, p);
+        if (fileCompiler.shouldSkipPath(fullPath)) {
+          return;
+        }
+        const stat = fs5.statSync(fullPath);
+        if (stat.isDirectory() && fileCompiler.options.recursive !== false) {
+          walk(fullPath);
+          return;
+        }
+        fallback(fullPath);
+      });
+    };
+    const scanCompilationFiles = (file, res) => {
+      const stat = getInputStat(file);
+      if (!stat) return;
+      const classifyFile = (filePath) => {
+        const fileExt = path7.extname(filePath);
+        if (fileExt === ".vue") {
+          res.vue.push(filePath);
+          return;
+        }
+        if (scriptExt.test(fileExt)) {
+          res.script.push(filePath);
+          return;
+        }
+        if (styleExt.test(fileExt)) {
+          res.style.push(filePath);
+        }
+      };
+      if (stat.isFile()) {
+        classifyFile(file);
+        return;
+      }
+      resolveDirectory(
+        file,
+        (path8) => scanCompilationFiles(path8, res),
+        (path8) => classifyFile(path8)
+      );
+    };
+    const isAssetFile = (input) => {
+      const fileExt = path7.extname(input).toLowerCase();
+      const resolvedPath = normalizePath(fileCompiler.relativePath(input));
+      const baseName = path7.basename(input).toLowerCase();
+      const exclusions = fileCompiler.getIgnoreAssets();
+      if (!fileCompiler.options.output?.ignoreAssets) {
+        const shouldExclude = Array.from(exclusions).some((pattern) => {
+          if (pattern.endsWith(".")) {
+            return baseName.startsWith(pattern);
+          }
+          if (pattern.startsWith(".")) {
+            return fileExt === pattern;
+          }
+          return resolvedPath === pattern || baseName === pattern;
+        });
+        if (shouldExclude) return false;
+      } else {
+        if (exclusions.has(resolvedPath) || exclusions.has(baseName) || fileExt === ".vue") {
+          return false;
+        }
+      }
+      const isInsideSrc = input.startsWith(inputPath + path7.sep);
+      if (isInsideSrc && (scriptExt.test(fileExt) || styleExt.test(fileExt))) {
+        return false;
+      }
+      return true;
+    };
+    const scanAssetFiles = (input, res) => {
+      const stat = getInputStat(input);
+      if (!stat || fileCompiler.shouldSkipPath(input)) {
+        return;
+      }
+      if (stat.isFile()) {
+        if (isAssetFile(input)) {
+          res.assets.push(input);
+        }
+        return;
+      }
+      resolveDirectory(
+        input,
+        (path8) => scanAssetFiles(path8, res),
+        (path8) => {
+          if (isAssetFile(path8)) {
+            res.assets.push(path8);
+          }
+        }
+      );
+    };
+    scanCompilationFiles(inputPath, result);
+    scanAssetFiles(rootPath, result);
+    return result;
+  }
 };
 
 // src/compiler/shared/file-compiler/pipeline-manager.ts
-import path8 from "path";
 var PipelineManager = class {
-  constructor(fileCompiler, fileProcessor) {
+  constructor(fileCompiler, fileProcessor, cleanupManager) {
     this.fileCompiler = fileCompiler;
     this.fileProcessor = fileProcessor;
-    this.cleanupManager = new CleanupManager(fileCompiler);
+    this.cleanupManager = cleanupManager;
   }
   skippedCount = 0;
-  cleanupManager;
   /**
    * 运行 SFC 编译管线
    */
-  async runSfcPipeline() {
-    return this.runCorePipeline("sfc" /* SFC */);
+  async runSFC(files, cacheMap) {
+    return this.runCore(files, "sfc" /* SFC */, cacheMap);
   }
   /**
    * 运行 Script 编译管线
    */
-  async runScriptPipeline() {
-    return this.runCorePipeline("script" /* SCRIPT */);
+  async runScript(files, cacheMap) {
+    return this.runCore(files, "script" /* SCRIPT */, cacheMap);
   }
   /**
    * 运行 Style 编译管线
    */
-  async runStylePipeline() {
-    return this.runCorePipeline("style" /* STYLE */);
+  async runStyle(files, cacheMap) {
+    return this.runCore(files, "style" /* STYLE */, cacheMap);
   }
   /**
    * 核心编译管线
    */
-  async runCorePipeline(key) {
-    const inputPath = this.fileCompiler.getInputPath();
-    const scriptExtRegex = /\.(js|ts)$/i;
-    const styleExtRegex = /\.(css|less|sass|scss)$/i;
-    const files = this.fileCompiler.scanFiles(inputPath, (p) => {
-      const ext = path8.extname(p);
-      if (key === "sfc" /* SFC */) {
-        return ext === ".vue";
-      }
-      if (key === "script" /* SCRIPT */) {
-        return scriptExtRegex.test(ext);
-      }
-      if (key === "style" /* STYLE */) {
-        return styleExtRegex.test(ext);
-      }
-      return false;
-    });
-    const absFiles = new Set(files.map((f) => this.fileCompiler.getAbsPath(f)));
-    await this.cleanupManager.cleanupOldOutput(key, (c) => !absFiles.has(c.file));
+  async runCore(files, key, cacheMap) {
+    const absPaths = new Set(files.map((f) => this.fileCompiler.getAbsPath(f)));
+    const cache = cacheMap[key];
+    await this.cleanupManager.removeMatchedFromCache(key, cache, (c) => !absPaths.has(c.file));
     if (!files.length) return 0;
-    const cache = await this.fileCompiler.loadCache(key);
     const compiled = await Promise.all(
-      files.map(async (f) => this.fileProcessor.processFile(key, f, cache))
+      files.map((f) => this.fileProcessor.processFile(key, f, cache))
     );
-    await this.fileCompiler.flushCache(key);
     return compiled.filter(Boolean).length;
   }
   /**
@@ -7981,12 +8077,13 @@ var PipelineManager = class {
    */
   resetSkippedCount() {
     this.skippedCount = 0;
+    this.fileProcessor.resetSkippedCount();
   }
 };
 
 // src/compiler/shared/file-compiler/vite-bootstrapper.ts
 import { execSync } from "child_process";
-import fs5 from "fs";
+import fs6 from "fs";
 import kleur7 from "kleur";
 import ora from "ora";
 var ViteBootstrapper = class {
@@ -8004,10 +8101,10 @@ var ViteBootstrapper = class {
    */
   isSingleFile() {
     const inputPath = this.fileCompiler.getInputPath();
-    if (!fs5.existsSync(inputPath)) {
+    if (!fs6.existsSync(inputPath)) {
       return false;
     }
-    const stat = fs5.statSync(inputPath);
+    const stat = fs6.statSync(inputPath);
     return stat.isFile();
   }
   /**
@@ -8016,30 +8113,20 @@ var ViteBootstrapper = class {
   async bootstrapIfNeeded() {
     const { output } = this.options;
     const workspaceDir = this.fileCompiler.getWorkspaceDir();
-    await fs5.promises.mkdir(workspaceDir, { recursive: true });
+    await fs6.promises.mkdir(workspaceDir, { recursive: true });
     if (output?.bootstrapVite === false) {
       return false;
     }
     if (this.isSingleFile()) {
-      console.info("Skipping Vite initialization for single file compilation");
+      console.info(kleur7.dim("Skip Vite init for single file"));
+      console.info();
       return;
     }
     const outputPkgPath = this.fileCompiler.getOutputPkgPath();
-    if (fs5.existsSync(outputPkgPath)) {
-      return;
-    }
-    try {
-      this.spinner.start("Bootstrapping Vite React environment...");
-      await this.resolveViteCreateApp();
-    } catch (err) {
-      console.error(
-        kleur7.red("\u2716"),
-        "Failed to bootstrap Vite environment. Please check npm/network.\n",
-        err
-      );
-      this.spinner.stop();
+    if (fs6.existsSync(outputPkgPath)) {
       return;
     }
+    await this.resolveViteCreateApp();
     const removeVuePackages = (deps) => {
       for (const name in deps) {
         const isVueLike = VUE_PACKAGES.some((n) => name.includes(n));
@@ -8069,7 +8156,7 @@ var ViteBootstrapper = class {
     newPkg.devDependencies = newDevDeps;
     newPkg = output?.packageJson?.(newPkg) || newPkg;
     await this.fileCompiler.writeFileWithDir(outputPkgPath, JSON.stringify(newPkg, null, 2));
-    this.spinner.succeed("Standard Vite React environment initialized");
+    this.spinner.succeed("Initialized Vite React environment");
     return true;
   }
   /**
@@ -8139,13 +8226,13 @@ var SetupManager = class {
     fileCompiler.manager = {};
     const manager = fileCompiler.manager;
     manager.cacheManager = new CacheManager(fileCompiler);
-    manager.cleanupManager = new CleanupManager(fileCompiler);
   }
   /**
    * 创建依赖基础管理器的管理器
    */
   setupManagedByBase(fileCompiler) {
     const manager = fileCompiler.manager;
+    manager.cleanupManager = new CleanupManager(fileCompiler, manager.cacheManager);
     manager.fileProcessor = new FileProcessor(
       fileCompiler,
       new CompilationUnitProcessor(fileCompiler),
@@ -8158,8 +8245,16 @@ var SetupManager = class {
   setupCompositeManager(fileCompiler) {
     const manager = fileCompiler.manager;
     manager.viteBootstrapper = new ViteBootstrapper(fileCompiler, fileCompiler.options);
-    manager.pipelineManager = new PipelineManager(fileCompiler, manager.fileProcessor);
-    manager.assetManager = new AssetManager(fileCompiler, manager.cleanupManager);
+    manager.pipelineManager = new PipelineManager(
+      fileCompiler,
+      manager.fileProcessor,
+      manager.cleanupManager
+    );
+    manager.assetManager = new AssetManager(
+      fileCompiler,
+      manager.cleanupManager,
+      manager.cacheManager
+    );
   }
 };
 
@@ -8171,34 +8266,57 @@ var FileCompiler = class extends BaseCompiler {
     super(options);
     new SetupManager(() => this);
   }
+  printTitle() {
+    const purple = "\x1B[38;2;153;50;204m";
+    const reset = "\x1B[0m";
+    console.info();
+    console.info();
+    console.info(`${purple}${kleur8.bold("VUREACT")} v${this.version}${reset}`);
+    console.info();
+  }
+  updateSpinner(text) {
+    this.spinner.stop();
+    this.spinner.start(text);
+  }
   /** 执行完整的编译流程 */
   async execute() {
-    console.info("\n\n", kleur8.magenta(`${kleur8.bold("VUREACT")} v${this.version}`), "\n");
-    const startTime = performance.now();
-    const rmWorkspace = async () => {
-      await this.rmFile(this.getWorkspaceDir());
-    };
+    this.printTitle();
     try {
       if (!this.getIsCache()) {
-        await rmWorkspace();
+        await this.rmFile(this.getCachePath());
       }
-      await this.manager.viteBootstrapper.bootstrapIfNeeded();
-      const sfcCount = await this.runPipelineWithSpinner("sfc" /* SFC */);
-      const scriptCount = await this.runPipelineWithSpinner("script" /* SCRIPT */);
-      const styleCount = await this.runPipelineWithSpinner("style" /* STYLE */);
-      const assetCount = await this.runPipelineWithSpinner("copied" /* ASSET */);
+    } catch (err) {
+      console.warn(kleur8.yellow("\u26A0"), "Failed to clear cache");
+      console.info();
+    }
+    const { viteBootstrapper, fileProcessor, cacheManager, pipelineManager, assetManager } = this.manager;
+    let startTime = 0;
+    try {
+      this.updateSpinner("Initializing Vite React env...");
+      await viteBootstrapper.bootstrapIfNeeded();
+      const cacheMap = await cacheManager.loadAllCache();
+      startTime = performance.now();
+      this.updateSpinner("Scanning files...");
+      const scanFiles = fileProcessor.scanFiles();
+      this.updateSpinner("Compiling Vue to React...");
+      const sfcCount = await pipelineManager.runSFC(scanFiles.vue, cacheMap);
+      const scriptCount = await pipelineManager.runScript(scanFiles.script, cacheMap);
+      const styleCount = await pipelineManager.runStyle(scanFiles.style, cacheMap);
+      this.updateSpinner("Copying assets...");
+      const assetCount = await assetManager.runAsset(scanFiles.assets, cacheMap);
+      this.updateSpinner("Almost done...");
+      await cacheManager.flushAllCache();
       await this.options.onSuccess?.();
       const endTime = calcElapsedTime(startTime);
       this.printCoreLogs();
       this.showCompileStats(endTime, sfcCount, scriptCount, styleCount, assetCount);
     } catch (error) {
-      const endTime = calcElapsedTime(startTime);
-      await rmWorkspace();
-      console.error(kleur8.red("\u2716"), `Build failed in ${endTime}`);
+      this.spinner.stop();
+      console.error(kleur8.red("\u2716"), `Build failed in ${calcElapsedTime(startTime)}`);
       console.error(error);
+      await this.rmFile(this.getWorkspaceDir());
       process.exit(-1);
     } finally {
-      this.spinner.stop();
       this.resetSkippedCount();
     }
   }
@@ -8235,62 +8353,40 @@ var FileCompiler = class extends BaseCompiler {
   async processAsset(filePath, existingCache) {
     return this.manager.assetManager.processAsset(filePath, existingCache);
   }
-  /** 批量保存缓存 */
-  async flushCache(key) {
-    await this.manager.cacheManager.flushCache(key);
-  }
   /** 删除指定路径对应的输出文件和缓存 */
   async removeOutputPath(targetPath, type) {
     return await this.manager.cleanupManager.removeOutputPath(targetPath, type);
   }
-  async runPipelineWithSpinner(name) {
-    const options = {
-      ["sfc" /* SFC */]: {
-        text: "Compiling Vue files...",
-        pipeline: () => this.manager.pipelineManager.runSfcPipeline()
-      },
-      ["script" /* SCRIPT */]: {
-        text: "Compiling script files...",
-        pipeline: () => this.manager.pipelineManager.runScriptPipeline()
-      },
-      ["style" /* STYLE */]: {
-        text: "Compiling style files...",
-        pipeline: () => this.manager.pipelineManager.runStylePipeline()
-      },
-      ["copied" /* ASSET */]: {
-        text: "Copying assets...",
-        pipeline: () => this.manager.assetManager.runAssetPipeline()
-      }
-    };
-    const { text, pipeline } = options[name];
-    try {
-      this.spinner.start(text);
-      return await pipeline();
-    } catch (err) {
-      throw err;
-    } finally {
-      this.spinner.stop();
-    }
-  }
   showCompileStats(endTime, sfcCount, scriptCount, styleCount, assetCount) {
     this.spinner.succeed(`Build completed in ${endTime}`);
-    console.info();
     if (sfcCount || scriptCount || styleCount || assetCount) {
       const stats = [];
-      if (sfcCount) stats.push(`${sfcCount} SFC(s)`);
-      if (scriptCount) stats.push(`${scriptCount} script(s)`);
-      if (styleCount) stats.push(`${styleCount} style(s)`);
-      if (assetCount) stats.push(`${assetCount} asset(s)`);
-      this.spinner.succeed(`Processed: ${stats.join(", ")}`);
+      if (sfcCount) stats.push(`${sfcCount} ${kleur8.dim("SFC(s)")}`);
+      if (scriptCount) stats.push(`${scriptCount} ${kleur8.dim("script(s)")}`);
+      if (styleCount) stats.push(`${styleCount} ${kleur8.dim("style(s)")}`);
+      if (assetCount) stats.push(`${assetCount} ${kleur8.dim("asset(s)")}`);
+      this.spinner.succeed(`${kleur8.bold("Processed")}: ${stats.join(", ")}`);
     }
     const skippedCount = this.manager.pipelineManager.getSkippedCount() + this.manager.assetManager.getSkippedCount();
     if (skippedCount) {
-      console.info(kleur8.gray(`\u21B7 Cached: ${kleur8.white(skippedCount)} unchanged file(s)`));
+      console.info();
+      console.info(
+        kleur8.gray(`\u21B7 ${kleur8.bold("Cached")}: ${kleur8.white(skippedCount)} unchanged file(s)`)
+      );
       this.resetSkippedCount();
     }
     const dir = normalizePath(this.relativePath(this.getOuputPath()));
     console.info();
-    console.info(`\u{1F4E6} Output: ${dir}`);
+    console.info(`\u{1F4E6} ${kleur8.bold("Output")}: ${kleur8.cyan(dir)}`);
+    console.info();
+    console.info(`  >  cd ${dir}`);
+    console.info(`  >  npm install`);
+    console.info(`  >  npm run dev`);
+    console.info();
+    console.info(
+      kleur8.dim("\u2B50 If you like VuReact, give us a star on GitHub:"),
+      kleur8.gray(kleur8.underline("https://github.com/vureact-js/core"))
+    );
     console.info();
   }
   resetSkippedCount() {
@@ -8321,9 +8417,9 @@ export {
   transform,
   version,
   bin,
-  CacheKey,
   Helper,
   BaseCompiler,
+  CacheKey,
   FileCompiler,
   defineConfig,
   VuReact