@vureact/compiler-core 1.6.2 → 1.7.0

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

@@ -1,5 +1,5 @@
 /**
- * @vureact/compiler-core v1.6.2
+ * @vureact/compiler-core v1.7.0
  * (c) 2025-present Ruihong Zhong (Ryan John)
  * @license MIT
  */
@@ -1058,7 +1058,7 @@ function buildStandardProp(nodeIR) {
     babelExp: { ast: keyAST },
     value: {
       content,
-      isStringLiteral: isStringLiteral13,
+      isStringLiteral: isStringLiteral14,
       babelExp: { ast: valueAST }
     }
   } = nodeIR;
@@ -1067,7 +1067,7 @@ function buildStandardProp(nodeIR) {
   }
   let value;
   if (content !== "true") {
-    value = isStringLiteral13 ? t9.stringLiteral(content) : buildJsxExpressionNode(valueAST);
+    value = isStringLiteral14 ? t9.stringLiteral(content) : buildJsxExpressionNode(valueAST);
   }
   return t9.jsxAttribute(keyAST, value);
 }
@@ -2408,33 +2408,270 @@ function resolveContext(scriptSetup, ctx) {
   scriptSetup.content = content;
 }
 
-// src/plugins/postcss.ts
+// src/plugins/postcss/index.ts
 import postcss from "postcss";
+
+// src/plugins/postcss/deep.ts
+import selectorParser2 from "postcss-selector-parser";
+
+// src/plugins/postcss/standard.ts
+import selectorParser from "postcss-selector-parser";
+
+// src/plugins/postcss/utils.ts
+function findFirstPseudoIndex(nodes, start, end) {
+  for (let i = start; i <= end; i++) {
+    if (nodes[i]?.type === "pseudo") {
+      return i;
+    }
+  }
+  return end + 1;
+}
+function hasScopeAttribute(nodes, start, end, scopeId) {
+  if (start > end) {
+    return false;
+  }
+  for (let i = start; i <= end; i++) {
+    const node = nodes[i];
+    if (node?.type === "attribute" && node.attribute === scopeId) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasNestingSelector(nodes, start, end) {
+  if (start > end) {
+    return false;
+  }
+  for (let i = start; i <= end; i++) {
+    if (nodes[i]?.type === "nesting") {
+      return true;
+    }
+  }
+  return false;
+}
+function findScopeTargetIndex(nodes, start, end) {
+  if (start > end) {
+    return -1;
+  }
+  let candidate = -1;
+  let nestingFallback = -1;
+  for (let i = start; i <= end; i++) {
+    const node = nodes[i];
+    if (node?.type === "nesting") {
+      nestingFallback = i;
+      continue;
+    }
+    if (node?.type === "tag" || node?.type === "class" || node?.type === "id") {
+      candidate = i;
+    }
+  }
+  return candidate === -1 ? nestingFallback : candidate;
+}
+function isRuleIgnored(rule) {
+  return rule.parent != null && rule.parent.type === "atrule" && rule.parent?.name === "keyframes";
+}
+function isNestedInRule(rule) {
+  let current = rule.parent;
+  while (current) {
+    if (current.type === "rule") {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+
+// src/plugins/postcss/standard.ts
+function resolveStandard(s, scopeId) {
+  try {
+    return selectorParser((selectors) => {
+      selectors.each((selector) => {
+        const compoundEnd = selector.nodes.length - 1;
+        if (compoundEnd < 0) {
+          return;
+        }
+        let compoundStart = 0;
+        for (let i = compoundEnd; i >= 0; i--) {
+          if (selector.nodes[i]?.type === "combinator") {
+            compoundStart = i + 1;
+            break;
+          }
+        }
+        const firstPseudoIndex = findFirstPseudoIndex(selector.nodes, compoundStart, compoundEnd);
+        if (hasNestingSelector(selector.nodes, compoundStart, firstPseudoIndex - 1)) {
+          return;
+        }
+        if (hasScopeAttribute(selector.nodes, compoundStart, firstPseudoIndex - 1, scopeId)) {
+          return;
+        }
+        const insertTargetIndex = findScopeTargetIndex(
+          selector.nodes,
+          compoundStart,
+          firstPseudoIndex - 1
+        );
+        if (insertTargetIndex === -1) {
+          return;
+        }
+        selector.insertAfter(
+          selector.nodes[insertTargetIndex],
+          selectorParser.attribute({
+            attribute: scopeId,
+            raws: {},
+            value: void 0
+            // 不加 = 值，等同于 [data-css-xxx]
+          })
+        );
+      });
+    }).processSync(s);
+  } catch (e) {
+    console.warn(e);
+    return `${s}[${scopeId}]`;
+  }
+}
+
+// src/plugins/postcss/deep.ts
+function resolveDeep(s, scopeId, nestedInRule) {
+  try {
+    const root = selectorParser2().astSync(s);
+    const resolvedSelectors = [];
+    root.nodes.forEach((selector) => {
+      const resolved = resolveSingleSelectorWithDeep(selector, scopeId, nestedInRule);
+      resolvedSelectors.push(...resolved);
+    });
+    return resolvedSelectors.join(", ");
+  } catch (e) {
+    console.warn(e);
+    return s.replace(/:deep\((.*)\)/g, "$1");
+  }
+}
+function resolveSingleSelectorWithDeep(selector, scopeId, nestedInRule) {
+  const deepIndex = findTopLevelDeepIndex(selector.nodes);
+  if (deepIndex === -1) {
+    return [resolveStandard(selector.toString(), scopeId)];
+  }
+  const deepNode = selector.nodes[deepIndex];
+  if (deepNode?.type !== "pseudo") {
+    return [resolveStandard(selector.toString(), scopeId)];
+  }
+  const leftRaw = selector.nodes.slice(0, deepIndex).map((node) => node.toString()).join("");
+  const rightRaw = selector.nodes.slice(deepIndex + 1).map((node) => node.toString()).join("");
+  const leftScoped = scopeDeepLeftSide(leftRaw, scopeId, nestedInRule);
+  const deepInnerSelectors = deepNode.nodes?.length ? deepNode.nodes : [];
+  if (!deepInnerSelectors.length) {
+    return [leftScoped + rightRaw];
+  }
+  const results = [];
+  for (const innerSelector of deepInnerSelectors) {
+    const combined = joinDeepParts(leftScoped, innerSelector.toString().trim(), rightRaw);
+    if (combined.includes(":deep(")) {
+      results.push(resolveDeep(combined, scopeId, nestedInRule));
+      continue;
+    }
+    results.push(combined);
+  }
+  return results;
+}
+function findTopLevelDeepIndex(nodes) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (node?.type === "pseudo" && (node.value === ":deep" || node.value === "::v-deep")) {
+      return i;
+    }
+  }
+  return -1;
+}
+function scopeDeepLeftSide(leftRaw, scopeId, nestedInRule) {
+  if (!leftRaw.trim()) {
+    return nestedInRule ? "&" : `[${scopeId}]`;
+  }
+  try {
+    const root = selectorParser2().astSync(leftRaw);
+    root.each((selector) => {
+      injectScopeToRightMostCompound(selector, scopeId);
+    });
+    return root.toString();
+  } catch (e) {
+    console.warn(e);
+    return resolveStandard(leftRaw, scopeId);
+  }
+}
+function injectScopeToRightMostCompound(selector, scopeId) {
+  const nodes = selector.nodes;
+  if (!nodes.length) {
+    return;
+  }
+  let compoundEnd = nodes.length - 1;
+  while (compoundEnd >= 0 && nodes[compoundEnd]?.type === "combinator") {
+    compoundEnd--;
+  }
+  if (compoundEnd < 0) {
+    return;
+  }
+  let compoundStart = 0;
+  for (let i = compoundEnd; i >= 0; i--) {
+    if (nodes[i]?.type === "combinator") {
+      compoundStart = i + 1;
+      break;
+    }
+  }
+  const firstPseudoIndex = findFirstPseudoIndex(nodes, compoundStart, compoundEnd);
+  if (hasScopeAttribute(nodes, compoundStart, firstPseudoIndex - 1, scopeId)) {
+    return;
+  }
+  const insertTargetIndex = findScopeTargetIndex(nodes, compoundStart, firstPseudoIndex - 1);
+  if (insertTargetIndex === -1) {
+    return;
+  }
+  const insertTarget = nodes[insertTargetIndex];
+  insertTarget.spaces = {
+    ...insertTarget.spaces,
+    after: ""
+  };
+  selector.insertAfter(
+    insertTarget,
+    selectorParser2.attribute({
+      attribute: scopeId,
+      raws: {},
+      value: void 0
+    })
+  );
+}
+function joinDeepParts(leftScoped, innerRaw, rightRaw) {
+  if (!leftScoped) {
+    return `${innerRaw}${rightRaw}`;
+  }
+  const needsGap = !/\s$/.test(leftScoped);
+  const gap = needsGap ? " " : "";
+  return `${leftScoped}${gap}${innerRaw}${rightRaw}`;
+}
+
+// src/plugins/postcss/selector.ts
+function resolveSelector(s, scopeId, options) {
+  if (s.includes(":global(")) {
+    return s.replace(/:global\(([^)]+)\)/g, (_, inner) => inner);
+  }
+  if (s.includes(":deep(")) {
+    return resolveDeep(s, scopeId, options?.nestedInRule ?? false);
+  }
+  if (s.includes(":slotted(")) {
+    return s.replace(/:slotted\((.*)\)/, "$1");
+  }
+  return resolveStandard(s, scopeId);
+}
+
+// src/plugins/postcss/index.ts
 function processScopedWithPostCss(input, hash) {
   const scopeId = `data-css-${hash}`;
   const result = postcss([
     {
-      postcssPlugin: "postcss-scoped-simple",
+      postcssPlugin: "postcss-scoped-vureact",
       Rule(rule) {
-        if (rule.parent && rule.parent.type === "atrule" && rule.parent.name === "keyframes") {
+        if (isRuleIgnored(rule)) {
           return;
         }
-        rule.selectors = rule.selectors.map((selector) => {
-          if (selector.includes(":global(")) {
-            return selector.replace(/:global\((.*)\)/, "$1");
-          }
-          if (selector.includes(":deep(")) {
-            return selector.replace(/:deep\((.*)\)/, "$1");
-          }
-          const pseudoElementRegex = /(::[a-zA-Z-]+)$/;
-          const match = selector.match(pseudoElementRegex);
-          if (match) {
-            const base = selector.replace(pseudoElementRegex, "");
-            const pseudo = match[1];
-            return `${base}[${scopeId}]${pseudo}`;
-          }
-          return `${selector}[${scopeId}]`;
-        });
+        rule.selectors = rule.selectors.map(
+          (selector) => resolveSelector(selector, scopeId, { nestedInRule: isNestedInRule(rule) })
+        );
       }
     }
   ]).process(input);
@@ -3118,30 +3355,32 @@ function resolveEmitCalls(ctx) {
       };
       if (!checkIfFromDefineEmits()) return;
       const [callee, ...args] = node.arguments;
-      const eventName = t28.isStringLiteral(callee) ? formatEmitEventName(callee.value) : void 0;
-      if (!eventName) {
-        logger.warn(`Expected String type but got ${callee?.type}, expression will be removed`, {
-          file: filename,
-          source: scriptData.source,
-          loc: callee?.loc
-        });
-        path9.remove();
-        return;
+      let propCall;
+      if (t28.isStringLiteral(callee)) {
+        const eventName = formatEmitEventName(callee.value);
+        propCall = createPropCall(ctx.propField, t28.identifier(eventName), args);
+      } else {
+        propCall = createPropCall(ctx.propField, callee, args, true);
+        logger.error(
+          `Non-string event name cannot be converted to React onXxx style. The emit call will not work as expected.`,
+          {
+            file: filename,
+            source: scriptData.source,
+            loc: callee?.loc
+          }
+        );
       }
-      const propCall = t28.optionalCallExpression(
-        t28.optionalMemberExpression(
-          t28.identifier(ctx.propField),
-          t28.identifier(eventName),
-          false,
-          true
-        ),
-        args,
-        true
-      );
       replaceNode(path9, propCall, node);
     }
   };
 }
+function createPropCall(rootName, callee, args, computed = false) {
+  return t28.optionalCallExpression(
+    t28.memberExpression(t28.identifier(rootName), callee, computed),
+    args,
+    true
+  );
+}
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/index.ts
 import * as t36 from "@babel/types";
@@ -4154,20 +4393,249 @@ function createPropsTypeAssertion(propsIdentifier, typeAnnotation) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-analysis-only-adapter.ts
-import * as t39 from "@babel/types";
+import * as t43 from "@babel/types";
 
-// src/core/transform/sfc/script/shared/dependency-analyzer.ts
+// src/core/transform/sfc/script/shared/dependency-analyzer/index.ts
 import { traverse as traverse2 } from "@babel/core";
+import * as t42 from "@babel/types";
+
+// src/core/transform/sfc/script/shared/dependency-analyzer/binding-utils.ts
+function isBindingDeclaredInsideBoundary(binding, boundary) {
+  let current = binding.path;
+  while (current) {
+    if (current.node === boundary) {
+      return true;
+    }
+    current = current.parentPath;
+  }
+  return false;
+}
+function isReactiveBinding(node) {
+  if (!node) return false;
+  return !!getScriptNodeMeta(node)?.is_reactive;
+}
+
+// src/core/transform/sfc/script/shared/dependency-analyzer/dep-checker.ts
 import * as t38 from "@babel/types";
+function isEligibleBindingSource(binding) {
+  if (binding.kind === "param") {
+    return false;
+  }
+  const reactiveStateApis = getReactiveStateApis();
+  const bindingPath = binding.path;
+  const declaratorPath = getVariableDeclaratorPath(bindingPath);
+  const isReactiveVarBinding = !!declaratorPath && isReactiveBinding(declaratorPath.node);
+  const nodeInit = declaratorPath?.node.init;
+  const isReactiveApiCallVarBinding = !!declaratorPath && t38.isCallExpression(nodeInit) && t38.isIdentifier(nodeInit.callee) && reactiveStateApis.has(nodeInit.callee.name);
+  const isHookCallVarBinding = !!declaratorPath && t38.isCallExpression(nodeInit) && isHookLikeCallee(nodeInit.callee);
+  const isFunctionBinding = bindingPath.isFunctionDeclaration() || !!declaratorPath && !!nodeInit && (t38.isArrowFunctionExpression(nodeInit) || t38.isFunctionExpression(nodeInit));
+  const isReactiveFunctionBinding = isFunctionBinding && (isReactiveBinding(declaratorPath?.node) || isReactiveBinding(bindingPath.node));
+  return isReactiveVarBinding || isReactiveApiCallVarBinding || isHookCallVarBinding || isReactiveFunctionBinding;
+}
+function isReactValidDependencyExpr(node) {
+  if (t38.isIdentifier(node)) {
+    return true;
+  }
+  if (t38.isMemberExpression(node) || t38.isOptionalMemberExpression(node)) {
+    return isStaticMemberChain(node);
+  }
+  return false;
+}
+function isStaticMemberChain(node) {
+  let current = node;
+  while (t38.isMemberExpression(current) || t38.isOptionalMemberExpression(current)) {
+    if (!current.computed && !t38.isIdentifier(current.property)) {
+      return false;
+    }
+    if (current.computed && !t38.isStringLiteral(current.property) && !t38.isNumericLiteral(current.property)) {
+      return false;
+    }
+    current = current.object;
+  }
+  return t38.isIdentifier(current);
+}
+function isHookLikeCallee(callee) {
+  if (t38.isIdentifier(callee)) {
+    return callee.name.startsWith("use");
+  }
+  if (t38.isMemberExpression(callee) && !callee.computed && t38.isIdentifier(callee.property)) {
+    return callee.property.name.startsWith("use");
+  }
+  return false;
+}
+
+// src/core/transform/sfc/script/shared/dependency-analyzer/dep-key.ts
+import * as t39 from "@babel/types";
+function getDependencyKey(exp) {
+  if (t39.isIdentifier(exp)) {
+    return exp.name;
+  }
+  if (t39.isMemberExpression(exp) || t39.isOptionalMemberExpression(exp)) {
+    const objectKey = getDependencyKey(exp.object);
+    const opt = exp.optional ? "?" : "";
+    if (!exp.computed && t39.isIdentifier(exp.property)) {
+      return `${objectKey}${opt}.${exp.property.name}`;
+    }
+    if (t39.isStringLiteral(exp.property) || t39.isNumericLiteral(exp.property)) {
+      return `${objectKey}${opt}[${JSON.stringify(exp.property.value)}]`;
+    }
+    return `${objectKey}${opt}[*]`;
+  }
+  return exp.type;
+}
+
+// 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);
+  }
+  if (t40.isMemberExpression(path9.node) || t40.isOptionalMemberExpression(path9.node)) {
+    if (rootName === ctx.propField) {
+      const safePropsExp = ensureOptionalForMemberChain(path9.node);
+      if (isReactValidDependencyExpr(safePropsExp)) {
+        return t40.cloneNode(safePropsExp, true);
+      }
+      return t40.identifier(rootName);
+    }
+    const normalizedExp = normalizeMemberForCallSite(path9, path9.node);
+    const safeExp = t40.isMemberExpression(normalizedExp) || t40.isOptionalMemberExpression(normalizedExp) ? ensureOptionalForMemberChain(normalizedExp) : normalizedExp;
+    if (isReactValidDependencyExpr(safeExp)) {
+      return t40.cloneNode(safeExp, true);
+    }
+    return t40.identifier(rootName);
+  }
+  return null;
+}
+function normalizeSourcedDependency(exp) {
+  if (t40.isIdentifier(exp)) {
+    return t40.identifier(exp.name);
+  }
+  if (t40.isMemberExpression(exp) || t40.isOptionalMemberExpression(exp)) {
+    const root = findRootIdentifier(exp);
+    if (!root) return null;
+    const safeExp = t40.isMemberExpression(exp) || t40.isOptionalMemberExpression(exp) ? ensureOptionalForMemberChain(exp) : exp;
+    if (isReactValidDependencyExpr(safeExp)) {
+      return t40.cloneNode(safeExp, true);
+    }
+    return t40.identifier(root.name);
+  }
+  return null;
+}
+function normalizeMemberForCallSite(path9, node) {
+  const parent = path9.parentPath;
+  const isDirectCallee = !!parent && (parent.isCallExpression() && parent.node.callee === node || parent.isOptionalCallExpression() && parent.node.callee === node);
+  if (!isDirectCallee) {
+    return node;
+  }
+  if (!t40.isExpression(node.object)) {
+    return node;
+  }
+  return node.object;
+}
+function ensureOptionalForMemberChain(node) {
+  if (!hasTrailingMemberAccess(node)) {
+    return node;
+  }
+  if (t40.isOptionalMemberExpression(node) && node.optional) {
+    return node;
+  }
+  const object = t40.cloneNode(node.object, true);
+  const property = t40.cloneNode(node.property, true);
+  return t40.optionalMemberExpression(object, property, node.computed, true);
+}
+function hasTrailingMemberAccess(node) {
+  return t40.isMemberExpression(node.object) || t40.isOptionalMemberExpression(node.object);
+}
+
+// src/core/transform/sfc/script/shared/dependency-analyzer/shared-utils.ts
 var TRACE_MAX_DEPTH = 20;
+function isNestedMemberObject(path9) {
+  const parent = path9.parentPath;
+  if (!parent) return false;
+  if (parent.isMemberExpression() || parent.isOptionalMemberExpression()) {
+    return parent.node.object === path9.node;
+  }
+  return false;
+}
+
+// src/core/transform/sfc/script/shared/dependency-analyzer/trace-utils.ts
+import * as t41 from "@babel/types";
+function traceBindingSource(binding, seen, depth) {
+  if (depth <= 0) return null;
+  const declaratorPath = getVariableDeclaratorPath(binding.path);
+  if (!declaratorPath || !declaratorPath.node.init) return null;
+  if (seen.has(declaratorPath.node)) return null;
+  seen.add(declaratorPath.node);
+  const { init } = declaratorPath.node;
+  return isExpressionSourcedFromEligibleBinding(init, declaratorPath.scope, seen, depth - 1);
+}
+function isExpressionSourcedFromEligibleBinding(exp, scope, seen, depth) {
+  if (depth <= 0) return null;
+  if (t41.isIdentifier(exp)) {
+    const sourceBinding = scope.getBinding(exp.name);
+    if (!sourceBinding) return null;
+    if (isEligibleBindingSource(sourceBinding)) {
+      return exp;
+    }
+    return traceBindingSource(sourceBinding, seen, depth - 1);
+  }
+  if (t41.isMemberExpression(exp) || t41.isOptionalMemberExpression(exp)) {
+    const root = findRootIdentifier(exp);
+    if (!root) return null;
+    const sourceBinding = scope.getBinding(root.name);
+    if (!sourceBinding) return null;
+    if (isEligibleBindingSource(sourceBinding)) {
+      return t41.cloneNode(exp);
+    }
+    const sourcedRoot = traceBindingSource(sourceBinding, seen, depth - 1);
+    if (sourcedRoot) {
+      const rebuilt = rebuildMemberWithNewRoot(exp, sourcedRoot);
+      if (rebuilt) {
+        return rebuilt;
+      }
+      return t41.cloneNode(sourcedRoot, true);
+    }
+  }
+  return null;
+}
+function rebuildMemberWithNewRoot(node, nextRoot) {
+  const replacedObject = (() => {
+    if (t41.isIdentifier(node.object)) {
+      return t41.cloneNode(nextRoot, true);
+    }
+    if (t41.isMemberExpression(node.object) || t41.isOptionalMemberExpression(node.object)) {
+      return rebuildMemberWithNewRoot(node.object, nextRoot);
+    }
+    return null;
+  })();
+  if (!replacedObject) {
+    return null;
+  }
+  const property = t41.cloneNode(node.property, true);
+  if (t41.isMemberExpression(node)) {
+    return t41.memberExpression(
+      replacedObject,
+      property,
+      node.computed
+    );
+  }
+  return t41.optionalMemberExpression(
+    replacedObject,
+    property,
+    node.computed,
+    node.optional
+  );
+}
+
+// src/core/transform/sfc/script/shared/dependency-analyzer/index.ts
 function analyzeDeps(node, ctx, parentPath) {
   if (!parentPath) {
-    return t38.arrayExpression([]);
+    return t42.arrayExpression([]);
   }
-  const isFnExpr = t38.isArrowFunctionExpression(node) || t38.isFunctionExpression(node);
+  const isFnExpr = t42.isArrowFunctionExpression(node) || t42.isFunctionExpression(node);
   const analyzeTarget = isFnExpr ? node.body : node;
   const bindingLocalBoundary = isFnExpr ? node : analyzeTarget;
-  const reactiveStateApis = getReactiveStateApis();
   const deps = /* @__PURE__ */ new Map();
   const processedIdentifiers = /* @__PURE__ */ new WeakSet();
   function addDependency(exp) {
@@ -4175,13 +4643,13 @@ function analyzeDeps(node, ctx, parentPath) {
   }
   const analyzeTargetPath = parentPath && parentPath.node === analyzeTarget ? parentPath : null;
   if (analyzeTargetPath) {
-    if (t38.isMemberExpression(analyzeTarget) || t38.isOptionalMemberExpression(analyzeTarget)) {
+    if (t42.isMemberExpression(analyzeTarget) || t42.isOptionalMemberExpression(analyzeTarget)) {
       const rootId = findRootIdentifier(analyzeTarget);
       if (rootId) {
         tryAddDependency(analyzeTargetPath, rootId.name, analyzeTargetPath.scope);
         processedIdentifiers.add(rootId);
       }
-    } else if (t38.isIdentifier(analyzeTarget)) {
+    } else if (t42.isIdentifier(analyzeTarget)) {
       tryAddDependency(analyzeTargetPath, analyzeTarget.name, analyzeTargetPath.scope);
     }
   }
@@ -4207,17 +4675,19 @@ function analyzeDeps(node, ctx, parentPath) {
     parentPath.scope
   );
   function tryAddDependency(depPath, rootName, scope) {
-    const normalized = normalizeDependencyExpr(depPath, rootName);
+    const normalized = normalizeDependencyExpr(depPath, rootName, ctx);
     if (!normalized) return;
-    const binding = scope.getBinding(rootName);
-    if (!binding) return;
-    const isLocalBinding = isBindingDeclaredInsideBoundary(binding, bindingLocalBoundary);
     if (rootName === ctx.propField) {
-      if (!isLocalBinding) {
+      const propsBinding = scope.getBinding(rootName);
+      const isLocalPropsBinding = !!propsBinding && isBindingDeclaredInsideBoundary(propsBinding, bindingLocalBoundary);
+      if (!isLocalPropsBinding) {
         addDependency(normalized);
       }
       return;
     }
+    const binding = scope.getBinding(rootName);
+    if (!binding) return;
+    const isLocalBinding = isBindingDeclaredInsideBoundary(binding, bindingLocalBoundary);
     const directEligible = !isLocalBinding && isEligibleBindingSource(binding);
     if (directEligible) {
       addDependency(normalized);
@@ -4231,211 +4701,7 @@ function analyzeDeps(node, ctx, parentPath) {
       }
     }
   }
-  function normalizeDependencyExpr(path9, rootName) {
-    if (t38.isIdentifier(path9.node)) {
-      return t38.identifier(path9.node.name);
-    }
-    if (t38.isMemberExpression(path9.node) || t38.isOptionalMemberExpression(path9.node)) {
-      const normalizedExp = normalizeMemberForCallSite(path9, path9.node);
-      const safeExp = t38.isMemberExpression(normalizedExp) || t38.isOptionalMemberExpression(normalizedExp) ? ensureOptionalForMemberChain(normalizedExp) : normalizedExp;
-      if (isReactValidDependencyExpr(safeExp)) {
-        return t38.cloneNode(safeExp, true);
-      }
-      return t38.identifier(rootName);
-    }
-    return null;
-  }
-  function normalizeSourcedDependency(exp) {
-    if (t38.isIdentifier(exp)) {
-      return t38.identifier(exp.name);
-    }
-    if (t38.isMemberExpression(exp) || t38.isOptionalMemberExpression(exp)) {
-      const root = findRootIdentifier(exp);
-      if (!root) return null;
-      const safeExp = t38.isMemberExpression(exp) || t38.isOptionalMemberExpression(exp) ? ensureOptionalForMemberChain(exp) : exp;
-      if (isReactValidDependencyExpr(safeExp)) {
-        return t38.cloneNode(safeExp, true);
-      }
-      return t38.identifier(root.name);
-    }
-    return null;
-  }
-  function isReactValidDependencyExpr(node2) {
-    if (t38.isIdentifier(node2)) {
-      return true;
-    }
-    if (t38.isMemberExpression(node2) || t38.isOptionalMemberExpression(node2)) {
-      return isStaticMemberChain(node2);
-    }
-    return false;
-  }
-  function isStaticMemberChain(node2) {
-    let current = node2;
-    while (t38.isMemberExpression(current) || t38.isOptionalMemberExpression(current)) {
-      if (!current.computed && !t38.isIdentifier(current.property)) {
-        return false;
-      }
-      if (current.computed && !t38.isStringLiteral(current.property) && !t38.isNumericLiteral(current.property)) {
-        return false;
-      }
-      current = current.object;
-    }
-    return t38.isIdentifier(current);
-  }
-  function isBindingDeclaredInsideBoundary(binding, boundary) {
-    let current = binding.path;
-    while (current) {
-      if (current.node === boundary) {
-        return true;
-      }
-      current = current.parentPath;
-    }
-    return false;
-  }
-  function normalizeMemberForCallSite(path9, node2) {
-    const parent = path9.parentPath;
-    const isDirectCallee = !!parent && (parent.isCallExpression() && parent.node.callee === node2 || parent.isOptionalCallExpression() && parent.node.callee === node2);
-    if (!isDirectCallee) {
-      return node2;
-    }
-    if (!t38.isExpression(node2.object)) {
-      return node2;
-    }
-    return node2.object;
-  }
-  function ensureOptionalForMemberChain(node2) {
-    if (!hasTrailingMemberAccess(node2)) {
-      return node2;
-    }
-    if (t38.isOptionalMemberExpression(node2) && node2.optional) {
-      return node2;
-    }
-    const object = t38.cloneNode(node2.object, true);
-    const property = t38.cloneNode(node2.property, true);
-    return t38.optionalMemberExpression(object, property, node2.computed, true);
-  }
-  function hasTrailingMemberAccess(node2) {
-    return t38.isMemberExpression(node2.object) || t38.isOptionalMemberExpression(node2.object);
-  }
-  function isEligibleBindingSource(binding) {
-    if (binding.kind === "param") {
-      return false;
-    }
-    const bindingPath = binding.path;
-    const declaratorPath = getVariableDeclaratorPath(bindingPath);
-    const isReactiveVarBinding = !!declaratorPath && isReactiveBinding(declaratorPath.node);
-    const nodeInit = declaratorPath?.node.init;
-    const isReactiveApiCallVarBinding = !!declaratorPath && t38.isCallExpression(nodeInit) && t38.isIdentifier(nodeInit.callee) && reactiveStateApis.has(nodeInit.callee.name);
-    const isHookCallVarBinding = !!declaratorPath && t38.isCallExpression(nodeInit) && isHookLikeCallee(nodeInit.callee);
-    const isFunctionBinding = bindingPath.isFunctionDeclaration() || !!declaratorPath && !!nodeInit && (t38.isArrowFunctionExpression(nodeInit) || t38.isFunctionExpression(nodeInit));
-    const isReactiveFunctionBinding = isFunctionBinding && (isReactiveBinding(declaratorPath?.node) || isReactiveBinding(bindingPath.node));
-    return isReactiveVarBinding || isReactiveApiCallVarBinding || isHookCallVarBinding || isReactiveFunctionBinding;
-  }
-  function isHookLikeCallee(callee) {
-    if (t38.isIdentifier(callee)) {
-      return callee.name.startsWith("use");
-    }
-    if (t38.isMemberExpression(callee) && !callee.computed && t38.isIdentifier(callee.property)) {
-      return callee.property.name.startsWith("use");
-    }
-    return false;
-  }
-  function traceBindingSource(binding, seen, depth) {
-    if (depth <= 0) return null;
-    const declaratorPath = getVariableDeclaratorPath(binding.path);
-    if (!declaratorPath || !declaratorPath.node.init) return null;
-    if (seen.has(declaratorPath.node)) return null;
-    seen.add(declaratorPath.node);
-    const { init } = declaratorPath.node;
-    return isExpressionSourcedFromEligibleBinding(init, declaratorPath.scope, seen, depth - 1);
-  }
-  function isExpressionSourcedFromEligibleBinding(exp, scope, seen, depth) {
-    if (depth <= 0) return null;
-    if (t38.isIdentifier(exp)) {
-      const sourceBinding = scope.getBinding(exp.name);
-      if (!sourceBinding) return null;
-      if (isEligibleBindingSource(sourceBinding)) {
-        return exp;
-      }
-      return traceBindingSource(sourceBinding, seen, depth - 1);
-    }
-    if (t38.isMemberExpression(exp) || t38.isOptionalMemberExpression(exp)) {
-      const root = findRootIdentifier(exp);
-      if (!root) return null;
-      const sourceBinding = scope.getBinding(root.name);
-      if (!sourceBinding) return null;
-      if (isEligibleBindingSource(sourceBinding)) {
-        return t38.cloneNode(exp);
-      }
-      const sourcedRoot = traceBindingSource(sourceBinding, seen, depth - 1);
-      if (sourcedRoot) {
-        const rebuilt = rebuildMemberWithNewRoot(exp, sourcedRoot);
-        if (rebuilt) {
-          return rebuilt;
-        }
-        return t38.cloneNode(sourcedRoot, true);
-      }
-    }
-    return null;
-  }
-  function rebuildMemberWithNewRoot(node2, nextRoot) {
-    const replacedObject = (() => {
-      if (t38.isIdentifier(node2.object)) {
-        return t38.cloneNode(nextRoot, true);
-      }
-      if (t38.isMemberExpression(node2.object) || t38.isOptionalMemberExpression(node2.object)) {
-        return rebuildMemberWithNewRoot(node2.object, nextRoot);
-      }
-      return null;
-    })();
-    if (!replacedObject) {
-      return null;
-    }
-    const property = t38.cloneNode(node2.property, true);
-    if (t38.isMemberExpression(node2)) {
-      return t38.memberExpression(
-        replacedObject,
-        property,
-        node2.computed
-      );
-    }
-    return t38.optionalMemberExpression(
-      replacedObject,
-      property,
-      node2.computed,
-      node2.optional
-    );
-  }
-  return t38.arrayExpression(Array.from(deps.values()));
-}
-function getDependencyKey(exp) {
-  if (t38.isIdentifier(exp)) {
-    return exp.name;
-  }
-  if (t38.isMemberExpression(exp) || t38.isOptionalMemberExpression(exp)) {
-    const objectKey = getDependencyKey(exp.object);
-    const opt = exp.optional ? "?" : "";
-    if (!exp.computed && t38.isIdentifier(exp.property)) {
-      return `${objectKey}${opt}.${exp.property.name}`;
-    }
-    if (t38.isStringLiteral(exp.property) || t38.isNumericLiteral(exp.property)) {
-      return `${objectKey}${opt}[${JSON.stringify(exp.property.value)}]`;
-    }
-    return `${objectKey}${opt}[*]`;
-  }
-  return exp.type;
-}
-function isNestedMemberObject(path9) {
-  const parent = path9.parentPath;
-  if (!parent) return false;
-  if (parent.isMemberExpression() || parent.isOptionalMemberExpression()) {
-    return parent.node.object === path9.node;
-  }
-  return false;
-}
-function isReactiveBinding(node) {
-  if (!node) return false;
-  return !!getScriptNodeMeta(node)?.is_reactive;
+  return t42.arrayExpression(Array.from(deps.values()));
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-analysis-only-adapter.ts
@@ -4451,7 +4717,7 @@ function resolveAnalysisOnlyAdapter(ctx) {
       if (!isVueApiReference(path9, apiName)) {
         return;
       }
-      if (t39.isCallExpression(node)) {
+      if (t43.isCallExpression(node)) {
         resolveCallNode(path9, adapter, ctx);
       } else {
         replaceIdName(node, adapter.target);
@@ -4461,11 +4727,11 @@ function resolveAnalysisOnlyAdapter(ctx) {
   };
 }
 function getApiName(node) {
-  const isCallNode = t39.isCallExpression(node);
+  const isCallNode = t43.isCallExpression(node);
   let apiName = "";
-  if (t39.isIdentifier(node)) {
+  if (t43.isIdentifier(node)) {
     apiName = node.name;
-  } else if (isCallNode && t39.isIdentifier(node.callee)) {
+  } else if (isCallNode && t43.isIdentifier(node.callee)) {
     apiName = node.callee.name;
   }
   return apiName;
@@ -4475,7 +4741,7 @@ function resolveCallNode(path9, adapter, ctx) {
   const { arguments: args } = node;
   if (!args.length) return;
   const fn = args[0];
-  if (!t39.isArrowFunctionExpression(fn) && !t39.isFunctionExpression(fn)) {
+  if (!t43.isArrowFunctionExpression(fn) && !t43.isFunctionExpression(fn)) {
     return;
   }
   const fnPath = path9.get("arguments")[0];
@@ -4507,7 +4773,7 @@ function isVueImportBinding(binding) {
     return false;
   }
   const parent = bindingPath.parentPath?.node;
-  if (!parent || !t39.isImportDeclaration(parent)) {
+  if (!parent || !t43.isImportDeclaration(parent)) {
     return false;
   }
   const source = parent.source.value.toLowerCase();
@@ -4575,7 +4841,7 @@ function isSkip(path9) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-element-ref.ts
-import * as t40 from "@babel/types";
+import * as t44 from "@babel/types";
 function resolveElementRef(ctx) {
   return {
     CallExpression(path9) {
@@ -4593,14 +4859,14 @@ function resolveElementRef(ctx) {
       }
       if (isCompRefBindings) {
         const varDeclaratorPath = getVariableDeclaratorPath(path9)?.node;
-        if (!t40.isIdentifier(varDeclaratorPath?.id)) {
+        if (!t44.isIdentifier(varDeclaratorPath?.id)) {
           return;
         }
         const varName = varDeclaratorPath.id.name;
         const compRef = refBindings.componentRefs[varName];
         if (!compRef) return;
       }
-      node.arguments[0] = t40.identifier("null");
+      node.arguments[0] = t44.identifier("null");
       resolveTypeParameters(ctx, path9);
       replaceCallName(node, REACT_API_MAP.useRef);
       recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.useRef);
@@ -4625,27 +4891,27 @@ function resolveTypeParameters(ctx, path9) {
   const compBindingMeta = refBindings.componentRefs[idName];
   if (!node.typeParameters && (domBindingMeta || compBindingMeta)) {
     const type = compBindingMeta ? "any" : domBindingMeta.htmlType;
-    node.typeParameters = t40.tsTypeParameterInstantiation([t40.tsTypeReference(t40.identifier(type))]);
+    node.typeParameters = t44.tsTypeParameterInstantiation([t44.tsTypeReference(t44.identifier(type))]);
   }
 }
 function resolveRefValueToCurrent(path9) {
   const { node } = path9;
-  if (node.computed || !t40.isIdentifier(node.property) || node.property.name !== "value") {
+  if (node.computed || !t44.isIdentifier(node.property) || node.property.name !== "value") {
     return;
   }
   const rootPath = findRootVariablePath(path9);
-  if (!rootPath?.node || !t40.isCallExpression(rootPath.node.init) || !isCalleeNamed(rootPath.node.init, REACT_API_MAP.useRef)) {
+  if (!rootPath?.node || !t44.isCallExpression(rootPath.node.init) || !isCalleeNamed(rootPath.node.init, REACT_API_MAP.useRef)) {
     return;
   }
   const rootId = findRootIdentifier(node);
-  if (!t40.isIdentifier(node.object) || node.object.name !== rootId?.name) {
+  if (!t44.isIdentifier(node.object) || node.object.name !== rootId?.name) {
     return;
   }
   node.property.name = "current";
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-expression-memo.ts
-import * as t41 from "@babel/types";
+import * as t45 from "@babel/types";
 function resolveExprMemo(ctx, ast) {
   const isScriptFile = ctx.inputType !== "sfc";
   return {
@@ -4657,11 +4923,11 @@ function resolveExprMemo(ctx, ast) {
         if (!atComponentOrHookRoot(path9, ast.program, isScriptFile)) {
           return false;
         }
-        if (!t41.isVariableDeclaration(path9.parent) || path9.parent.kind !== "const") {
+        if (!t45.isVariableDeclaration(path9.parent) || path9.parent.kind !== "const") {
           return false;
         }
-        if (t41.isFunction(init)) return false;
-        if (t41.isCallExpression(init) && t41.isIdentifier(init.callee) && init.callee.name.startsWith("use")) {
+        if (t45.isFunction(init)) return false;
+        if (t45.isCallExpression(init) && t45.isIdentifier(init.callee) && init.callee.name.startsWith("use")) {
           return false;
         }
         return true;
@@ -4674,21 +4940,22 @@ function resolveExprMemo(ctx, ast) {
       const useMemoCall = createUseMemo(initPath.node, deps);
       initPath.replaceWith(useMemoCall);
       setScriptNodeMeta(node, { is_reactive: true, reactive_type: "indirect" });
+      recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.useMemo);
     }
   };
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-lint-rules.ts
-import * as t42 from "@babel/types";
+import * as t46 from "@babel/types";
 function resolveLintRules(ctx, ast) {
   const inScriptFile = ctx.inputType !== "sfc";
   return {
     CallExpression(path9) {
       const { node, parentPath } = path9;
-      if (!t42.isIdentifier(node.callee)) return;
+      if (!t46.isIdentifier(node.callee)) return;
       const { name: callName } = node.callee;
-      const addLog = (t48) => {
-        logger.error(t48, {
+      const addLog = (t52) => {
+        logger.error(t52, {
           file: ctx.filename,
           source: ctx.scriptData.source,
           loc: node.loc
@@ -4733,7 +5000,7 @@ function resolveLintRules(ctx, ast) {
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-provide.ts
 import { generate as generate2 } from "@babel/generator";
-import * as t43 from "@babel/types";
+import * as t47 from "@babel/types";
 function resolveProvide(ctx) {
   if (ctx.inputType === "style") return {};
   return {
@@ -4765,13 +5032,13 @@ function findOrCreateCtxProvider(root) {
 function assignProviderValue(target, key, value) {
   const getRawExp = (exp) => {
     if (!exp) return "''";
-    if (t43.isStringLiteral(exp)) {
+    if (t47.isStringLiteral(exp)) {
       return JSON.stringify(exp.value);
     }
-    if (t43.isNumericLiteral(exp)) {
+    if (t47.isNumericLiteral(exp)) {
       return exp.value.toString();
     }
-    if (t43.isIdentifier(exp)) {
+    if (t47.isIdentifier(exp)) {
       return exp.name;
     }
     try {
@@ -4787,16 +5054,16 @@ function assignProviderValue(target, key, value) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-rename-adapter.ts
-import * as t44 from "@babel/types";
+import * as t48 from "@babel/types";
 function resolveRenameAdapter(ctx) {
   return {
     "CallExpression|Identifier"(path9) {
       const node = path9.node;
-      const isCallNode = t44.isCallExpression(node);
+      const isCallNode = t48.isCallExpression(node);
       let apiName = "";
-      if (t44.isIdentifier(node)) {
+      if (t48.isIdentifier(node)) {
         apiName = node.name;
-      } else if (isCallNode && t44.isIdentifier(node.callee)) {
+      } else if (isCallNode && t48.isIdentifier(node.callee)) {
         apiName = node.callee.name;
       }
       if (!apiName) {
@@ -4858,7 +5125,7 @@ function isVueImportBinding2(binding) {
     return false;
   }
   const parent = bindingPath.parentPath?.node;
-  if (!parent || !t44.isImportDeclaration(parent)) {
+  if (!parent || !t48.isImportDeclaration(parent)) {
     return false;
   }
   const source = parent.source.value.toLowerCase();
@@ -4995,15 +5262,15 @@ function isRouterLinkBooleanCustomProp(prop) {
 }
 
 // src/core/transform/sfc/template/shared/prop-ir-utils.ts
-import * as t46 from "@babel/types";
+import * as t50 from "@babel/types";
 
 // src/shared/string-code-types.ts
 import { parseExpression as parseExpression3 } from "@babel/parser";
-import * as t45 from "@babel/types";
+import * as t49 from "@babel/types";
 var strCodeTypes = {
-  isIdentifier: isIdentifier24,
+  isIdentifier: isIdentifier28,
   isSimpleExpression,
-  isStringLiteral: isStringLiteral12
+  isStringLiteral: isStringLiteral13
 };
 function isSimpleExpression(code, excludeVar = false) {
   let node;
@@ -5012,38 +5279,38 @@ function isSimpleExpression(code, excludeVar = false) {
   } catch {
     return false;
   }
-  if (t45.isLiteral(node)) {
+  if (t49.isLiteral(node)) {
     return true;
   }
-  if (!excludeVar && t45.isIdentifier(node)) {
+  if (!excludeVar && t49.isIdentifier(node)) {
     return true;
   }
-  if (t45.isMemberExpression(node)) {
-    return isSimpleExpression(node.object) && t45.isIdentifier(node.property);
+  if (t49.isMemberExpression(node)) {
+    return isSimpleExpression(node.object) && t49.isIdentifier(node.property);
   }
-  if (t45.isObjectExpression(node) || t45.isArrayExpression(node)) {
+  if (t49.isObjectExpression(node) || t49.isArrayExpression(node)) {
     return false;
   }
-  if (t45.isCallExpression(node) || t45.isAssignmentExpression(node)) {
+  if (t49.isCallExpression(node) || t49.isAssignmentExpression(node)) {
     return false;
   }
-  if (t45.isBinaryExpression(node) || t45.isUnaryExpression(node)) {
+  if (t49.isBinaryExpression(node) || t49.isUnaryExpression(node)) {
     return true;
   }
   return false;
 }
-function isIdentifier24(code) {
+function isIdentifier28(code) {
   try {
     const node = parseExpression3(code);
-    return t45.isIdentifier(node);
+    return t49.isIdentifier(node);
   } catch {
     return false;
   }
 }
-function isStringLiteral12(code) {
+function isStringLiteral13(code) {
   try {
     const node = parseExpression3(code);
-    return t45.isStringLiteral(node);
+    return t49.isStringLiteral(node);
   } catch {
     return false;
   }
@@ -5185,23 +5452,23 @@ function resolvePropAsBabelExp(ir, ctx) {
   const mergedItems = value.merge;
   const setNameIdentifier = (target, valueName) => {
     target.content = valueName;
-    target.ast = t46.jsxIdentifier(valueName);
+    target.ast = t50.jsxIdentifier(valueName);
   };
-  const setValueExpression = (target, content, isStringLiteral13) => {
+  const setValueExpression = (target, content, isStringLiteral14) => {
     target.content = content;
-    target.ast = resolveStringExpr(content, ctx, isStringLiteral13);
+    target.ast = resolveStringExpr(content, ctx, isStringLiteral14);
   };
   const createRuntimeCall = (fnName, args) => {
     const fnArgs = args.filter(Boolean).join(",");
     return `${fnName}(${fnArgs})`;
   };
-  const applyRuntimeExpression = (expression, setName = false, nameIdentifier, isStringLiteral13) => {
+  const applyRuntimeExpression = (expression, setName = false, nameIdentifier, isStringLiteral14) => {
     if (setName && nameIdentifier) {
       setNameIdentifier(nameExp, nameIdentifier);
     }
     const dir = ADAPTER_RULES.runtime.dir;
     recordImport(ctx, dir.package, dir.target);
-    setValueExpression(value.babelExp, expression, isStringLiteral13);
+    setValueExpression(value.babelExp, expression, isStringLiteral14);
   };
   if (ir.isKeyLessVBind) {
     const dirKeyless = ADAPTER_RULES.runtime.dirKeyless;
@@ -5356,26 +5623,16 @@ function injectStyleScopeAttribute(node, ctx) {
     return;
   }
   let hasScopeId = false;
-  let hasClassOrId = false;
   for (const prop of node.props) {
-    if (prop.type === NodeTypes3.ATTRIBUTE) {
-      if (prop.name === scopeId) {
-        hasScopeId = true;
-        break;
-      }
-      if (getHasClassOrId(prop.name)) {
-        hasClassOrId = true;
-        break;
-      }
+    if (prop.type !== NodeTypes3.ATTRIBUTE) {
+      continue;
     }
-    if (prop.type === NodeTypes3.DIRECTIVE && prop.arg?.type === NodeTypes3.SIMPLE_EXPRESSION) {
-      if (getHasClassOrId(prop.arg.content)) {
-        hasClassOrId = true;
-        break;
-      }
+    if (prop.name === scopeId) {
+      hasScopeId = true;
+      break;
     }
   }
-  if (hasScopeId || !hasClassOrId) return;
+  if (hasScopeId) return;
   const attr = {
     type: NodeTypes3.ATTRIBUTE,
     name: scopeId,
@@ -5385,9 +5642,6 @@ function injectStyleScopeAttribute(node, ctx) {
   };
   node.props.push(attr);
 }
-function getHasClassOrId(ns) {
-  return isClassAttr(ns) || ns === "id";
-}
 
 // src/core/transform/sfc/template/shared/prop-merge-utils.ts
 function mergePropsIR(ctx, oldAttr, newAttr) {
@@ -5635,12 +5889,12 @@ function resolvePropertyIR(propsIR, ir, ctx, nodeIR, isDynamic = false) {
     content = propsIR.value.content = parseStyleString(content);
   }
   if (isDynamic) {
-    const isStringLiteral13 = strCodeTypes.isStringLiteral(content);
-    if (isStringLiteral13) {
+    const isStringLiteral14 = strCodeTypes.isStringLiteral(content);
+    if (isStringLiteral14) {
       content = normalizeString(content);
       propsIR.value.content = content;
     }
-    propsIR.value.isStringLiteral = isStringLiteral13;
+    propsIR.value.isStringLiteral = isStringLiteral14;
   }
   const existing = findSameProp(nodeIR.props, propsIR);
   if (existing) {
@@ -5945,27 +6199,15 @@ function applyValueModifiers(valueExp, modifiers) {
 }
 
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-on.ts
-import * as t47 from "@babel/types";
+import * as t51 from "@babel/types";
 function resolveVOn(directive, ir, ctx, nodeIR) {
   const arg = directive.arg;
   const exp = directive.exp;
   const modifiers = directive.modifiers.map((item) => item.content);
-  const captureIndex = modifiers.findIndex((modifier) => modifier === "capture");
-  let eventName = normalizeVOnEventName(arg.content);
-  let handler = resolveSpecialExpression(exp.content.trim(), ctx);
-  if (captureIndex > -1) {
-    eventName = modifiers[captureIndex] ? `${eventName}Capture` : eventName;
-    modifiers.splice(captureIndex, 1);
-  }
-  let originalVueEventName = "";
-  if (modifiers.length) {
-    originalVueEventName = `${arg.content}.${modifiers.join(".")}`;
-  } else {
-    const expr = stringToExpr(handler);
-    if (!t47.isFunctionExpression(expr) && !t47.isArrowFunctionExpression(expr) && !t47.isIdentifier(expr)) {
-      handler = `() => {${handler}}`;
-    }
-  }
+  const captureIndex = resolveCaptureModifier(modifiers);
+  const eventName = resolveEventName(arg.content, captureIndex);
+  const handler = resolveHandler(exp.content.trim(), ctx, modifiers);
+  const originalVueEventName = modifiers.length ? `${arg.content}.${modifiers.join(".")}` : "";
   const eventIR = createPropsIR(directive.rawName, eventName, handler);
   eventIR.type = 3 /* EVENT */;
   eventIR.isStatic = arg.isStatic;
@@ -5980,11 +6222,45 @@ function resolveVOn(directive, ir, ctx, nodeIR) {
   }
   nodeIR.props.push(eventIR);
 }
+function resolveCaptureModifier(modifiers) {
+  const captureIndex = modifiers.findIndex((modifier) => modifier === "capture");
+  if (captureIndex > -1) {
+    modifiers.splice(captureIndex, 1);
+  }
+  return captureIndex;
+}
+function resolveEventName(rawEventName, captureIndex) {
+  let eventName = normalizeVOnEventName(rawEventName);
+  if (captureIndex > -1) {
+    eventName = `${eventName}Capture`;
+  }
+  return eventName;
+}
 function normalizeVOnEventName(rawEventName) {
   const segments = rawEventName.split(/[:-]/g).map((segment) => segment.trim()).filter(Boolean);
   const normalized = segments.map((segment) => capitalize(camelCase(segment))).join("");
   return `on${normalized}`;
 }
+function resolveHandler(handlerContent, ctx, modifiers) {
+  let handler = resolveSpecialExpression(handlerContent, ctx);
+  if (modifiers.length) {
+    return handler;
+  }
+  const expr = stringToExpr(handler);
+  if (isConsoleCall(expr)) {
+    return "() => {}";
+  }
+  if (!isFnReference(expr)) {
+    handler = `() => {${handler}}`;
+  }
+  return handler;
+}
+function isConsoleCall(expr) {
+  return t51.isCallExpression(expr) && t51.isMemberExpression(expr.callee) && t51.isIdentifier(expr.callee.object) && expr.callee.object.name === "console";
+}
+function isFnReference(expr) {
+  return t51.isIdentifier(expr) || t51.isMemberExpression(expr) || t51.isFunction(expr);
+}
 
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-show.ts
 function resolveVShow(directive, ir, ctx, nodeIR) {
@@ -6336,7 +6612,7 @@ function transform(ast, ctx, options) {
 }
 
 // package.json
-var version = "1.6.2";
+var version = "1.7.0";
 var bin = {
   vureact: "./bin/vureact.js"
 };
@@ -6950,7 +7226,7 @@ var CompilationContext = class {
   }
   create() {
     return {
-      fileId: "",
+      fileId: Date.now().toString(),
       source: "",
       filename: "",
       imports: /* @__PURE__ */ new Map(),