npm - @vureact/compiler-core - Versions diffs - 1.8.3 → 1.8.5 - Mend

@vureact/compiler-core 1.8.3 → 1.8.5

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

Files changed (10) hide show

package/README.md +65 -61
package/README.zh-CN.md +193 -0
package/lib/{chunk-R34TQK4X.js → chunk-6FMNT76F.js} +496 -411
package/lib/{chunk-QPW3RUZH.esm.js → chunk-FWYPSB43.esm.js} +447 -362
package/lib/cli.esm.js +2 -2
package/lib/cli.js +10 -10
package/lib/compiler-core.esm.js +2 -2
package/lib/compiler-core.js +3 -3
package/package.json +2 -2
package/README.en.md +0 -192

package/lib/{chunk-QPW3RUZH.esm.js → chunk-FWYPSB43.esm.js} RENAMED Viewed

@@ -1,5 +1,5 @@
 /**
- * @vureact/compiler-core v1.8.3
+ * @vureact/compiler-core v1.8.5
  * (c) 2025-present Ruihong Zhong (Ryan John)
  * @license MIT
  */
@@ -39,7 +39,7 @@ var RUNTIME_PACKAGES = {
   },
   runtime: {
     name: PACKAGE_NAME.runtime,
-    version: "^1.1.0"
+    version: "^1.1.1"
   }
 };
 var STYLE_MODULE_NAME = "$style";
@@ -311,7 +311,8 @@ var ADAPTER_RULES = {
       type: "rename"
     },
     dirOn: {
-      target: "dir.On",
+      // fix: https://github.com/vureact-js/core/issues/49
+      target: "dir.on",
       package: PACKAGE_NAME.runtime,
       type: "rename"
     },
@@ -568,7 +569,8 @@ function buildJsxChildrenProcessor(nodeIR, ctx, state) {
 }
 function buildJsxChildren(children, ctx) {
   const result = [];
-  for (const childIR of children) {
+  const normalizedChildren = Array.isArray(children) ? children : [];
+  for (const childIR of normalizedChildren) {
     const jsxNode = buildJsxNode(childIR, ctx);
     if (!jsxNode) continue;
     result.push(jsxNode);
@@ -1178,26 +1180,38 @@ function buildCtxProviderNode(nodeIR, ctx, children) {
 // src/core/codegen/component/jsx/syntax-processor/postprocess/build-root-jsx.ts
 function buildRootJsxProcessor(nodeIR, ctx, state) {
-  if (!state.rootChildren.length) {
-    state.result = null;
+  const { rootChildren } = state;
+  const { provide } = ctx.scriptData;
+  const hasProvide = provide.isOccupied;
+  const hasChildren = rootChildren.length > 0;
+  const setResult = (elem) => {
+    state.result = elem ?? null;
+  };
+  if (hasProvide) {
+    const provider = buildCtxProviderNode(provide, ctx, rootChildren);
+    if (!hasChildren) {
+      setResult(buildFragmentNode([provider]));
+    } else {
+      setResult(provider);
+    }
     return;
   }
-  const { provide } = ctx.scriptData;
-  if (provide.isOccupied) {
-    state.result = buildCtxProviderNode(provide, ctx, state.rootChildren);
+  if (!hasChildren) {
+    setResult();
     return;
   }
-  state.result = buildFragmentNode(state.rootChildren);
+  setResult(buildFragmentNode(rootChildren));
   void nodeIR;
 }
 // src/core/codegen/component/jsx/syntax-processor/index.ts
 function buildJSXChild(nodeIR, ctx) {
+  const templateIR = nodeIR || { children: [] };
   const state = {
     rootChildren: [],
     result: null
   };
-  jsxBuilder(nodeIR, ctx, state, {
+  jsxBuilder(templateIR, ctx, state, {
     preprocess: [],
     process: [buildJsxChildrenProcessor],
     postprocess: [buildRootJsxProcessor]
@@ -1215,7 +1229,7 @@ function jsxBuilder(nodeIR, ctx, state, options) {
 // src/core/codegen/component/jsx/index.ts
 function buildJSX(nodeIR, ctx) {
-  if (!nodeIR?.children.length) {
+  if (!nodeIR?.children.length && ctx.inputType !== "sfc") {
     return null;
   }
   return buildJSXChild(nodeIR, ctx);
@@ -3220,8 +3234,51 @@ function resolveSfcCssImport(ctx) {
   scriptIR.imports.push(importDecl);
 }
-// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-async-component.ts
+// src/core/transform/sfc/script/syntax-processor/postprocess/resolve-vue-type-as-any.ts
 import * as t25 from "@babel/types";
+function resolveVueTypeAsAny(ctx) {
+  return {
+    TSTypeReference(path8) {
+      if (isVueTypeRef(path8)) {
+        replaceNode(path8, t25.tsAnyKeyword(), path8.node);
+      }
+    }
+  };
+}
+function isVueTypeRef(path8) {
+  const id = resolveTypeNameId(path8.node.typeName);
+  return id !== null && isVueImport(id, path8);
+}
+function resolveTypeNameId(typeName) {
+  if (t25.isIdentifier(typeName)) {
+    return typeName;
+  }
+  if (t25.isTSQualifiedName(typeName)) {
+    let node = typeName;
+    while (t25.isTSQualifiedName(node)) {
+      node = node.left;
+    }
+    return t25.isIdentifier(node) ? node : null;
+  }
+  return null;
+}
+function isVueImport(id, path8) {
+  const binding = path8.scope.getBinding(id.name);
+  if (!binding) return false;
+  const bp = binding.path;
+  if (!bp.isImportSpecifier() && !bp.isImportDefaultSpecifier()) {
+    return false;
+  }
+  const importDecl = bp.parentPath;
+  if (!importDecl.isImportDeclaration()) {
+    return false;
+  }
+  const moduleName = importDecl.node.source.value;
+  return VUE_PACKAGES.some((pkg) => moduleName.includes(pkg));
+}
+// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-async-component.ts
+import * as t26 from "@babel/types";
 function resolveDefineAsyncComponent(ctx) {
   return {
     CallExpression(path8) {
@@ -3230,11 +3287,11 @@ function resolveDefineAsyncComponent(ctx) {
         return;
       }
       const [arg] = node.arguments;
-      if (!t25.isObjectExpression(arg)) {
+      if (!t26.isObjectExpression(arg)) {
         return;
       }
       for (const prop of arg.properties) {
-        if (!t25.isObjectProperty(prop) || !t25.isIdentifier(prop.key) || prop.key.name !== "hydrate") {
+        if (!t26.isObjectProperty(prop) || !t26.isIdentifier(prop.key) || prop.key.name !== "hydrate") {
           continue;
         }
         logger.warn('Unsupported option "hydrate"', {
@@ -3249,24 +3306,24 @@ function resolveDefineAsyncComponent(ctx) {
 }
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-expose.ts
-import * as t27 from "@babel/types";
+import * as t28 from "@babel/types";
 // src/core/transform/sfc/script/shared/hook-creator.ts
-import * as t26 from "@babel/types";
+import * as t27 from "@babel/types";
 function createUseCallback(body, deps) {
-  return t26.callExpression(t26.identifier(REACT_API_MAP.useCallback), [
+  return t27.callExpression(t27.identifier(REACT_API_MAP.useCallback), [
     body,
-    deps ?? t26.arrayExpression([])
+    deps ?? t27.arrayExpression([])
   ]);
 }
 function createUseMemo(body, deps) {
-  return t26.callExpression(t26.identifier(REACT_API_MAP.useMemo), [
-    t26.arrowFunctionExpression([], body),
-    deps ?? t26.arrayExpression([])
+  return t27.callExpression(t27.identifier(REACT_API_MAP.useMemo), [
+    t27.arrowFunctionExpression([], body),
+    deps ?? t27.arrayExpression([])
   ]);
 }
 function createUseImperativeHandle(refId, init) {
-  return t26.callExpression(t26.identifier(REACT_API_MAP.useImperativeHandle), [refId, init]);
+  return t27.callExpression(t27.identifier(REACT_API_MAP.useImperativeHandle), [refId, init]);
 }
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-expose.ts
@@ -3287,16 +3344,16 @@ function resolveDefineExpose(ctx) {
       const adapter = ADAPTER_RULES.react[MACRO_API_NAMES.expose];
       recordImport(ctx, adapter.package, REACT_API_MAP.forwardRef);
       recordImport(ctx, adapter.package, adapter.target);
-      if (!t27.isObjectExpression(expose) && !t27.isFunction(expose)) {
+      if (!t28.isObjectExpression(expose) && !t28.isFunction(expose)) {
         logger.warn("Non-deterministic object literal may cause unknown risks.", {
           file: filename,
           loc: expose.loc,
           source: scriptData.source
         });
       }
-      const init = !t27.isFunction(expose) ? t27.arrowFunctionExpression([], expose) : expose;
+      const init = !t28.isFunction(expose) ? t28.arrowFunctionExpression([], expose) : expose;
       const { forwardRef } = scriptData;
-      const newNode = createUseImperativeHandle(t27.identifier(forwardRef.refField), init);
+      const newNode = createUseImperativeHandle(t28.identifier(forwardRef.refField), init);
       forwardRef.enabled = true;
       replaceNode(path8, newNode, node);
     }
@@ -3317,7 +3374,7 @@ function resolveDefineOptions(ctx) {
 }
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-emit-calls.ts
-import * as t28 from "@babel/types";
+import * as t29 from "@babel/types";
 function resolveEmitCalls(ctx) {
   const formatEmitEventName = (raw) => {
     if (raw.startsWith("update:")) {
@@ -3331,7 +3388,7 @@ function resolveEmitCalls(ctx) {
     CallExpression(path8) {
       const { node } = path8;
       const { filename, templateData, scriptData } = ctx;
-      if (!t28.isIdentifier(node.callee)) return;
+      if (!t29.isIdentifier(node.callee)) return;
       const { name } = node.callee;
       const checkIfFromDefineEmits = () => {
         let result = false;
@@ -3343,7 +3400,7 @@ function resolveEmitCalls(ctx) {
           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)) {
+            if (t29.isVariableDeclarator(parent) && t29.isCallExpression(parent.init) && t29.isIdentifier(parent.init.callee)) {
               result = parent.init.callee.name === MACRO_API_NAMES.emits;
             }
           }
@@ -3353,9 +3410,9 @@ function resolveEmitCalls(ctx) {
       if (!checkIfFromDefineEmits()) return;
       const [callee, ...args] = node.arguments;
       let propCall;
-      if (t28.isStringLiteral(callee)) {
+      if (t29.isStringLiteral(callee)) {
         const eventName = formatEmitEventName(callee.value);
-        propCall = createPropCall(ctx.propField, t28.identifier(eventName), args);
+        propCall = createPropCall(ctx.propField, t29.identifier(eventName), args);
       } else {
         propCall = createPropCall(ctx.propField, callee, args, true);
         logger.error(
@@ -3372,38 +3429,38 @@ function resolveEmitCalls(ctx) {
   };
 }
 function createPropCall(rootName, callee, args, computed = false) {
-  return t28.optionalCallExpression(
-    t28.memberExpression(t28.identifier(rootName), callee, computed),
+  return t29.optionalCallExpression(
+    t29.memberExpression(t29.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";
+import * as t37 from "@babel/types";
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-emits.ts
-import * as t30 from "@babel/types";
+import * as t31 from "@babel/types";
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/shared.ts
-import * as t29 from "@babel/types";
+import * as t30 from "@babel/types";
 function cloneCallableParams(params) {
   const cloneCallableParam = (param, index) => {
-    if (t29.isRestElement(param)) {
+    if (t30.isRestElement(param)) {
       const arg = param.argument;
-      const name = t29.isIdentifier(arg) ? arg.name : `args${index}`;
-      const rest = t29.restElement(t29.identifier(name));
-      rest.typeAnnotation = param.typeAnnotation || (t29.isIdentifier(arg) ? arg.typeAnnotation : null) || t29.tsTypeAnnotation(t29.tsArrayType(t29.tsAnyKeyword()));
+      const name = t30.isIdentifier(arg) ? arg.name : `args${index}`;
+      const rest = t30.restElement(t30.identifier(name));
+      rest.typeAnnotation = param.typeAnnotation || (t30.isIdentifier(arg) ? arg.typeAnnotation : null) || t30.tsTypeAnnotation(t30.tsArrayType(t30.tsAnyKeyword()));
       return rest;
     }
-    if (t29.isIdentifier(param)) {
-      const id = t29.identifier(param.name || `arg${index}`);
+    if (t30.isIdentifier(param)) {
+      const id = t30.identifier(param.name || `arg${index}`);
       id.optional = param.optional;
-      id.typeAnnotation = param.typeAnnotation || t29.tsTypeAnnotation(t29.tsAnyKeyword());
+      id.typeAnnotation = param.typeAnnotation || t30.tsTypeAnnotation(t30.tsAnyKeyword());
       return id;
     }
-    const fallback = t29.identifier(`arg${index}`);
-    fallback.typeAnnotation = t29.tsTypeAnnotation(t29.tsAnyKeyword());
+    const fallback = t30.identifier(`arg${index}`);
+    fallback.typeAnnotation = t30.tsTypeAnnotation(t30.tsAnyKeyword());
     return fallback;
   };
   return params.map(cloneCallableParam);
@@ -3413,18 +3470,18 @@ function cloneCallableParams(params) {
 function resolveEmitsTopLevelTypes(ctx) {
   return {
     "TSInterfaceDeclaration|TSTypeAliasDeclaration"(path8) {
-      if (!t30.isProgram(path8.parent)) return;
+      if (!t31.isProgram(path8.parent)) return;
       const { node } = path8;
-      if (t30.isTSInterfaceDeclaration(node)) {
-        const typeLiteral = t30.tsTypeLiteral(node.body.body);
+      if (t31.isTSInterfaceDeclaration(node)) {
+        const typeLiteral = t31.tsTypeLiteral(node.body.body);
         if (!hasEmitsSignatureInType(typeLiteral)) return;
         const resolved = resolveTopLevelEmitType(typeLiteral);
-        if (resolved && t30.isTSTypeLiteral(resolved)) {
+        if (resolved && t31.isTSTypeLiteral(resolved)) {
           node.body.body = resolved.members;
         }
         return;
       }
-      if (t30.isTSTypeAliasDeclaration(node)) {
+      if (t31.isTSTypeAliasDeclaration(node)) {
         if (!hasEmitsSignatureInType(node.typeAnnotation)) return;
         const resolved = resolveTopLevelEmitType(node.typeAnnotation);
         if (resolved) {
@@ -3435,47 +3492,47 @@ function resolveEmitsTopLevelTypes(ctx) {
   };
 }
 function resolveTopLevelEmitType(tsType) {
-  if (t30.isTSParenthesizedType(tsType)) {
+  if (t31.isTSParenthesizedType(tsType)) {
     return resolveTopLevelEmitType(tsType.typeAnnotation);
   }
-  if (t30.isTSTypeReference(tsType)) {
+  if (t31.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return tsType;
     }
     const params = tsType.typeParameters.params.map((param) => resolveTopLevelEmitType(param)).filter(Boolean);
-    return t30.tsTypeReference(
+    return t31.tsTypeReference(
       tsType.typeName,
-      t30.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
+      t31.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
     );
   }
-  if (t30.isTSIntersectionType(tsType)) {
+  if (t31.isTSIntersectionType(tsType)) {
     const types = tsType.types.map(resolveTopLevelEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t30.tsIntersectionType(types);
+    return t31.tsIntersectionType(types);
   }
-  if (t30.isTSUnionType(tsType)) {
+  if (t31.isTSUnionType(tsType)) {
     const types = tsType.types.map(resolveTopLevelEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t30.tsUnionType(types);
+    return t31.tsUnionType(types);
   }
-  if (t30.isTSTypeLiteral(tsType)) {
+  if (t31.isTSTypeLiteral(tsType)) {
     const members = [];
     for (const member of tsType.members) {
-      if (t30.isTSCallSignatureDeclaration(member)) {
+      if (t31.isTSCallSignatureDeclaration(member)) {
         members.push(...resolveEmitPropsFromCallSignature(member));
         continue;
       }
       members.push(member);
     }
     if (!members.length) return null;
-    return t30.tsTypeLiteral(members);
+    return t31.tsTypeLiteral(members);
   }
-  if (t30.isTSFunctionType(tsType)) {
+  if (t31.isTSFunctionType(tsType)) {
     const props = resolveEmitPropsFromCallable(tsType.parameters, tsType.typeAnnotation);
     if (!props.length) return null;
-    return t30.tsTypeLiteral(props);
+    return t31.tsTypeLiteral(props);
   }
   return tsType;
 }
@@ -3496,41 +3553,41 @@ function processInferredTypes(ctx, runtimeArg) {
     propsTSIface: { emitTypes }
   } = ctx.scriptData;
   const members = [];
-  if (t30.isArrayExpression(runtimeArg)) {
+  if (t31.isArrayExpression(runtimeArg)) {
     for (const element of runtimeArg.elements) {
-      if (!element || !t30.isStringLiteral(element)) continue;
+      if (!element || !t31.isStringLiteral(element)) continue;
       const handlerName = resolveEmitHandlerName(element.value);
       const key = buildKey(handlerName);
-      const fnType = t30.tsFunctionType(
+      const fnType = t31.tsFunctionType(
         null,
         [createRestAnyParam("args")],
-        t30.tsTypeAnnotation(t30.tsAnyKeyword())
+        t31.tsTypeAnnotation(t31.tsAnyKeyword())
       );
-      const prop = t30.tsPropertySignature(key, t30.tsTypeAnnotation(fnType));
+      const prop = t31.tsPropertySignature(key, t31.tsTypeAnnotation(fnType));
       prop.optional = true;
       members.push(prop);
     }
     if (members.length) {
-      emitTypes.push(t30.tsTypeLiteral(members));
+      emitTypes.push(t31.tsTypeLiteral(members));
     }
     return;
   }
-  if (t30.isObjectExpression(runtimeArg)) {
+  if (t31.isObjectExpression(runtimeArg)) {
     for (const prop of runtimeArg.properties) {
-      if (!t30.isObjectProperty(prop)) continue;
-      if (t30.isSpreadElement(prop)) continue;
+      if (!t31.isObjectProperty(prop)) continue;
+      if (t31.isSpreadElement(prop)) continue;
       const rawName = resolvePropName(prop.key);
       if (!rawName) continue;
       const handlerName = resolveEmitHandlerName(rawName);
       const key = buildKey(handlerName);
-      const params = t30.isArrayExpression(prop.value) ? resolveRuntimeTupleParams(prop.value) : [createRestAnyParam("args")];
-      const fnType = t30.tsFunctionType(null, params, t30.tsTypeAnnotation(t30.tsAnyKeyword()));
-      const propSig = t30.tsPropertySignature(key, t30.tsTypeAnnotation(fnType));
+      const params = t31.isArrayExpression(prop.value) ? resolveRuntimeTupleParams(prop.value) : [createRestAnyParam("args")];
+      const fnType = t31.tsFunctionType(null, params, t31.tsTypeAnnotation(t31.tsAnyKeyword()));
+      const propSig = t31.tsPropertySignature(key, t31.tsTypeAnnotation(fnType));
       propSig.optional = true;
       members.push(propSig);
     }
     if (members.length) {
-      emitTypes.push(t30.tsTypeLiteral(members));
+      emitTypes.push(t31.tsTypeLiteral(members));
     }
   }
 }
@@ -3551,129 +3608,129 @@ function resolveEmitHandlerName(rawName) {
   return `on${name}`;
 }
 function resolvePropName(key) {
-  if (t30.isIdentifier(key)) return key.name;
-  if (t30.isStringLiteral(key)) return key.value;
-  if (t30.isNumericLiteral(key)) return String(key.value);
+  if (t31.isIdentifier(key)) return key.name;
+  if (t31.isStringLiteral(key)) return key.value;
+  if (t31.isNumericLiteral(key)) return String(key.value);
   return null;
 }
 function buildKey(name) {
-  return t30.isValidIdentifier(name) ? t30.identifier(name) : t30.stringLiteral(name);
+  return t31.isValidIdentifier(name) ? t31.identifier(name) : t31.stringLiteral(name);
 }
 function createRestAnyParam(name) {
-  const id = t30.identifier(name);
-  const rest = t30.restElement(id);
-  rest.typeAnnotation = t30.tsTypeAnnotation(t30.tsArrayType(t30.tsAnyKeyword()));
+  const id = t31.identifier(name);
+  const rest = t31.restElement(id);
+  rest.typeAnnotation = t31.tsTypeAnnotation(t31.tsArrayType(t31.tsAnyKeyword()));
   return rest;
 }
 function resolveRuntimeTupleParams(value) {
   const params = [];
   value.elements.forEach((element, index) => {
     if (!element) return;
-    if (t30.isSpreadElement(element)) {
+    if (t31.isSpreadElement(element)) {
       params.push(createRestAnyParam(`args${index}`));
       return;
     }
-    if (t30.isIdentifier(element)) {
-      const id = t30.identifier(element.name);
-      id.typeAnnotation = element.typeAnnotation || t30.tsTypeAnnotation(t30.tsAnyKeyword());
+    if (t31.isIdentifier(element)) {
+      const id = t31.identifier(element.name);
+      id.typeAnnotation = element.typeAnnotation || t31.tsTypeAnnotation(t31.tsAnyKeyword());
       params.push(id);
       return;
     }
-    if (t30.isTSAsExpression(element)) {
-      const id = t30.identifier(`arg${index}`);
-      id.typeAnnotation = t30.tsTypeAnnotation(element.typeAnnotation);
+    if (t31.isTSAsExpression(element)) {
+      const id = t31.identifier(`arg${index}`);
+      id.typeAnnotation = t31.tsTypeAnnotation(element.typeAnnotation);
       params.push(id);
       return;
     }
-    const fallback = t30.identifier(`arg${index}`);
-    fallback.typeAnnotation = t30.tsTypeAnnotation(t30.tsAnyKeyword());
+    const fallback = t31.identifier(`arg${index}`);
+    fallback.typeAnnotation = t31.tsTypeAnnotation(t31.tsAnyKeyword());
     params.push(fallback);
   });
   return params;
 }
 function resolveExplicitEmitType(tsType) {
-  if (t30.isTSParenthesizedType(tsType)) {
+  if (t31.isTSParenthesizedType(tsType)) {
     return resolveExplicitEmitType(tsType.typeAnnotation);
   }
-  if (t30.isTSTypeReference(tsType)) {
+  if (t31.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return tsType;
     }
     const params = tsType.typeParameters.params.map((param) => resolveExplicitEmitType(param)).filter(Boolean);
-    return t30.tsTypeReference(
+    return t31.tsTypeReference(
       tsType.typeName,
-      t30.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
+      t31.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
     );
   }
-  if (t30.isTSIntersectionType(tsType)) {
+  if (t31.isTSIntersectionType(tsType)) {
     const types = tsType.types.map(resolveExplicitEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t30.tsIntersectionType(types);
+    return t31.tsIntersectionType(types);
   }
-  if (t30.isTSUnionType(tsType)) {
+  if (t31.isTSUnionType(tsType)) {
     const types = tsType.types.map(resolveExplicitEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t30.tsUnionType(types);
+    return t31.tsUnionType(types);
   }
-  if (t30.isTSTypeLiteral(tsType)) {
+  if (t31.isTSTypeLiteral(tsType)) {
     const members = [];
     for (const member of tsType.members) {
-      if (t30.isTSPropertySignature(member)) {
+      if (t31.isTSPropertySignature(member)) {
         const prop = resolveEmitPropFromPropertySignature(member);
         if (prop) members.push(prop);
         continue;
       }
-      if (t30.isTSCallSignatureDeclaration(member)) {
+      if (t31.isTSCallSignatureDeclaration(member)) {
         members.push(...resolveEmitPropsFromCallSignature(member));
         continue;
       }
     }
     if (!members.length) return null;
-    return t30.tsTypeLiteral(members);
+    return t31.tsTypeLiteral(members);
   }
-  if (t30.isTSFunctionType(tsType)) {
+  if (t31.isTSFunctionType(tsType)) {
     const props = resolveEmitPropsFromCallable(tsType.parameters, tsType.typeAnnotation);
     if (!props.length) return null;
-    return t30.tsTypeLiteral(props);
+    return t31.tsTypeLiteral(props);
   }
   return tsType;
 }
 function hasEmitsSignatureInType(tsType) {
-  if (t30.isTSParenthesizedType(tsType)) {
+  if (t31.isTSParenthesizedType(tsType)) {
     return hasEmitsSignatureInType(tsType.typeAnnotation);
   }
-  if (t30.isTSTypeReference(tsType)) {
+  if (t31.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return false;
     }
     return tsType.typeParameters.params.some(hasEmitsSignatureInType);
   }
-  if (t30.isTSIntersectionType(tsType) || t30.isTSUnionType(tsType)) {
+  if (t31.isTSIntersectionType(tsType) || t31.isTSUnionType(tsType)) {
     return tsType.types.some(hasEmitsSignatureInType);
   }
-  if (t30.isTSTypeLiteral(tsType)) {
+  if (t31.isTSTypeLiteral(tsType)) {
     return tsType.members.some(hasEmitsSignatureInMember);
   }
-  if (t30.isTSFunctionType(tsType)) {
+  if (t31.isTSFunctionType(tsType)) {
     return isEmitsCallable(tsType.parameters);
   }
   return false;
 }
 function hasEmitsSignatureInMember(member) {
-  if (t30.isTSCallSignatureDeclaration(member)) {
+  if (t31.isTSCallSignatureDeclaration(member)) {
     return isEmitsCallable(member.parameters);
   }
   return false;
 }
 function isEmitsCallable(parameters) {
   const [eventParam] = parameters;
-  if (!eventParam || !t30.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
+  if (!eventParam || !t31.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
     return false;
   }
   const { typeAnnotation } = eventParam;
-  if (t30.isNoop(typeAnnotation)) return false;
+  if (t31.isNoop(typeAnnotation)) return false;
   return resolveEventNames(typeAnnotation.typeAnnotation).length > 0;
 }
 function resolveEmitPropFromPropertySignature(member) {
@@ -3683,19 +3740,19 @@ function resolveEmitPropFromPropertySignature(member) {
   const key = buildKey(handlerName);
   const typeAnnotation = member.typeAnnotation?.typeAnnotation;
   let params = [];
-  let returnType = t30.tsAnyKeyword();
-  if (typeAnnotation && t30.isTSFunctionType(typeAnnotation)) {
+  let returnType = t31.tsAnyKeyword();
+  if (typeAnnotation && t31.isTSFunctionType(typeAnnotation)) {
     params = cloneCallableParams(typeAnnotation.parameters);
     returnType = typeAnnotation.typeAnnotation?.typeAnnotation ?? returnType;
-  } else if (typeAnnotation && t30.isTSTupleType(typeAnnotation)) {
+  } else if (typeAnnotation && t31.isTSTupleType(typeAnnotation)) {
     params = resolveTupleTypeParams(typeAnnotation);
   } else if (typeAnnotation) {
-    const id = t30.identifier("value");
-    id.typeAnnotation = t30.tsTypeAnnotation(typeAnnotation);
+    const id = t31.identifier("value");
+    id.typeAnnotation = t31.tsTypeAnnotation(typeAnnotation);
     params = [id];
   }
-  const fnType = t30.tsFunctionType(null, params, t30.tsTypeAnnotation(returnType));
-  const prop = t30.tsPropertySignature(key, t30.tsTypeAnnotation(fnType));
+  const fnType = t31.tsFunctionType(null, params, t31.tsTypeAnnotation(returnType));
+  const prop = t31.tsPropertySignature(key, t31.tsTypeAnnotation(fnType));
   prop.optional = !!member.optional;
   return prop;
 }
@@ -3704,32 +3761,32 @@ function resolveEmitPropsFromCallSignature(member) {
 }
 function resolveEmitPropsFromCallable(parameters, typeAnnotation) {
   const [eventParam, ...restParams] = parameters;
-  if (!eventParam || !t30.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
+  if (!eventParam || !t31.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
     return [];
   }
   const { typeAnnotation: paramTypeAnnotation } = eventParam;
-  if (t30.isNoop(paramTypeAnnotation)) return [];
+  if (t31.isNoop(paramTypeAnnotation)) return [];
   const eventNames = resolveEventNames(paramTypeAnnotation.typeAnnotation);
   if (!eventNames.length) return [];
-  const returnType = typeAnnotation?.typeAnnotation ?? t30.tsAnyKeyword();
+  const returnType = typeAnnotation?.typeAnnotation ?? t31.tsAnyKeyword();
   return eventNames.map((eventName) => {
     const handlerName = resolveEmitHandlerName(eventName);
     const key = buildKey(handlerName);
     const params = cloneCallableParams(restParams);
-    const fnType = t30.tsFunctionType(null, params, t30.tsTypeAnnotation(returnType));
-    const prop = t30.tsPropertySignature(key, t30.tsTypeAnnotation(fnType));
+    const fnType = t31.tsFunctionType(null, params, t31.tsTypeAnnotation(returnType));
+    const prop = t31.tsPropertySignature(key, t31.tsTypeAnnotation(fnType));
     prop.optional = true;
     return prop;
   });
 }
 function resolveEventNames(type) {
-  if (t30.isTSLiteralType(type) && t30.isStringLiteral(type.literal)) {
+  if (t31.isTSLiteralType(type) && t31.isStringLiteral(type.literal)) {
     return [type.literal.value];
   }
-  if (t30.isTSUnionType(type)) {
+  if (t31.isTSUnionType(type)) {
     return type.types.flatMap(resolveEventNames);
   }
-  if (t30.isTSParenthesizedType(type)) {
+  if (t31.isTSParenthesizedType(type)) {
     return resolveEventNames(type.typeAnnotation);
   }
   return [];
@@ -3742,44 +3799,44 @@ function resolveTupleTypeParams(tuple) {
   return params;
 }
 function resolveTupleElementParam(element, index) {
-  const isNamedTuple = typeof t30.isTSNamedTupleMember === "function" && t30.isTSNamedTupleMember(element);
+  const isNamedTuple = typeof t31.isTSNamedTupleMember === "function" && t31.isTSNamedTupleMember(element);
   if (isNamedTuple) {
     const tupleMember = element;
     const name = tupleMember.label?.name || `arg${index}`;
     let innerType = tupleMember.elementType;
     let optional = tupleMember.optional;
-    if (t30.isTSOptionalType(innerType)) {
+    if (t31.isTSOptionalType(innerType)) {
       optional = true;
       innerType = innerType.typeAnnotation;
     }
-    if (t30.isTSRestType(innerType)) {
-      const rest = t30.restElement(t30.identifier(name));
-      rest.typeAnnotation = t30.tsTypeAnnotation(innerType.typeAnnotation);
+    if (t31.isTSRestType(innerType)) {
+      const rest = t31.restElement(t31.identifier(name));
+      rest.typeAnnotation = t31.tsTypeAnnotation(innerType.typeAnnotation);
       return rest;
     }
-    const id2 = t30.identifier(name);
+    const id2 = t31.identifier(name);
     id2.optional = optional;
-    id2.typeAnnotation = t30.tsTypeAnnotation(innerType);
+    id2.typeAnnotation = t31.tsTypeAnnotation(innerType);
     return id2;
   }
-  if (t30.isTSRestType(element)) {
-    const rest = t30.restElement(t30.identifier(`args${index}`));
-    rest.typeAnnotation = t30.tsTypeAnnotation(element.typeAnnotation);
+  if (t31.isTSRestType(element)) {
+    const rest = t31.restElement(t31.identifier(`args${index}`));
+    rest.typeAnnotation = t31.tsTypeAnnotation(element.typeAnnotation);
     return rest;
   }
-  if (t30.isTSOptionalType(element)) {
-    const id2 = t30.identifier(`arg${index}`);
+  if (t31.isTSOptionalType(element)) {
+    const id2 = t31.identifier(`arg${index}`);
     id2.optional = true;
-    id2.typeAnnotation = t30.tsTypeAnnotation(element.typeAnnotation);
+    id2.typeAnnotation = t31.tsTypeAnnotation(element.typeAnnotation);
     return id2;
   }
-  const id = t30.identifier(`arg${index}`);
-  id.typeAnnotation = t30.tsTypeAnnotation(element);
+  const id = t31.identifier(`arg${index}`);
+  id.typeAnnotation = t31.tsTypeAnnotation(element);
   return id;
 }
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-props.ts
-import * as t31 from "@babel/types";
+import * as t32 from "@babel/types";
 function resolveDefinePropsIface(path8, ctx) {
   const { node } = path8;
   const [runtimeArg] = node.arguments;
@@ -3799,38 +3856,38 @@ function processInferredTypes2(ctx, runtimeArg) {
   } = scriptData;
   if (!runtimeArg) return;
   const members = [];
-  if (t31.isArrayExpression(runtimeArg)) {
+  if (t32.isArrayExpression(runtimeArg)) {
     for (const element of runtimeArg.elements) {
-      if (!element || !t31.isStringLiteral(element)) continue;
-      const key = t31.isValidIdentifier(element.value) ? t31.identifier(element.value) : t31.stringLiteral(element.value);
-      const prop = t31.tsPropertySignature(key, t31.tsTypeAnnotation(t31.tsAnyKeyword()));
+      if (!element || !t32.isStringLiteral(element)) continue;
+      const key = t32.isValidIdentifier(element.value) ? t32.identifier(element.value) : t32.stringLiteral(element.value);
+      const prop = t32.tsPropertySignature(key, t32.tsTypeAnnotation(t32.tsAnyKeyword()));
       prop.optional = true;
       members.push(prop);
     }
     if (members.length) {
-      propsTypes.push(t31.tsTypeLiteral(members));
+      propsTypes.push(t32.tsTypeLiteral(members));
     }
     return;
   }
-  if (t31.isObjectExpression(runtimeArg)) {
+  if (t32.isObjectExpression(runtimeArg)) {
     for (const prop of runtimeArg.properties) {
-      if (!t31.isObjectProperty(prop)) continue;
-      if (t31.isSpreadElement(prop)) continue;
+      if (!t32.isObjectProperty(prop)) continue;
+      if (t32.isSpreadElement(prop)) continue;
       const key = prop.key;
       let propName = null;
-      if (t31.isIdentifier(key)) propName = key.name;
-      if (t31.isStringLiteral(key)) propName = key.value;
-      if (t31.isNumericLiteral(key)) propName = String(key.value);
+      if (t32.isIdentifier(key)) propName = key.name;
+      if (t32.isStringLiteral(key)) propName = key.value;
+      if (t32.isNumericLiteral(key)) propName = String(key.value);
       if (!propName) continue;
       const { type, required } = resolveRuntimePropMeta(prop.value);
-      const tsType = type ?? t31.tsAnyKeyword();
-      const tsKey = t31.isValidIdentifier(propName) ? t31.identifier(propName) : t31.stringLiteral(propName);
-      const tsProp = t31.tsPropertySignature(tsKey, t31.tsTypeAnnotation(tsType));
+      const tsType = type ?? t32.tsAnyKeyword();
+      const tsKey = t32.isValidIdentifier(propName) ? t32.identifier(propName) : t32.stringLiteral(propName);
+      const tsProp = t32.tsPropertySignature(tsKey, t32.tsTypeAnnotation(tsType));
       tsProp.optional = !required;
       members.push(tsProp);
     }
     if (members.length) {
-      propsTypes.push(t31.tsTypeLiteral(members));
+      propsTypes.push(t32.tsTypeLiteral(members));
     }
     return;
   }
@@ -3844,42 +3901,42 @@ function processInferredTypes2(ctx, runtimeArg) {
   );
 }
 function resolveRuntimePropMeta(value) {
-  if (t31.isIdentifier(value)) {
+  if (t32.isIdentifier(value)) {
     return {
       type: mapRuntimeTypeToTSType(value),
       required: false
     };
   }
-  if (t31.isArrayExpression(value)) {
+  if (t32.isArrayExpression(value)) {
     return {
       type: resolveRuntimeUnionType(value),
       required: false
     };
   }
-  if (!t31.isObjectExpression(value)) {
+  if (!t32.isObjectExpression(value)) {
     return { required: false };
   }
   let type;
   let required = false;
   for (const prop of value.properties) {
-    if (!t31.isObjectProperty(prop)) continue;
-    if (t31.isSpreadElement(prop)) continue;
+    if (!t32.isObjectProperty(prop)) continue;
+    if (t32.isSpreadElement(prop)) continue;
     const key = prop.key;
-    const propName = t31.isIdentifier(key) ? key.name : t31.isStringLiteral(key) ? key.value : null;
+    const propName = t32.isIdentifier(key) ? key.name : t32.isStringLiteral(key) ? key.value : null;
     if (!propName) continue;
     if (propName === "type") {
       const valueNode = prop.value;
-      if (t31.isArrayExpression(valueNode)) {
+      if (t32.isArrayExpression(valueNode)) {
         type = resolveRuntimeUnionType(valueNode);
         continue;
       }
-      if (t31.isIdentifier(valueNode)) {
+      if (t32.isIdentifier(valueNode)) {
         type = mapRuntimeTypeToTSType(valueNode);
         continue;
       }
     }
     if (propName === "required") {
-      if (t31.isBooleanLiteral(prop.value)) {
+      if (t32.isBooleanLiteral(prop.value)) {
         required = prop.value.value;
       }
     }
@@ -3889,80 +3946,80 @@ function resolveRuntimePropMeta(value) {
 function resolveRuntimeUnionType(value) {
   const types = [];
   for (const element of value.elements) {
-    if (!element || !t31.isIdentifier(element)) continue;
+    if (!element || !t32.isIdentifier(element)) continue;
     const resolved = mapRuntimeTypeToTSType(element);
     if (resolved) types.push(resolved);
   }
-  if (!types.length) return t31.tsAnyKeyword();
+  if (!types.length) return t32.tsAnyKeyword();
   if (types.length === 1) return types[0];
-  return t31.tsUnionType(types);
+  return t32.tsUnionType(types);
 }
 function mapRuntimeTypeToTSType(value) {
   switch (value.name) {
     case "String":
-      return t31.tsStringKeyword();
+      return t32.tsStringKeyword();
     case "Number":
-      return t31.tsNumberKeyword();
+      return t32.tsNumberKeyword();
     case "Boolean":
-      return t31.tsBooleanKeyword();
+      return t32.tsBooleanKeyword();
     case "Object":
-      return t31.tsTypeLiteral([]);
+      return t32.tsTypeLiteral([]);
     case "Array":
-      return t31.tsArrayType(t31.tsAnyKeyword());
+      return t32.tsArrayType(t32.tsAnyKeyword());
     case "Function":
-      return t31.tsFunctionType(null, [], t31.tsTypeAnnotation(t31.tsAnyKeyword()));
+      return t32.tsFunctionType(null, [], t32.tsTypeAnnotation(t32.tsAnyKeyword()));
     case "Symbol":
-      return t31.tsSymbolKeyword();
+      return t32.tsSymbolKeyword();
     case "BigInt":
-      return t31.tsBigIntKeyword();
+      return t32.tsBigIntKeyword();
     default:
-      return t31.tsAnyKeyword();
+      return t32.tsAnyKeyword();
   }
 }
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/type-resolver.ts
-import * as t34 from "@babel/types";
+import * as t35 from "@babel/types";
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/slot-builder.ts
-import * as t32 from "@babel/types";
+import * as t33 from "@babel/types";
 var SLOT_DEFAULT_NAME = "default";
 var SLOT_CHILDREN_NAME = "children";
 var SLOT_FN_PARAM_NAME = "props";
 function buildSlotPropSignature(rawName, params, optional) {
   const propName = rawName === SLOT_DEFAULT_NAME ? SLOT_CHILDREN_NAME : rawName;
-  const key = t32.isValidIdentifier(propName) ? t32.identifier(propName) : t32.stringLiteral(propName);
-  const reactNodeType = t32.tsTypeAnnotation(
-    t32.tsTypeReference(t32.identifier(REACT_API_MAP.ReactNode))
+  const key = t33.isValidIdentifier(propName) ? t33.identifier(propName) : t33.stringLiteral(propName);
+  const reactNodeType = t33.tsTypeAnnotation(
+    t33.tsTypeReference(t33.identifier(REACT_API_MAP.ReactNode))
   );
   let typeAnnotation;
   if (rawName === SLOT_DEFAULT_NAME && params.length === 0 || params.length === 0) {
     typeAnnotation = reactNodeType;
   } else {
-    const fnType = t32.tsFunctionType(null, params, reactNodeType);
-    typeAnnotation = t32.tsTypeAnnotation(fnType);
+    const fnType = t33.tsFunctionType(null, params, reactNodeType);
+    typeAnnotation = t33.tsTypeAnnotation(fnType);
   }
-  const prop = t32.tsPropertySignature(key, typeAnnotation);
+  const prop = t33.tsPropertySignature(key, typeAnnotation);
   prop.optional = optional;
   return prop;
 }
 function createSlotScopeParam(props, ctx) {
-  const paramId = t32.identifier(SLOT_FN_PARAM_NAME);
+  const paramId = t33.identifier(SLOT_FN_PARAM_NAME);
   const propsSigns = [];
   const { reactiveBindings } = ctx.templateData;
   props.forEach(({ prop, tsType }) => {
     const foundBindingValue = reactiveBindings[prop]?.value;
     const foundBindingTypes = foundBindingValue ? expressionToTSType(foundBindingValue) : null;
-    const typeAnnotation = foundBindingTypes ? t32.tsTypeAnnotation(foundBindingTypes) : tsType;
-    const key = t32.isValidIdentifier(prop) ? t32.identifier(prop) : t32.stringLiteral(prop);
-    const propSign = t32.tsPropertySignature(key, typeAnnotation);
+    const typeAnnotation = foundBindingTypes ? t33.tsTypeAnnotation(foundBindingTypes) : tsType;
+    const key = t33.isValidIdentifier(prop) ? t33.identifier(prop) : t33.stringLiteral(prop);
+    const propSign = t33.tsPropertySignature(key, typeAnnotation);
     propsSigns.push(propSign);
   });
-  paramId.typeAnnotation = t32.tsTypeAnnotation(t32.tsTypeLiteral(propsSigns));
+  paramId.typeAnnotation = t33.tsTypeAnnotation(t33.tsTypeLiteral(propsSigns));
   return paramId;
 }
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/utils.ts
-import * as t33 from "@babel/types";
+import * as t34 from "@babel/types";
 function recordReactNode(ctx) {
   if (!ctx.scriptData.lang.startsWith("ts")) {
     return;
@@ -3978,16 +4035,16 @@ function collectLocalTypeDeclarations(path8) {
     return declarations;
   }
   for (const statement of programPath.node.body) {
-    if (t33.isTSInterfaceDeclaration(statement)) {
+    if (t34.isTSInterfaceDeclaration(statement)) {
       declarations.set(statement.id.name, {
-        type: t33.tsTypeLiteral(statement.body.body),
+        type: t34.tsTypeLiteral(statement.body.body),
         // 将接口体转换为类型字面量
         hasTypeParameters: !!statement.typeParameters?.params.length
         // 检查是否有泛型参数
       });
       continue;
     }
-    if (t33.isTSTypeAliasDeclaration(statement)) {
+    if (t34.isTSTypeAliasDeclaration(statement)) {
       declarations.set(statement.id.name, {
         type: statement.typeAnnotation,
         // 直接使用类型注解
@@ -3996,16 +4053,16 @@ function collectLocalTypeDeclarations(path8) {
       });
       continue;
     }
-    if (t33.isExportNamedDeclaration(statement) && statement.declaration) {
+    if (t34.isExportNamedDeclaration(statement) && statement.declaration) {
       const declaration = statement.declaration;
-      if (t33.isTSInterfaceDeclaration(declaration)) {
+      if (t34.isTSInterfaceDeclaration(declaration)) {
         declarations.set(declaration.id.name, {
-          type: t33.tsTypeLiteral(declaration.body.body),
+          type: t34.tsTypeLiteral(declaration.body.body),
           // 将接口体转换为类型字面量
           hasTypeParameters: !!declaration.typeParameters?.params.length
           // 检查是否有泛型参数
         });
-      } else if (t33.isTSTypeAliasDeclaration(declaration)) {
+      } else if (t34.isTSTypeAliasDeclaration(declaration)) {
         declarations.set(declaration.id.name, {
           type: declaration.typeAnnotation,
           // 直接使用类型注解
@@ -4018,22 +4075,22 @@ function collectLocalTypeDeclarations(path8) {
   return declarations;
 }
 function resolvePropName2(key) {
-  if (t33.isIdentifier(key)) {
+  if (t34.isIdentifier(key)) {
     return key.name;
   }
-  if (t33.isStringLiteral(key)) {
+  if (t34.isStringLiteral(key)) {
     return key.value;
   }
-  if (t33.isNumericLiteral(key)) {
+  if (t34.isNumericLiteral(key)) {
     return String(key.value);
   }
   return null;
 }
 function resolveCallableType(tsType) {
-  if (t33.isTSFunctionType(tsType)) {
+  if (t34.isTSFunctionType(tsType)) {
     return tsType;
   }
-  if (t33.isTSParenthesizedType(tsType)) {
+  if (t34.isTSParenthesizedType(tsType)) {
     return resolveCallableType(tsType.typeAnnotation);
   }
   return null;
@@ -4042,10 +4099,10 @@ function resolveCallableType(tsType) {
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/type-resolver.ts
 var SLOT_DEFAULT_NAME2 = "default";
 function resolveSlotType(tsType, options) {
-  if (t34.isTSParenthesizedType(tsType)) {
+  if (t35.isTSParenthesizedType(tsType)) {
     return resolveSlotType(tsType.typeAnnotation, options);
   }
-  if (t34.isTSTypeReference(tsType)) {
+  if (t35.isTSTypeReference(tsType)) {
     let shouldRecordReactNode = false;
     if (tsType.typeParameters?.params.length) {
       const params = [];
@@ -4061,11 +4118,11 @@ function resolveSlotType(tsType, options) {
         };
       }
       return {
-        type: t34.tsTypeReference(tsType.typeName, t34.tsTypeParameterInstantiation(params)),
+        type: t35.tsTypeReference(tsType.typeName, t35.tsTypeParameterInstantiation(params)),
         shouldRecordReactNode
       };
     }
-    if (!t34.isIdentifier(tsType.typeName)) {
+    if (!t35.isIdentifier(tsType.typeName)) {
       return {
         type: tsType,
         shouldRecordReactNode: false
@@ -4096,7 +4153,7 @@ function resolveSlotType(tsType, options) {
     }
     return resolved;
   }
-  if (t34.isTSIntersectionType(tsType)) {
+  if (t35.isTSIntersectionType(tsType)) {
     const types = [];
     let shouldRecordReactNode = false;
     for (const item of tsType.types) {
@@ -4119,11 +4176,11 @@ function resolveSlotType(tsType, options) {
       };
     }
     return {
-      type: t34.tsIntersectionType(types),
+      type: t35.tsIntersectionType(types),
       shouldRecordReactNode
     };
   }
-  if (t34.isTSUnionType(tsType)) {
+  if (t35.isTSUnionType(tsType)) {
     const types = [];
     let shouldRecordReactNode = false;
     for (const item of tsType.types) {
@@ -4146,11 +4203,11 @@ function resolveSlotType(tsType, options) {
       };
     }
     return {
-      type: t34.tsUnionType(types),
+      type: t35.tsUnionType(types),
       shouldRecordReactNode
     };
   }
-  if (t34.isTSTypeLiteral(tsType)) {
+  if (t35.isTSTypeLiteral(tsType)) {
     const members = [];
     let shouldRecordReactNode = false;
     for (const item of tsType.members) {
@@ -4165,11 +4222,11 @@ function resolveSlotType(tsType, options) {
       };
     }
     return {
-      type: t34.tsTypeLiteral(members),
+      type: t35.tsTypeLiteral(members),
       shouldRecordReactNode
     };
   }
-  if (t34.isTSFunctionType(tsType)) {
+  if (t35.isTSFunctionType(tsType)) {
     const props = buildSlotPropSignature(
       SLOT_DEFAULT_NAME2,
       cloneCallableParams(tsType.parameters),
@@ -4177,7 +4234,7 @@ function resolveSlotType(tsType, options) {
       // 默认插槽不是可选的
     );
     return {
-      type: t34.tsTypeLiteral([props]),
+      type: t35.tsTypeLiteral([props]),
       shouldRecordReactNode: true
       // 函数类型总是需要记录 ReactNode
     };
@@ -4188,7 +4245,7 @@ function resolveSlotType(tsType, options) {
   };
 }
 function resolveSlotPropFromMember(member) {
-  if (t34.isTSMethodSignature(member)) {
+  if (t35.isTSMethodSignature(member)) {
     const rawName = resolvePropName2(member.key);
     if (!rawName) {
       return {
@@ -4203,7 +4260,7 @@ function resolveSlotPropFromMember(member) {
       // 方法签名总是可调用，需要记录 ReactNode
     };
   }
-  if (t34.isTSPropertySignature(member)) {
+  if (t35.isTSPropertySignature(member)) {
     const rawName = resolvePropName2(member.key);
     if (!rawName) {
       return {
@@ -4226,7 +4283,7 @@ function resolveSlotPropFromMember(member) {
       // 可调用属性需要记录 ReactNode
     };
   }
-  if (t34.isTSCallSignatureDeclaration(member)) {
+  if (t35.isTSCallSignatureDeclaration(member)) {
     const params = cloneCallableParams(member.parameters);
     return {
       member: buildSlotPropSignature(SLOT_DEFAULT_NAME2, params, true),
@@ -4266,7 +4323,7 @@ function resolveDefineSlotsIface(path8, ctx) {
 }
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/template-slots.ts
-import * as t35 from "@babel/types";
+import * as t36 from "@babel/types";
 function resolveTemplateSlotIface(ctx) {
   if (ctx.inputType !== "sfc") return;
   const {
@@ -4284,7 +4341,7 @@ function resolveTemplateSlotIface(ctx) {
   }
   if (tsMembers.length) {
     recordReactNode(ctx);
-    slotTypes.push(t35.tsTypeLiteral(tsMembers));
+    slotTypes.push(t36.tsTypeLiteral(tsMembers));
   }
 }
@@ -4336,9 +4393,9 @@ function resolveCompIProps(ctx, ast) {
   }
   const n = declaredOptions.name || "Comp";
   const ns = `I${camelCase(capitalize(n))}Props`;
-  const typeNode = t36.tsIntersectionType(tsTypes);
-  const typeAliasDecl = t36.tsTypeAliasDeclaration(t36.identifier(ns), null, typeNode);
-  const exportDecl = t36.exportNamedDeclaration(typeAliasDecl);
+  const typeNode = t37.tsIntersectionType(tsTypes);
+  const typeAliasDecl = t37.tsTypeAliasDeclaration(t37.identifier(ns), null, typeNode);
+  const exportDecl = t37.exportNamedDeclaration(typeAliasDecl);
   propsTSIface.name = ns;
   const scriptIR = getScriptIR(ctx);
   scriptIR.exports.push(exportDecl);
@@ -4346,15 +4403,15 @@ function resolveCompIProps(ctx, ast) {
 }
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-use-attrs.ts
-import * as t37 from "@babel/types";
+import * as t38 from "@babel/types";
 function resolveUseAttrs(ctx) {
   return {
     VariableDeclarator(path8) {
       const { init, id } = path8.node;
       if (!init) return;
       const initPath = path8.get("init");
-      const propsIdentifier = t37.identifier(ctx.propField);
-      if (t37.isTSAsExpression(init) && isUseAttrsCall(init.expression)) {
+      const propsIdentifier = t38.identifier(ctx.propField);
+      if (t38.isTSAsExpression(init) && isUseAttrsCall(init.expression)) {
         const typeAssertion = createPropsTypeAssertion(propsIdentifier, init.typeAnnotation);
         replaceNode(initPath, typeAssertion, init);
         return;
@@ -4365,13 +4422,13 @@ function resolveUseAttrs(ctx) {
       const isTS = ctx.scriptData.lang.startsWith("ts");
       if (isTS) {
         let typeAnnotation = null;
-        if (t37.isIdentifier(id) && t37.isTSTypeAnnotation(id.typeAnnotation)) {
+        if (t38.isIdentifier(id) && t38.isTSTypeAnnotation(id.typeAnnotation)) {
           typeAnnotation = id.typeAnnotation.typeAnnotation;
           id.typeAnnotation = null;
         } else {
-          typeAnnotation = t37.tsTypeReference(
-            t37.identifier("Record"),
-            t37.tsTypeParameterInstantiation([t37.tsStringKeyword(), t37.tsUnknownKeyword()])
+          typeAnnotation = t38.tsTypeReference(
+            t38.identifier("Record"),
+            t38.tsTypeParameterInstantiation([t38.tsStringKeyword(), t38.tsUnknownKeyword()])
           );
         }
         const propsTypeAssertion = createPropsTypeAssertion(propsIdentifier, typeAnnotation);
@@ -4383,18 +4440,18 @@ function resolveUseAttrs(ctx) {
   };
 }
 function isUseAttrsCall(expr) {
-  return t37.isCallExpression(expr) && isCalleeNamed(expr, VUE_API_MAP.useAttrs);
+  return t38.isCallExpression(expr) && isCalleeNamed(expr, VUE_API_MAP.useAttrs);
 }
 function createPropsTypeAssertion(propsIdentifier, typeAnnotation) {
-  return t37.tsAsExpression(propsIdentifier, typeAnnotation);
+  return t38.tsAsExpression(propsIdentifier, typeAnnotation);
 }
 // src/core/transform/sfc/script/syntax-processor/process/resolve-analysis-only-adapter.ts
-import * as t43 from "@babel/types";
+import * as t44 from "@babel/types";
 // src/core/transform/sfc/script/shared/dependency-analyzer/index.ts
 import { traverse as traverse2 } from "@babel/core";
-import * as t42 from "@babel/types";
+import * as t43 from "@babel/types";
 // src/core/transform/sfc/script/shared/dependency-analyzer/binding-utils.ts
 function isBindingDeclaredInsideBoundary(binding, boundary) {
@@ -4413,7 +4470,7 @@ function isReactiveBinding(node) {
 }
 // src/core/transform/sfc/script/shared/dependency-analyzer/dep-checker.ts
-import * as t38 from "@babel/types";
+import * as t39 from "@babel/types";
 function isEligibleBindingSource(binding) {
   if (binding.kind === "param") {
     return false;
@@ -4423,57 +4480,57 @@ function isEligibleBindingSource(binding) {
   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 isReactiveApiCallVarBinding = !!declaratorPath && t39.isCallExpression(nodeInit) && t39.isIdentifier(nodeInit.callee) && reactiveStateApis.has(nodeInit.callee.name);
+  const isHookCallVarBinding = !!declaratorPath && t39.isCallExpression(nodeInit) && isHookLikeCallee(nodeInit.callee);
+  const isFunctionBinding = bindingPath.isFunctionDeclaration() || !!declaratorPath && !!nodeInit && (t39.isArrowFunctionExpression(nodeInit) || t39.isFunctionExpression(nodeInit));
   const isReactiveFunctionBinding = isFunctionBinding && (isReactiveBinding(declaratorPath?.node) || isReactiveBinding(bindingPath.node));
   return isReactiveVarBinding || isReactiveApiCallVarBinding || isHookCallVarBinding || isReactiveFunctionBinding;
 }
 function isReactValidDependencyExpr(node) {
-  if (t38.isIdentifier(node)) {
+  if (t39.isIdentifier(node)) {
     return true;
   }
-  if (t38.isMemberExpression(node) || t38.isOptionalMemberExpression(node)) {
+  if (t39.isMemberExpression(node) || t39.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)) {
+  while (t39.isMemberExpression(current) || t39.isOptionalMemberExpression(current)) {
+    if (!current.computed && !t39.isIdentifier(current.property)) {
       return false;
     }
-    if (current.computed && !t38.isStringLiteral(current.property) && !t38.isNumericLiteral(current.property)) {
+    if (current.computed && !t39.isStringLiteral(current.property) && !t39.isNumericLiteral(current.property)) {
       return false;
     }
     current = current.object;
   }
-  return t38.isIdentifier(current);
+  return t39.isIdentifier(current);
 }
 function isHookLikeCallee(callee) {
-  if (t38.isIdentifier(callee)) {
+  if (t39.isIdentifier(callee)) {
     return callee.name.startsWith("use");
   }
-  if (t38.isMemberExpression(callee) && !callee.computed && t38.isIdentifier(callee.property)) {
+  if (t39.isMemberExpression(callee) && !callee.computed && t39.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";
+import * as t40 from "@babel/types";
 function getDependencyKey(exp) {
-  if (t39.isIdentifier(exp)) {
+  if (t40.isIdentifier(exp)) {
     return exp.name;
   }
-  if (t39.isMemberExpression(exp) || t39.isOptionalMemberExpression(exp)) {
+  if (t40.isMemberExpression(exp) || t40.isOptionalMemberExpression(exp)) {
     const objectKey = getDependencyKey(exp.object);
     const opt = exp.optional ? "?" : "";
-    if (!exp.computed && t39.isIdentifier(exp.property)) {
+    if (!exp.computed && t40.isIdentifier(exp.property)) {
       return `${objectKey}${opt}.${exp.property.name}`;
     }
-    if (t39.isStringLiteral(exp.property) || t39.isNumericLiteral(exp.property)) {
+    if (t40.isStringLiteral(exp.property) || t40.isNumericLiteral(exp.property)) {
       return `${objectKey}${opt}[${JSON.stringify(exp.property.value)}]`;
     }
     return `${objectKey}${opt}[*]`;
@@ -4482,40 +4539,40 @@ function getDependencyKey(exp) {
 }
 // src/core/transform/sfc/script/shared/dependency-analyzer/dep-normalizer.ts
-import * as t40 from "@babel/types";
+import * as t41 from "@babel/types";
 function normalizeDependencyExpr(path8, rootName, ctx) {
-  if (t40.isIdentifier(path8.node)) {
-    return t40.identifier(path8.node.name);
+  if (t41.isIdentifier(path8.node)) {
+    return t41.identifier(path8.node.name);
   }
-  if (t40.isMemberExpression(path8.node) || t40.isOptionalMemberExpression(path8.node)) {
+  if (t41.isMemberExpression(path8.node) || t41.isOptionalMemberExpression(path8.node)) {
     if (rootName === ctx.propField) {
       const safePropsExp = ensureOptionalForMemberChain(path8.node);
       if (isReactValidDependencyExpr(safePropsExp)) {
-        return t40.cloneNode(safePropsExp, true);
+        return t41.cloneNode(safePropsExp, true);
       }
-      return t40.identifier(rootName);
+      return t41.identifier(rootName);
     }
     const normalizedExp = normalizeMemberForCallSite(path8, path8.node);
-    const safeExp = t40.isMemberExpression(normalizedExp) || t40.isOptionalMemberExpression(normalizedExp) ? ensureOptionalForMemberChain(normalizedExp) : normalizedExp;
+    const safeExp = t41.isMemberExpression(normalizedExp) || t41.isOptionalMemberExpression(normalizedExp) ? ensureOptionalForMemberChain(normalizedExp) : normalizedExp;
     if (isReactValidDependencyExpr(safeExp)) {
-      return t40.cloneNode(safeExp, true);
+      return t41.cloneNode(safeExp, true);
     }
-    return t40.identifier(rootName);
+    return t41.identifier(rootName);
   }
   return null;
 }
 function normalizeSourcedDependency(exp) {
-  if (t40.isIdentifier(exp)) {
-    return t40.identifier(exp.name);
+  if (t41.isIdentifier(exp)) {
+    return t41.identifier(exp.name);
   }
-  if (t40.isMemberExpression(exp) || t40.isOptionalMemberExpression(exp)) {
+  if (t41.isMemberExpression(exp) || t41.isOptionalMemberExpression(exp)) {
     const root = findRootIdentifier(exp);
     if (!root) return null;
-    const safeExp = t40.isMemberExpression(exp) || t40.isOptionalMemberExpression(exp) ? ensureOptionalForMemberChain(exp) : exp;
+    const safeExp = t41.isMemberExpression(exp) || t41.isOptionalMemberExpression(exp) ? ensureOptionalForMemberChain(exp) : exp;
     if (isReactValidDependencyExpr(safeExp)) {
-      return t40.cloneNode(safeExp, true);
+      return t41.cloneNode(safeExp, true);
     }
-    return t40.identifier(root.name);
+    return t41.identifier(root.name);
   }
   return null;
 }
@@ -4525,7 +4582,7 @@ function normalizeMemberForCallSite(path8, node) {
   if (!isDirectCallee) {
     return node;
   }
-  if (!t40.isExpression(node.object)) {
+  if (!t41.isExpression(node.object)) {
     return node;
   }
   return node.object;
@@ -4534,15 +4591,23 @@ 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);
+  const rebuildWithOptionalChain = (node2) => {
+    const safeObject = ensureOptionalForMemberChain(node2.object);
+    if (safeObject !== node2.object) {
+      const property = t41.cloneNode(node2.property, true);
+      return t41.optionalMemberExpression(safeObject, property, node2.computed, true);
+    }
+    if (t41.isMemberExpression(node2)) {
+      const object = t41.cloneNode(node2.object, true);
+      const property = t41.cloneNode(node2.property, true);
+      return t41.optionalMemberExpression(object, property, node2.computed, true);
+    }
+    return node2;
+  };
+  return rebuildWithOptionalChain(node);
 }
 function hasTrailingMemberAccess(node) {
-  return t40.isMemberExpression(node.object) || t40.isOptionalMemberExpression(node.object);
+  return t41.isMemberExpression(node.object) || t41.isOptionalMemberExpression(node.object);
 }
 // src/core/transform/sfc/script/shared/dependency-analyzer/shared-utils.ts
@@ -4557,7 +4622,7 @@ function isNestedMemberObject(path8) {
 }
 // src/core/transform/sfc/script/shared/dependency-analyzer/trace-utils.ts
-import * as t41 from "@babel/types";
+import * as t42 from "@babel/types";
 function traceBindingSource(binding, seen, depth) {
   if (depth <= 0) return null;
   const declaratorPath = getVariableDeclaratorPath(binding.path);
@@ -4569,7 +4634,7 @@ function traceBindingSource(binding, seen, depth) {
 }
 function isExpressionSourcedFromEligibleBinding(exp, scope, seen, depth) {
   if (depth <= 0) return null;
-  if (t41.isIdentifier(exp)) {
+  if (t42.isIdentifier(exp)) {
     const sourceBinding = scope.getBinding(exp.name);
     if (!sourceBinding) return null;
     if (isEligibleBindingSource(sourceBinding)) {
@@ -4577,13 +4642,13 @@ function isExpressionSourcedFromEligibleBinding(exp, scope, seen, depth) {
     }
     return traceBindingSource(sourceBinding, seen, depth - 1);
   }
-  if (t41.isMemberExpression(exp) || t41.isOptionalMemberExpression(exp)) {
+  if (t42.isMemberExpression(exp) || t42.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);
+      return t42.cloneNode(exp);
     }
     const sourcedRoot = traceBindingSource(sourceBinding, seen, depth - 1);
     if (sourcedRoot) {
@@ -4591,17 +4656,17 @@ function isExpressionSourcedFromEligibleBinding(exp, scope, seen, depth) {
       if (rebuilt) {
         return rebuilt;
       }
-      return t41.cloneNode(sourcedRoot, true);
+      return t42.cloneNode(sourcedRoot, true);
     }
   }
   return null;
 }
 function rebuildMemberWithNewRoot(node, nextRoot) {
   const replacedObject = (() => {
-    if (t41.isIdentifier(node.object)) {
-      return t41.cloneNode(nextRoot, true);
+    if (t42.isIdentifier(node.object)) {
+      return t42.cloneNode(nextRoot, true);
     }
-    if (t41.isMemberExpression(node.object) || t41.isOptionalMemberExpression(node.object)) {
+    if (t42.isMemberExpression(node.object) || t42.isOptionalMemberExpression(node.object)) {
       return rebuildMemberWithNewRoot(node.object, nextRoot);
     }
     return null;
@@ -4609,15 +4674,15 @@ function rebuildMemberWithNewRoot(node, nextRoot) {
   if (!replacedObject) {
     return null;
   }
-  const property = t41.cloneNode(node.property, true);
-  if (t41.isMemberExpression(node)) {
-    return t41.memberExpression(
+  const property = t42.cloneNode(node.property, true);
+  if (t42.isMemberExpression(node)) {
+    return t42.memberExpression(
       replacedObject,
       property,
       node.computed
     );
   }
-  return t41.optionalMemberExpression(
+  return t42.optionalMemberExpression(
     replacedObject,
     property,
     node.computed,
@@ -4628,9 +4693,9 @@ function rebuildMemberWithNewRoot(node, nextRoot) {
 // src/core/transform/sfc/script/shared/dependency-analyzer/index.ts
 function analyzeDeps(node, ctx, parentPath) {
   if (!parentPath) {
-    return t42.arrayExpression([]);
+    return t43.arrayExpression([]);
   }
-  const isFnExpr = t42.isArrowFunctionExpression(node) || t42.isFunctionExpression(node);
+  const isFnExpr = t43.isArrowFunctionExpression(node) || t43.isFunctionExpression(node);
   const analyzeTarget = isFnExpr ? node.body : node;
   const bindingLocalBoundary = isFnExpr ? node : analyzeTarget;
   const deps = /* @__PURE__ */ new Map();
@@ -4640,13 +4705,13 @@ function analyzeDeps(node, ctx, parentPath) {
   }
   const analyzeTargetPath = parentPath && parentPath.node === analyzeTarget ? parentPath : null;
   if (analyzeTargetPath) {
-    if (t42.isMemberExpression(analyzeTarget) || t42.isOptionalMemberExpression(analyzeTarget)) {
+    if (t43.isMemberExpression(analyzeTarget) || t43.isOptionalMemberExpression(analyzeTarget)) {
       const rootId = findRootIdentifier(analyzeTarget);
       if (rootId) {
         tryAddDependency(analyzeTargetPath, rootId.name, analyzeTargetPath.scope);
         processedIdentifiers.add(rootId);
       }
-    } else if (t42.isIdentifier(analyzeTarget)) {
+    } else if (t43.isIdentifier(analyzeTarget)) {
       tryAddDependency(analyzeTargetPath, analyzeTarget.name, analyzeTargetPath.scope);
     }
   }
@@ -4698,7 +4763,7 @@ function analyzeDeps(node, ctx, parentPath) {
       }
     }
   }
-  return t42.arrayExpression(Array.from(deps.values()));
+  return t43.arrayExpression(Array.from(deps.values()));
 }
 // src/core/transform/sfc/script/syntax-processor/process/resolve-analysis-only-adapter.ts
@@ -4714,7 +4779,7 @@ function resolveAnalysisOnlyAdapter(ctx) {
       if (!isVueApiReference(path8, apiName)) {
         return;
       }
-      if (t43.isCallExpression(node)) {
+      if (t44.isCallExpression(node)) {
         resolveCallNode(path8, adapter, ctx);
       } else {
         replaceIdName(node, adapter.target);
@@ -4724,11 +4789,11 @@ function resolveAnalysisOnlyAdapter(ctx) {
   };
 }
 function getApiName(node) {
-  const isCallNode = t43.isCallExpression(node);
+  const isCallNode = t44.isCallExpression(node);
   let apiName = "";
-  if (t43.isIdentifier(node)) {
+  if (t44.isIdentifier(node)) {
     apiName = node.name;
-  } else if (isCallNode && t43.isIdentifier(node.callee)) {
+  } else if (isCallNode && t44.isIdentifier(node.callee)) {
     apiName = node.callee.name;
   }
   return apiName;
@@ -4738,7 +4803,7 @@ function resolveCallNode(path8, adapter, ctx) {
   const { arguments: args } = node;
   if (!args.length) return;
   const fn = args[0];
-  if (!t43.isArrowFunctionExpression(fn) && !t43.isFunctionExpression(fn)) {
+  if (!t44.isArrowFunctionExpression(fn) && !t44.isFunctionExpression(fn)) {
     return;
   }
   const fnPath = path8.get("arguments")[0];
@@ -4770,7 +4835,7 @@ function isVueImportBinding(binding) {
     return false;
   }
   const parent = bindingPath.parentPath?.node;
-  if (!parent || !t43.isImportDeclaration(parent)) {
+  if (!parent || !t44.isImportDeclaration(parent)) {
     return false;
   }
   const source = parent.source.value.toLowerCase();
@@ -4838,7 +4903,7 @@ function isSkip(path8) {
 }
 // src/core/transform/sfc/script/syntax-processor/process/resolve-element-ref.ts
-import * as t44 from "@babel/types";
+import * as t45 from "@babel/types";
 function resolveElementRef(ctx) {
   return {
     CallExpression(path8) {
@@ -4856,14 +4921,14 @@ function resolveElementRef(ctx) {
       }
       if (isCompRefBindings) {
         const varDeclaratorPath = getVariableDeclaratorPath(path8)?.node;
-        if (!t44.isIdentifier(varDeclaratorPath?.id)) {
+        if (!t45.isIdentifier(varDeclaratorPath?.id)) {
           return;
         }
         const varName = varDeclaratorPath.id.name;
         const compRef = refBindings.componentRefs[varName];
         if (!compRef) return;
       }
-      node.arguments[0] = t44.identifier("null");
+      node.arguments[0] = t45.identifier("null");
       resolveTypeParameters(ctx, path8);
       replaceCallName(node, REACT_API_MAP.useRef);
       recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.useRef);
@@ -4888,27 +4953,27 @@ function resolveTypeParameters(ctx, path8) {
   const compBindingMeta = refBindings.componentRefs[idName];
   if (!node.typeParameters && (domBindingMeta || compBindingMeta)) {
     const type = compBindingMeta ? "any" : domBindingMeta.htmlType;
-    node.typeParameters = t44.tsTypeParameterInstantiation([t44.tsTypeReference(t44.identifier(type))]);
+    node.typeParameters = t45.tsTypeParameterInstantiation([t45.tsTypeReference(t45.identifier(type))]);
   }
 }
 function resolveRefValueToCurrent(path8) {
   const { node } = path8;
-  if (node.computed || !t44.isIdentifier(node.property) || node.property.name !== "value") {
+  if (node.computed || !t45.isIdentifier(node.property) || node.property.name !== "value") {
     return;
   }
   const rootPath = findRootVariablePath(path8);
-  if (!rootPath?.node || !t44.isCallExpression(rootPath.node.init) || !isCalleeNamed(rootPath.node.init, REACT_API_MAP.useRef)) {
+  if (!rootPath?.node || !t45.isCallExpression(rootPath.node.init) || !isCalleeNamed(rootPath.node.init, REACT_API_MAP.useRef)) {
     return;
   }
   const rootId = findRootIdentifier(node);
-  if (!t44.isIdentifier(node.object) || node.object.name !== rootId?.name) {
+  if (!t45.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 t45 from "@babel/types";
+import * as t46 from "@babel/types";
 function resolveExprMemo(ctx, ast) {
   const isScriptFile = ctx.inputType !== "sfc";
   return {
@@ -4920,11 +4985,11 @@ function resolveExprMemo(ctx, ast) {
         if (!atComponentOrHookRoot(path8, ast.program, isScriptFile)) {
           return false;
         }
-        if (!t45.isVariableDeclaration(path8.parent) || path8.parent.kind !== "const") {
+        if (!t46.isVariableDeclaration(path8.parent) || path8.parent.kind !== "const") {
           return false;
         }
-        if (t45.isFunction(init)) return false;
-        if (t45.isCallExpression(init) && t45.isIdentifier(init.callee) && init.callee.name.startsWith("use")) {
+        if (t46.isFunction(init)) return false;
+        if (t46.isCallExpression(init) && t46.isIdentifier(init.callee) && init.callee.name.startsWith("use")) {
           return false;
         }
         return true;
@@ -4943,16 +5008,16 @@ function resolveExprMemo(ctx, ast) {
 }
 // src/core/transform/sfc/script/syntax-processor/process/resolve-lint-rules.ts
-import * as t46 from "@babel/types";
+import * as t47 from "@babel/types";
 function resolveLintRules(ctx, ast) {
   const inScriptFile = ctx.inputType !== "sfc";
   return {
     CallExpression(path8) {
       const { node, parentPath } = path8;
-      if (!t46.isIdentifier(node.callee)) return;
+      if (!t47.isIdentifier(node.callee)) return;
       const { name: callName } = node.callee;
-      const addLog = (t52) => {
-        logger.error(t52, {
+      const addLog = (t53) => {
+        logger.error(t53, {
           file: ctx.filename,
           source: ctx.scriptData.source,
           loc: node.loc
@@ -4997,16 +5062,27 @@ function resolveLintRules(ctx, ast) {
 // src/core/transform/sfc/script/syntax-processor/process/resolve-provide.ts
 import { generate as generate2 } from "@babel/generator";
-import * as t47 from "@babel/types";
+import * as t48 from "@babel/types";
 function resolveProvide(ctx) {
-  if (ctx.inputType === "style") return {};
+  const { filename, scriptData, inputType } = ctx;
+  if (inputType !== "sfc") {
+    return {};
+  }
   return {
     CallExpression(path8) {
       const { node } = path8;
+      if (inputType.startsWith("script")) {
+        logger.error("provide() call found outside of SFC <script setup> context.", {
+          file: filename,
+          source: scriptData.source,
+          loc: node.loc
+        });
+        return;
+      }
       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;
-      const { provide } = ctx.scriptData;
+      const { provide } = scriptData;
       const [key, value] = node.arguments;
       const target = findOrCreateCtxProvider(provide);
       const adapter = ADAPTER_RULES.runtime[VUE_API_MAP.provide];
@@ -5029,13 +5105,13 @@ function findOrCreateCtxProvider(root) {
 function assignProviderValue(target, key, value) {
   const getRawExp = (exp) => {
     if (!exp) return "''";
-    if (t47.isStringLiteral(exp)) {
+    if (t48.isStringLiteral(exp)) {
       return JSON.stringify(exp.value);
     }
-    if (t47.isNumericLiteral(exp)) {
+    if (t48.isNumericLiteral(exp)) {
       return exp.value.toString();
     }
-    if (t47.isIdentifier(exp)) {
+    if (t48.isIdentifier(exp)) {
       return exp.name;
     }
     try {
@@ -5051,16 +5127,16 @@ function assignProviderValue(target, key, value) {
 }
 // src/core/transform/sfc/script/syntax-processor/process/resolve-rename-adapter.ts
-import * as t48 from "@babel/types";
+import * as t49 from "@babel/types";
 function resolveRenameAdapter(ctx) {
   return {
     "CallExpression|Identifier"(path8) {
       const node = path8.node;
-      const isCallNode = t48.isCallExpression(node);
+      const isCallNode = t49.isCallExpression(node);
       let apiName = "";
-      if (t48.isIdentifier(node)) {
+      if (t49.isIdentifier(node)) {
         apiName = node.name;
-      } else if (isCallNode && t48.isIdentifier(node.callee)) {
+      } else if (isCallNode && t49.isIdentifier(node.callee)) {
         apiName = node.callee.name;
       }
       if (!apiName) {
@@ -5122,7 +5198,7 @@ function isVueImportBinding2(binding) {
     return false;
   }
   const parent = bindingPath.parentPath?.node;
-  if (!parent || !t48.isImportDeclaration(parent)) {
+  if (!parent || !t49.isImportDeclaration(parent)) {
     return false;
   }
   const source = parent.source.value.toLowerCase();
@@ -5153,11 +5229,10 @@ function processVueSyntax2(ast, ctx) {
     process: {
       applyBabel: [
         resolveElementRef,
-        // provide 需要在 rename 之前收集并移除原始调用，避免被重命名后失配
-        resolveProvide,
         resolveRenameAdapter,
-        // fix：在分析函数前分析可优化为 useMemo 的顶层变量声明，
-        // 使得后续能够被函数依赖分析
+        // fix: https://github.com/vureact-js/core/issues/46
+        resolveProvide,
+        // fix：在分析函数前分析可优化为 useMemo 的顶层变量声明，使得后续能够被函数依赖分析
         resolveExprMemo,
         resolveArrowFnDeps,
         resolveAnalysisOnlyAdapter,
@@ -5166,7 +5241,12 @@ function processVueSyntax2(ast, ctx) {
       excludeBabel: [resolveTemplateSlotIface, resolveCompIProps]
     },
     postprocess: {
-      applyBabel: [resolveRuntimeImports, resolveASTChunks],
+      applyBabel: [
+        // 该 resolver 需确保放在所有类型处理之后，移除之前
+        resolveVueTypeAsAny,
+        resolveRuntimeImports,
+        resolveASTChunks
+      ],
       excludeBabel: [resolveSfcCssImport]
     }
   });
@@ -5259,13 +5339,13 @@ function isRouterLinkBooleanCustomProp(prop) {
 }
 // src/core/transform/sfc/template/shared/prop-ir-utils.ts
-import * as t50 from "@babel/types";
+import * as t51 from "@babel/types";
 // src/shared/string-code-types.ts
 import { parseExpression as parseExpression3 } from "@babel/parser";
-import * as t49 from "@babel/types";
+import * as t50 from "@babel/types";
 var strCodeTypes = {
-  isIdentifier: isIdentifier28,
+  isIdentifier: isIdentifier29,
   isSimpleExpression,
   isStringLiteral: isStringLiteral13
 };
@@ -5276,30 +5356,30 @@ function isSimpleExpression(code, excludeVar = false) {
   } catch {
     return false;
   }
-  if (t49.isLiteral(node)) {
+  if (t50.isLiteral(node)) {
     return true;
   }
-  if (!excludeVar && t49.isIdentifier(node)) {
+  if (!excludeVar && t50.isIdentifier(node)) {
     return true;
   }
-  if (t49.isMemberExpression(node)) {
-    return isSimpleExpression(node.object) && t49.isIdentifier(node.property);
+  if (t50.isMemberExpression(node)) {
+    return isSimpleExpression(node.object) && t50.isIdentifier(node.property);
   }
-  if (t49.isObjectExpression(node) || t49.isArrayExpression(node)) {
+  if (t50.isObjectExpression(node) || t50.isArrayExpression(node)) {
     return false;
   }
-  if (t49.isCallExpression(node) || t49.isAssignmentExpression(node)) {
+  if (t50.isCallExpression(node) || t50.isAssignmentExpression(node)) {
     return false;
   }
-  if (t49.isBinaryExpression(node) || t49.isUnaryExpression(node)) {
+  if (t50.isBinaryExpression(node) || t50.isUnaryExpression(node)) {
     return true;
   }
   return false;
 }
-function isIdentifier28(code) {
+function isIdentifier29(code) {
   try {
     const node = parseExpression3(code);
-    return t49.isIdentifier(node);
+    return t50.isIdentifier(node);
   } catch {
     return false;
   }
@@ -5307,7 +5387,7 @@ function isIdentifier28(code) {
 function isStringLiteral13(code) {
   try {
     const node = parseExpression3(code);
-    return t49.isStringLiteral(node);
+    return t50.isStringLiteral(node);
   } catch {
     return false;
   }
@@ -5447,9 +5527,10 @@ function resolvePropAsBabelExp(ir, ctx) {
   const value = ir.value;
   const valueContent = value.content;
   const mergedItems = value.merge;
+  const rule = ADAPTER_RULES.runtime;
   const setNameIdentifier = (target, valueName) => {
     target.content = valueName;
-    target.ast = t50.jsxIdentifier(valueName);
+    target.ast = t51.jsxIdentifier(valueName);
   };
   const setValueExpression = (target, content, isStringLiteral14) => {
     target.content = content;
@@ -5457,38 +5538,41 @@ function resolvePropAsBabelExp(ir, ctx) {
   };
   const createRuntimeCall = (fnName, args) => {
     const fnArgs = args.filter(Boolean).join(",");
-    return `${fnName}(${fnArgs})`;
+    const valIsUndef = fnName === rule.dirOn.target && args?.[1] === "undefined";
+    const isTs = ctx.scriptData.lang.startsWith("ts");
+    const safeTypeAssertion = isTs ? valIsUndef ? "as never" : "" : "";
+    return `${fnName}(${fnArgs}) ${safeTypeAssertion}`;
   };
   const applyRuntimeExpression = (expression, setName = false, nameIdentifier, isStringLiteral14) => {
     if (setName && nameIdentifier) {
       setNameIdentifier(nameExp, nameIdentifier);
     }
-    const dir = ADAPTER_RULES.runtime.dir;
+    const dir = rule.dir;
     recordImport(ctx, dir.package, dir.target);
     setValueExpression(value.babelExp, expression, isStringLiteral14);
   };
   if (ir.isKeyLessVBind) {
-    const dirKeyless = ADAPTER_RULES.runtime.dirKeyless;
+    const dirKeyless = rule.dirKeyless;
     const expression = createRuntimeCall(dirKeyless.target, [valueContent]);
     applyRuntimeExpression(expression, false);
     return;
   }
   if (isClassAttr(name) && !value.isStringLiteral && !valueContent.startsWith(STYLE_MODULE_NAME)) {
-    const dirCls = ADAPTER_RULES.runtime.dirCls;
+    const dirCls = rule.dirCls;
     const arg = mergedItems?.join(",") || wrapSingleQuotes(valueContent);
     const expression = createRuntimeCall(dirCls.target, [arg]);
     applyRuntimeExpression(expression, true, name);
     return;
   }
   if (isStyleAttr(name) && (!isSimpleStyle(valueContent) || mergedItems?.some((item) => !isSimpleStyle(item)))) {
-    const dirStyle = ADAPTER_RULES.runtime.dirStyle;
+    const dirStyle = rule.dirStyle;
     const arg = mergedItems?.join(",") || valueContent;
     const expression = createRuntimeCall(dirStyle.target, [arg]);
     applyRuntimeExpression(expression, true, name);
     return;
   }
   if (ir.type === 3 /* EVENT */ && ir.modifiers?.length) {
-    const dirOn = ADAPTER_RULES.runtime.dirOn;
+    const dirOn = rule.dirOn;
     const eventName = wrapSingleQuotes(ir.__vOnEvName || name, ir.isStatic);
     const expression = createRuntimeCall(dirOn.target, [eventName, valueContent]);
     applyRuntimeExpression(expression, true, name);
@@ -6196,14 +6280,15 @@ function applyValueModifiers(valueExp, modifiers) {
 }
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-on.ts
-import * as t51 from "@babel/types";
+import * as t52 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 = resolveCaptureModifier(modifiers);
   const eventName = resolveEventName(arg.content, captureIndex);
-  const handler = resolveHandler(exp.content.trim(), ctx, modifiers);
+  const handlerContent = exp?.content?.trim() || "undefined";
+  const handler = resolveHandler(handlerContent, ctx, modifiers);
   const originalVueEventName = modifiers.length ? `${arg.content}.${modifiers.join(".")}` : "";
   const eventIR = createPropsIR(directive.rawName, eventName, handler);
   eventIR.type = 3 /* EVENT */;
@@ -6253,10 +6338,10 @@ function resolveHandler(handlerContent, ctx, modifiers) {
   return handler;
 }
 function isConsoleCall(expr) {
-  return t51.isCallExpression(expr) && t51.isMemberExpression(expr.callee) && t51.isIdentifier(expr.callee.object) && expr.callee.object.name === "console";
+  return t52.isCallExpression(expr) && t52.isMemberExpression(expr.callee) && t52.isIdentifier(expr.callee.object) && expr.callee.object.name === "console";
 }
 function isFnReference(expr) {
-  return t51.isIdentifier(expr) || t51.isMemberExpression(expr) || t51.isFunction(expr);
+  return t52.isIdentifier(expr) || t52.isMemberExpression(expr) || t52.isFunction(expr);
 }
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-show.ts
@@ -6488,11 +6573,8 @@ function resolveSlotOutletNode(node, nodeIR, ctx, parentIR, childrenIR) {
 function resolveSlotProps(node, ctx) {
   const result = {
     name: "children",
-    // 默认插槽名为'children'
     isScope: false,
-    // 默认非作用域插槽
     props: []
-    // 作用域参数列表
   };
   const { source, filename } = ctx;
   const addSlotProp = (key, value) => {
@@ -6516,9 +6598,12 @@ function resolveSlotProps(node, ctx) {
       continue;
     }
     if (prop.type === NodeTypes9.DIRECTIVE) {
+      warnUnsupportedVueDollarVar(ctx, prop);
+      if (!prop.arg) {
+        continue;
+      }
       const arg = prop.arg;
       const exp = prop.exp;
-      warnUnsupportedVueDollarVar(ctx, prop);
       if (!arg.isStatic) {
         logger.warn("Avoid using dynamic slot names, as they may lead to unexpected behavior.", {
           source,
@@ -6527,7 +6612,7 @@ function resolveSlotProps(node, ctx) {
         });
       }
       const key = arg.content;
-      const value = exp.content.trim();
+      const value = exp?.content?.trim() || "undefined";
       if (key === "name") {
         result.name = camelCase(value);
       } else {
@@ -6609,7 +6694,7 @@ function transform(ast, ctx, options) {
 }
 // package.json
-var version = "1.8.3";
+var version = "1.8.5";
 var bin = {
   vureact: "bin/vureact.js"
 };