@vureact/compiler-core 1.1.0 → 1.2.0

package/lib/{chunk-P26R53VO.js → chunk-FCLIDEIZ.js}

@@ -1,5 +1,5 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10;/**
- * @vureact/compiler-core v1.1.0
+ * @vureact/compiler-core v1.1.1
  * (c) 2025-present Ruihong Zhong (Ryan John)
  * @license MIT
  */
@@ -24,95 +24,351 @@ function executePlugins(map, result, ctx) {
 }
 
 // src/core/codegen/component/jsx/syntax-processor/postprocess/build-ctx-provider.ts
-var _types = require('@babel/types'); var t10 = _interopRequireWildcard(_types); var t = _interopRequireWildcard(_types); var t9 = _interopRequireWildcard(_types); var t2 = _interopRequireWildcard(_types); var t4 = _interopRequireWildcard(_types); var t3 = _interopRequireWildcard(_types); var t5 = _interopRequireWildcard(_types); var t6 = _interopRequireWildcard(_types); var t8 = _interopRequireWildcard(_types); var t7 = _interopRequireWildcard(_types); var t13 = _interopRequireWildcard(_types); var t11 = _interopRequireWildcard(_types); var t12 = _interopRequireWildcard(_types); var t14 = _interopRequireWildcard(_types); var t15 = _interopRequireWildcard(_types); var t16 = _interopRequireWildcard(_types); var t17 = _interopRequireWildcard(_types); var t19 = _interopRequireWildcard(_types); var t18 = _interopRequireWildcard(_types); var t20 = _interopRequireWildcard(_types); var t21 = _interopRequireWildcard(_types); var t22 = _interopRequireWildcard(_types); var t23 = _interopRequireWildcard(_types); var t28 = _interopRequireWildcard(_types); var t25 = _interopRequireWildcard(_types); var t24 = _interopRequireWildcard(_types); var t26 = _interopRequireWildcard(_types); var t27 = _interopRequireWildcard(_types); var t29 = _interopRequireWildcard(_types); var t30 = _interopRequireWildcard(_types); var t31 = _interopRequireWildcard(_types); var t32 = _interopRequireWildcard(_types); var t33 = _interopRequireWildcard(_types); var t34 = _interopRequireWildcard(_types); var t35 = _interopRequireWildcard(_types); var t38 = _interopRequireWildcard(_types); var t36 = _interopRequireWildcard(_types); var t37 = _interopRequireWildcard(_types); var t39 = _interopRequireWildcard(_types);
+var _types = require('@babel/types'); var t10 = _interopRequireWildcard(_types); var t = _interopRequireWildcard(_types); var t9 = _interopRequireWildcard(_types); var t2 = _interopRequireWildcard(_types); var t4 = _interopRequireWildcard(_types); var t3 = _interopRequireWildcard(_types); var t5 = _interopRequireWildcard(_types); var t6 = _interopRequireWildcard(_types); var t8 = _interopRequireWildcard(_types); var t7 = _interopRequireWildcard(_types); var t13 = _interopRequireWildcard(_types); var t11 = _interopRequireWildcard(_types); var t12 = _interopRequireWildcard(_types); var t14 = _interopRequireWildcard(_types); var t15 = _interopRequireWildcard(_types); var t16 = _interopRequireWildcard(_types); var t17 = _interopRequireWildcard(_types); var t19 = _interopRequireWildcard(_types); var t18 = _interopRequireWildcard(_types); var t20 = _interopRequireWildcard(_types); var t22 = _interopRequireWildcard(_types); var t21 = _interopRequireWildcard(_types); var t23 = _interopRequireWildcard(_types); var t24 = _interopRequireWildcard(_types); var t29 = _interopRequireWildcard(_types); var t26 = _interopRequireWildcard(_types); var t25 = _interopRequireWildcard(_types); var t27 = _interopRequireWildcard(_types); var t28 = _interopRequireWildcard(_types); var t31 = _interopRequireWildcard(_types); var t30 = _interopRequireWildcard(_types); var t32 = _interopRequireWildcard(_types); var t33 = _interopRequireWildcard(_types); var t34 = _interopRequireWildcard(_types); var t35 = _interopRequireWildcard(_types); var t36 = _interopRequireWildcard(_types); var t39 = _interopRequireWildcard(_types); var t37 = _interopRequireWildcard(_types); var t38 = _interopRequireWildcard(_types); var t40 = _interopRequireWildcard(_types);
 
-// src/consts/adapters-map.ts
-var ADAPTER_COMPS = {
-  KeepAlive: "KeepAlive",
-  Suspense: "Suspense",
-  Teleport: "Teleport",
-  Component: "Component",
-  Provider: "Provider",
-  // 实际是 Vue 的 provide 方法，为了命名统一采用 Provide
-  Transition: "Transition",
-  TransitionGroup: "TransitionGroup"
-};
-var ADAPTER_UTILS_MAP = {
-  dir: "dir",
-  dirCls: "dir.cls",
-  dirKeyless: "dir.keyless",
-  dirOn: "dir.on",
-  dirStyle: "dir.style",
-  nextTick: "nextTick"
+// src/consts/other.ts
+var PACKAGE_NAME = {
+  react: "react",
+  runtime: "@vureact/runtime-core",
+  router: "@vureact/router"
 };
-var ADAPTER_ROUTER_COMPS = {
-  RouterLink: "RouterLink",
-  RouterView: "RouterView"
+var STYLE_MODULE_NAME = "$style";
+var MACRO_API_NAMES = {
+  props: "defineProps",
+  emits: "defineEmits",
+  slots: "defineSlots",
+  options: "defineOptions",
+  expose: "defineExpose"
 };
-var ADAPTER_HOOKS = {
-  renameOnly: {
-    pure: {
-      useActived: "useActived",
-      useDeactivated: "useDeactivated",
-      onBeforeMount: "useBeforeMount",
-      onBeforeUnMount: "useBeforeUnMount",
-      onMounted: "useMounted",
-      onUnmounted: "useUnmounted"
+var DOLLAR_IDENTIFIERS = [
+  "$data",
+  "$props",
+  "$el",
+  "$options",
+  "$parent",
+  "$root",
+  "$slots",
+  "$refs",
+  "$attrs",
+  "$emit",
+  "$watch",
+  "$forceUpdate",
+  "$nextTick",
+  "$router",
+  "$route",
+  "$store",
+  "$pinia",
+  "$event"
+];
+var VUE_PACKAGES = [
+  "vue",
+  "vite",
+  "pinia",
+  "nuxt",
+  // 不需要带到 React 项目中
+  "@vureact/compiler-core"
+];
+
+// src/consts/adapters-map.ts
+var ADAPTER_RULES = {
+  // =============== [React] ===============
+  react: {
+    // =============== Hooks ===============
+    useTemplateRef: {
+      target: "useRef",
+      package: PACKAGE_NAME.react,
+      type: "none"
     },
-    effectful: {
-      ref: "useVRef",
-      reactive: "useReactive",
-      computed: "useComputed",
-      readonly: "useReadonly",
-      toRef: "useToVRef",
-      toRefs: "useToVRefs",
-      toRaw: "useToRaw",
-      inject: "useInject",
-      watch: "useWatch",
-      shallowRef: "useShallowRef",
-      shallowReactive: "useShallowReactive",
-      shallowReadonly: "useShallowReadonly",
-      isRef: "isRef",
-      isProxy: "isProxy",
-      isReactive: "isReactive"
+    defineExpose: {
+      target: "useImperativeHandle",
+      package: PACKAGE_NAME.react,
+      type: "none"
     }
   },
-  transform: {
-    pure: {
-      useTemplateRef: "useRef",
-      watchEffect: {
-        watchEffect: "useWatchEffect",
-        watchPostEffect: "useWatchPostEffect",
-        watchSyncEffect: "useWatchSyncEffect"
-      },
-      lifecycle: {
-        onBeforeUpdate: "useBeforeUpdate",
-        onUpdated: "useUpdated"
-      }
+  // ============== [VuReact Runtime Core] ===============
+  runtime: {
+    // =============== Components ===============
+    KeepAlive: {
+      target: "KeepAlive",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
     },
-    effectful: {}
-  }
-};
-var ADAPTER_ROUTER_APIS = {
-  renameOnly: {
-    pure: {
-      createRouter: "createRouter",
-      onBeforeRouteLeave: "useBeforeRouteLeave",
-      onBeforeRouteUpdate: "useBeforeRouteUpdate",
-      onBeforeRouteEnter: "useBeforeRouteEnter"
+    Suspense: {
+      target: "Suspense",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    Teleport: {
+      target: "Teleport",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    Component: {
+      target: "Component",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    provide: {
+      target: "Provider",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    Transition: {
+      target: "Transition",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    TransitionGroup: {
+      target: "TransitionGroup",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    // =============== Hooks ===============
+    useActived: {
+      target: "useActived",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    useDeactivated: {
+      target: "useDeactivated",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    onBeforeMount: {
+      target: "useBeforeMount",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    onBeforeUnMount: {
+      target: "useBeforeUnMount",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    onMounted: {
+      target: "useMounted",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    onUnmounted: {
+      target: "useUnmounted",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    onBeforeUpdate: {
+      target: "useBeforeUpdate",
+      package: PACKAGE_NAME.runtime,
+      type: "analyzed-deps"
+    },
+    onUpdated: {
+      target: "useUpdated",
+      package: PACKAGE_NAME.runtime,
+      type: "analyzed-deps"
+    },
+    ref: {
+      target: "useVRef",
+      package: PACKAGE_NAME.runtime,
+      type: "rename",
+      isTrackable: true
+    },
+    reactive: {
+      target: "useReactive",
+      package: PACKAGE_NAME.runtime,
+      type: "rename",
+      isTrackable: true
+    },
+    computed: {
+      target: "useComputed",
+      package: PACKAGE_NAME.runtime,
+      type: "rename",
+      isTrackable: true
+    },
+    readonly: {
+      target: "useReadonly",
+      package: PACKAGE_NAME.runtime,
+      type: "rename",
+      isTrackable: true
+    },
+    toRef: {
+      target: "useToVRef",
+      package: PACKAGE_NAME.runtime,
+      type: "rename",
+      isTrackable: true
+    },
+    toRefs: {
+      target: "useToVRefs",
+      package: PACKAGE_NAME.runtime,
+      type: "rename",
+      isTrackable: true
+    },
+    toRaw: {
+      target: "useToRaw",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    inject: {
+      target: "useInject",
+      package: PACKAGE_NAME.runtime,
+      type: "rename",
+      isTrackable: true
+    },
+    shallowRef: {
+      target: "useShallowRef",
+      package: PACKAGE_NAME.runtime,
+      type: "rename",
+      isTrackable: true
+    },
+    shallowReactive: {
+      target: "useShallowReactive",
+      package: PACKAGE_NAME.runtime,
+      type: "rename",
+      isTrackable: true
+    },
+    shallowReadonly: {
+      target: "useShallowReadonly",
+      package: PACKAGE_NAME.runtime,
+      type: "rename",
+      isTrackable: true
+    },
+    isRef: {
+      target: "isRef",
+      package: PACKAGE_NAME.runtime,
+      type: "rename",
+      isTrackable: true
+    },
+    isProxy: {
+      target: "isProxy",
+      package: PACKAGE_NAME.runtime,
+      type: "rename",
+      isTrackable: true
+    },
+    isReactive: {
+      target: "isReactive",
+      package: PACKAGE_NAME.runtime,
+      type: "rename",
+      isTrackable: true
+    },
+    watch: {
+      target: "useWatch",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    watchEffect: {
+      target: "useWatchEffect",
+      package: PACKAGE_NAME.runtime,
+      type: "analyzed-deps"
+    },
+    watchPostEffect: {
+      target: "useWatchPostEffect",
+      package: PACKAGE_NAME.runtime,
+      type: "analyzed-deps"
     },
-    effectful: {
-      useRoute: "useRoute",
-      useRouter: "useRouter",
-      useLink: "useLink"
+    watchSyncEffect: {
+      target: "useWatchSyncEffect",
+      package: PACKAGE_NAME.runtime,
+      type: "analyzed-deps"
+    },
+    // =============== Directive Utils ===============
+    dir: {
+      target: "dir",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    dirCls: {
+      target: "dir.cls",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    dirKeyless: {
+      target: "dir.keyless",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    dirOn: {
+      target: "dir.On",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    dirStyle: {
+      target: "dir.style",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
+    },
+    nextTick: {
+      target: "nextTick",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
     }
   },
-  transform: {
-    pure: {},
-    effectful: {}
+  // =================== [VuReact Router] ===================
+  router: {
+    // =============== Components ===============
+    RouterLink: {
+      target: "RouterLink",
+      package: PACKAGE_NAME.router,
+      type: "rename"
+    },
+    RouterView: {
+      target: "RouterView",
+      package: PACKAGE_NAME.router,
+      type: "rename"
+    },
+    createRouter: {
+      target: "createRouter",
+      package: PACKAGE_NAME.router,
+      type: "rename"
+    },
+    // =============== Hooks ===============
+    useRoute: {
+      target: "useRoute",
+      package: PACKAGE_NAME.router,
+      type: "rename",
+      isTrackable: true
+    },
+    useRouter: {
+      target: "useRouter",
+      package: PACKAGE_NAME.router,
+      type: "rename",
+      isTrackable: true
+    },
+    useLink: {
+      target: "useLink",
+      package: PACKAGE_NAME.router,
+      type: "rename",
+      isTrackable: true
+    },
+    onBeforeRouteLeave: {
+      target: "useBeforeRouteLeave",
+      package: PACKAGE_NAME.router,
+      type: "rename"
+    },
+    onBeforeRouteUpdate: {
+      target: "useBeforeRouteUpdate",
+      package: PACKAGE_NAME.router,
+      type: "rename"
+    },
+    onBeforeRouteEnter: {
+      target: "useBeforeRouteEnter",
+      package: PACKAGE_NAME.router,
+      type: "rename"
+    }
   }
 };
 
+// src/consts/vue-api-map.ts
+var VUE_API_MAP = {
+  ref: "ref",
+  provide: "provide",
+  watch: "watch",
+  watchEffect: "watchEffect",
+  watchPostEffect: "watchPostEffect",
+  watchSyncEffect: "watchSyncEffect",
+  useTemplateRef: "useTemplateRef",
+  defineAsyncComponent: "defineAsyncComponent",
+  DynamicComponent: "Component",
+  Transition: "Transition",
+  RouterLink: "RouterLink"
+};
+
 // src/core/codegen/component/jsx/utils/jsx-element-utils.ts
 
 function createJsxElement(tag, props, children, selfClosing) {
@@ -705,7 +961,8 @@ function buildCtxProviderNode(nodeIR, ctx, children) {
     buildJsxExpressionNode(t10.identifier(value))
   );
   void ctx;
-  return createJsxElement(ADAPTER_COMPS.Provider, [keyProp, valueProp], childNodes);
+  const adpater = ADAPTER_RULES.runtime[VUE_API_MAP.provide];
+  return createJsxElement(adpater.target, [keyProp, valueProp], childNodes);
 }
 
 // src/core/codegen/component/jsx/syntax-processor/postprocess/build-root-jsx.ts
@@ -783,9 +1040,11 @@ var REACT_API_MAP = {
   lazy: "lazy",
   memo: "memo",
   useRef: "useRef",
-  useCallback: "useCallback",
   useMemo: "useMemo",
-  ReactNode: "ReactNode"
+  ReactNode: "ReactNode",
+  forwardRef: "forwardRef",
+  useCallback: "useCallback",
+  useImperativeHandle: "useImperativeHandle"
 };
 
 // src/utils/camelCase.ts
@@ -825,10 +1084,13 @@ function buildComponent(scriptIR, ctx, state) {
   const hasProps = getHasProps(propsTSIface.propsTypes) || getHasProps(propsTSIface.emitTypes) || getHasProps(propsTSIface.slotTypes);
   const shouldMemo = scriptIR !== null || hasProps;
   const jsxStatement = t12.returnStatement(state.jsx || t12.nullLiteral());
-  const component = !shouldMemo ? resolveComponent(jsxStatement, ctx) : resolveMemoComponent(scriptIR.statement.local, jsxStatement, ctx);
+  const component = !shouldMemo ? resolvePureUIComponent(jsxStatement, ctx) : resolveMemoComponent(scriptIR.statement.local, jsxStatement, ctx);
   state.component = component;
 }
-function resolveComponent(jsxStmt, ctx) {
+function getHasProps(list) {
+  return list.length > 0;
+}
+function resolvePureUIComponent(jsxStmt, ctx) {
   return t12.variableDeclaration("const", [
     t12.variableDeclarator(
       resolveComponentName(ctx),
@@ -838,12 +1100,14 @@ function resolveComponent(jsxStmt, ctx) {
 }
 function resolveMemoComponent(local, jsxStmt, ctx) {
   const name = resolveComponentName(ctx);
-  const param = resolveParam(ctx);
-  const component = t12.arrowFunctionExpression(
-    !param ? [] : [param],
-    t12.blockStatement(resolveStatements(local, jsxStmt))
-  );
-  const memoCall = t12.callExpression(t12.identifier(REACT_API_MAP.memo), [component]);
+  const param = resolvePropsParam(ctx);
+  const body = t12.blockStatement(resolveLocalStatements(local, jsxStmt));
+  const component = resolveComponent(param, body, ctx);
+  let compFn = component;
+  if (ctx.scriptData.forwardRef.enabled) {
+    compFn = resolveForwardRef(body, ctx);
+  }
+  const memoCall = t12.callExpression(t12.identifier(REACT_API_MAP.memo), [compFn]);
   return t12.variableDeclaration("const", [t12.variableDeclarator(name, memoCall)]);
 }
 function resolveComponentName(ctx) {
@@ -860,7 +1124,52 @@ function resolveComponentName(ctx) {
   }
   return t12.identifier(name);
 }
-function resolveParam(ctx) {
+function resolveLocalStatements(local, jsx) {
+  const stmts = [jsx];
+  if (!local) return stmts;
+  if (typeof local === "object" && "program" in local) {
+    const program3 = local.program;
+    if (_optionalChain([program3, 'optionalAccess', _28 => _28.body, 'optionalAccess', _29 => _29.length])) {
+      return [...program3.body, jsx];
+    }
+  }
+  return stmts;
+}
+function resolveComponent(param, body, ctx) {
+  const {
+    scriptData: { forwardRef }
+  } = ctx;
+  if (forwardRef.enabled) {
+    return resolveForwardRef(body, ctx);
+  }
+  const baseComponent = t12.arrowFunctionExpression(!param ? [] : [param], body);
+  return baseComponent;
+}
+function resolveForwardRef(body, ctx) {
+  const {
+    propField,
+    scriptData: { forwardRef, lang }
+  } = ctx;
+  const params = [t12.identifier(forwardRef.refField)];
+  const propsId = resolvePropsParam(ctx);
+  const callExpr = t12.callExpression(t12.identifier(REACT_API_MAP.forwardRef), [
+    t12.arrowFunctionExpression(params, body)
+  ]);
+  if (lang.startsWith("ts")) {
+    const types = [t12.tsAnyKeyword()];
+    if (propsId) {
+      const propsType = _optionalChain([propsId, 'optionalAccess', _30 => _30.typeAnnotation, 'optionalAccess', _31 => _31.typeAnnotation]);
+      types.push(propsType || t12.tsAnyKeyword());
+    }
+    callExpr.typeParameters = t12.tsTypeParameterInstantiation(types);
+  }
+  if (propsId) {
+    propsId.typeAnnotation = null;
+    params.unshift(propsId);
+  }
+  return callExpr;
+}
+function resolvePropsParam(ctx) {
   const { propField, scriptData } = ctx;
   const { propsTSIface } = scriptData;
   const propsIdentifier = t12.identifier(propField);
@@ -877,24 +1186,10 @@ function resolveParam(ctx) {
   propsIdentifier.typeAnnotation = t12.tsTypeAnnotation(t12.tsTypeReference(typeIdentifier));
   return propsIdentifier;
 }
-function resolveStatements(local, jsx) {
-  const stmts = [jsx];
-  if (!local) return stmts;
-  if (typeof local === "object" && "program" in local) {
-    const program3 = local.program;
-    if (_optionalChain([program3, 'optionalAccess', _28 => _28.body, 'optionalAccess', _29 => _29.length])) {
-      return [...program3.body, jsx];
-    }
-  }
-  return stmts;
-}
-function getHasProps(list) {
-  return list.length > 0;
-}
 
 // src/core/codegen/component/script/syntax-processor/process/build-program-preamble.ts
 function buildProgramPreamble(nodeIR, ctx, state) {
-  const statements = [_optionalChain([nodeIR, 'optionalAccess', _30 => _30.imports]), _optionalChain([nodeIR, 'optionalAccess', _31 => _31.tsTypes]), _optionalChain([nodeIR, 'optionalAccess', _32 => _32.exports]), _optionalChain([nodeIR, 'optionalAccess', _33 => _33.statement, 'access', _34 => _34.global])].flat().filter(Boolean);
+  const statements = [_optionalChain([nodeIR, 'optionalAccess', _32 => _32.imports]), _optionalChain([nodeIR, 'optionalAccess', _33 => _33.tsTypes]), _optionalChain([nodeIR, 'optionalAccess', _34 => _34.exports]), _optionalChain([nodeIR, 'optionalAccess', _35 => _35.statement, 'access', _36 => _36.global])].flat().filter(Boolean);
   state.preambleStatements = statements;
   void ctx;
 }
@@ -949,7 +1244,7 @@ function generateComponent(ir, ctx, options) {
     code,
     source: ctx.source
   };
-  executePlugins(_optionalChain([options, 'optionalAccess', _35 => _35.plugins]), result, ctx);
+  executePlugins(_optionalChain([options, 'optionalAccess', _37 => _37.plugins]), result, ctx);
   return result;
 }
 
@@ -963,7 +1258,7 @@ function generateOnlyScript(ir, ctx, options) {
     code,
     source: ctx.source
   };
-  executePlugins(_optionalChain([options, 'optionalAccess', _36 => _36.plugins]), result, ctx);
+  executePlugins(_optionalChain([options, 'optionalAccess', _38 => _38.plugins]), result, ctx);
   return result;
 }
 
@@ -1048,7 +1343,7 @@ function parseOnlyScript(source, ctx, options) {
   };
   ctx.scriptData.lang = lang;
   ctx.scriptData.source = source;
-  executePlugins(_optionalChain([options, 'optionalAccess', _37 => _37.plugins]), result, ctx);
+  executePlugins(_optionalChain([options, 'optionalAccess', _39 => _39.plugins]), result, ctx);
   return result;
 }
 
@@ -1083,8 +1378,8 @@ function resolveScript(descriptor, ctx, pResult) {
   } else {
     result.ast = _parser.parse.call(void 0, result.source.content, options);
   }
-  if (_optionalChain([scriptBlock, 'optionalAccess', _38 => _38.warnings])) {
-    _optionalChain([scriptBlock, 'optionalAccess', _39 => _39.warnings, 'access', _40 => _40.forEach, 'call', _41 => _41((msg) => {
+  if (_optionalChain([scriptBlock, 'optionalAccess', _40 => _40.warnings])) {
+    _optionalChain([scriptBlock, 'optionalAccess', _41 => _41.warnings, 'access', _42 => _42.forEach, 'call', _43 => _43((msg) => {
       logger.warn(msg, { file: ctx.filename });
     })]);
   }
@@ -1159,7 +1454,7 @@ function extractSetupBodyToTopLevel(content, options) {
 }
 function extractCompName(source) {
   const nameMatch = source.match(/@vr-name:\s*(\w+)/);
-  return _optionalChain([nameMatch, 'optionalAccess', _42 => _42[1], 'optionalAccess', _43 => _43.trim, 'call', _44 => _44()]) || "";
+  return _optionalChain([nameMatch, 'optionalAccess', _44 => _44[1], 'optionalAccess', _45 => _45.trim, 'call', _46 => _46()]) || "";
 }
 
 // src/core/parse/sfc/process/resolve-script-meta.ts
@@ -1234,11 +1529,6 @@ var HTML_TAG_TYPES = {
   frame: "HTMLFrameElement"
 };
 
-// src/consts/vue-api-map.ts
-var VUE_API_MAP = {
-  useTemplateRef: "useTemplateRef"
-};
-
 // src/consts/reactive-type-map.ts
 var REACTIVE_TYPE_MAP = {
   ref: "ref",
@@ -1270,7 +1560,7 @@ function getReactiveStateApis() {
 
 // src/core/parse/sfc/process/resolve-script-meta.ts
 function resolveScriptMeta(result, ctx) {
-  const scriptAST = _optionalChain([result, 'access', _45 => _45.script, 'optionalAccess', _46 => _46.ast]);
+  const scriptAST = _optionalChain([result, 'access', _47 => _47.script, 'optionalAccess', _48 => _48.ast]);
   if (!scriptAST) return;
   _core.traverse.call(void 0, scriptAST, {
     VariableDeclarator(path7) {
@@ -1294,7 +1584,7 @@ function collectReactiveBindings(node, ctx) {
   if (!reactiveStateApis.has(source)) return;
   const varName = node.id.name;
   const value = init.arguments[0];
-  if (source === "defineProps") {
+  if (source === MACRO_API_NAMES.props) {
     ctx.propField = varName;
   }
   reactiveBindings[varName] = {
@@ -1310,56 +1600,14 @@ function collectRefBindings(node, ctx) {
   const callee = init.callee;
   if (callee.name !== VUE_API_MAP.useTemplateRef) return;
   const idName = node.id.name;
-  const tag = _optionalChain([init, 'access', _47 => _47.arguments, 'access', _48 => _48[0], 'optionalAccess', _49 => _49.value]);
-  refBindings[idName] = {
+  const tag = _optionalChain([init, 'access', _49 => _49.arguments, 'access', _50 => _50[0], 'optionalAccess', _51 => _51.value]);
+  refBindings.domRefs[idName] = {
     tag,
     htmlType: HTML_TAG_TYPES[tag] || "HTMLElement",
     name: idName
   };
 }
 
-// src/consts/other.ts
-var PACKAGE_NAME = {
-  react: "react",
-  runtime: "@vureact/runtime-core",
-  router: "@vureact/router"
-};
-var STYLE_MODULE_NAME = "$style";
-var MACRO_API_NAMES = {
-  props: "defineProps",
-  emits: "defineEmits",
-  slots: "defineSlots",
-  options: "defineOptions"
-};
-var DOLLAR_IDENTIFIERS = [
-  "$data",
-  "$props",
-  "$el",
-  "$options",
-  "$parent",
-  "$root",
-  "$slots",
-  "$refs",
-  "$attrs",
-  "$emit",
-  "$watch",
-  "$forceUpdate",
-  "$nextTick",
-  "$router",
-  "$route",
-  "$store",
-  "$pinia",
-  "$event"
-];
-var VUE_PACKAGES = [
-  "vue",
-  "vite",
-  "pinia",
-  "nuxt",
-  // 不需要带到 React 项目中
-  "@vureact/compiler-core"
-];
-
 // src/plugins/postcss.ts
 var _postcss = require('postcss'); var _postcss2 = _interopRequireDefault(_postcss);
 function processScopedWithPostCss(input, hash) {
@@ -1411,6 +1659,7 @@ function resolveLessSass(source, options) {
   } else if (lang === "scss" || lang === "sass") {
     result.code = resolveSassSync(source, filename);
   }
+  result.code = resolveImportExtensions(result.code);
   return result;
 }
 function resolveLessSync(source, filename) {
@@ -1462,6 +1711,12 @@ function resolveSassSync(source, filename) {
   const result = sass.compileString(source, options);
   return result.css;
 }
+function resolveImportExtensions(code) {
+  if (code.includes(".less") || code.includes(".scss") || code.includes(".sass")) {
+    return code.replaceAll(/\.(less|scss|sass)(?=['")])/g, ".css");
+  }
+  return code;
+}
 
 // src/core/parse/sfc/process/resolve-styles.ts
 function resolveStyles(descriptor, ctx, result) {
@@ -1519,7 +1774,7 @@ function resolveStyles(descriptor, ctx, result) {
 var _compilercore = require('@vue/compiler-core');
 function resolveTemplate(descriptor, _, result) {
   const block = descriptor.template;
-  if (!_optionalChain([block, 'optionalAccess', _50 => _50.content])) return null;
+  if (!_optionalChain([block, 'optionalAccess', _52 => _52.content])) return null;
   result.template = {
     ast: _compilercore.baseParse.call(void 0, block.content),
     source: block
@@ -1536,7 +1791,7 @@ function processVueSyntax(descriptor, ctx, result) {
 }
 function vueSyntaxProcessor(descriptor, ctx, result, options) {
   const run = (p, type) => {
-    _optionalChain([p, 'optionalAccess', _51 => _51.forEach, 'call', _52 => _52((handler) => {
+    _optionalChain([p, 'optionalAccess', _53 => _53.forEach, 'call', _54 => _54((handler) => {
       if (type === "post") {
         handler(result, ctx);
         return;
@@ -1560,7 +1815,7 @@ function parseSFC(source, ctx, options) {
   };
   collectErrs(descriptor, errors);
   processVueSyntax(descriptor, ctx, result);
-  executePlugins(_optionalChain([options, 'optionalAccess', _53 => _53.plugins]), result, ctx);
+  executePlugins(_optionalChain([options, 'optionalAccess', _55 => _55.plugins]), result, ctx);
   return result;
 }
 function collectErrs(descriptor, errors) {
@@ -1568,7 +1823,7 @@ function collectErrs(descriptor, errors) {
     logger.error(err.message, {
       source: descriptor.source,
       file: descriptor.filename,
-      loc: _optionalChain([err, 'optionalAccess', _54 => _54.loc])
+      loc: _optionalChain([err, 'optionalAccess', _56 => _56.loc])
     });
   }
   if (descriptor.cssVars.length) {
@@ -1706,7 +1961,7 @@ function isVueEcosystemPackage(moduleName) {
 function mergeImports(currentNode, ctx) {
   const moduleName = currentNode.source.value.toLowerCase();
   const ctxImportItems = ctx.imports.get(moduleName);
-  if (!_optionalChain([ctxImportItems, 'optionalAccess', _55 => _55.length])) {
+  if (!_optionalChain([ctxImportItems, 'optionalAccess', _57 => _57.length])) {
     return;
   }
   const currentImports = /* @__PURE__ */ new Set();
@@ -1760,7 +2015,7 @@ function createRequiredImports(ctx) {
 
 function findRootVariablePath(path7) {
   const rootId = findRootIdentifier(path7.node);
-  if (!_optionalChain([rootId, 'optionalAccess', _56 => _56.name])) return null;
+  if (!_optionalChain([rootId, 'optionalAccess', _58 => _58.name])) return null;
   const binding = path7.scope.getBinding(rootId.name);
   if (!binding) return null;
   const rootPath = getVariableDeclaratorPath(binding.path);
@@ -1991,66 +2246,13 @@ function collectLocalStatements(ctx, ast) {
   scriptIR.statement.local = ast;
 }
 
-// src/core/transform/sfc/script/syntax-processor/process/resolve-template-ref.ts
+// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-async-component.ts
 
-function resolveTemplateRef(ctx) {
-  if (ctx.inputType !== "sfc") return {};
+function resolveDefineAsyncComponent(ctx) {
   return {
     CallExpression(path7) {
       const { node } = path7;
-      if (!isCalleeNamed(node, VUE_API_MAP.useTemplateRef)) return;
-      addTypeParam(ctx, path7);
-      replaceValue(node);
-      replaceCallName(node, REACT_API_MAP.useRef);
-      recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.useRef);
-    },
-    MemberExpression(path7) {
-      const { node } = path7;
-      if (node.computed || !t20.isIdentifier(node.property) || node.property.name !== "value") {
-        return;
-      }
-      const rootPath = findRootVariablePath(path7);
-      if (!_optionalChain([rootPath, 'optionalAccess', _57 => _57.node]) || !t20.isCallExpression(rootPath.node.init) || !isCalleeNamed(rootPath.node.init, REACT_API_MAP.useRef)) {
-        return;
-      }
-      const rootId = findRootIdentifier(node);
-      if (!t20.isIdentifier(node.object) || node.object.name !== _optionalChain([rootId, 'optionalAccess', _58 => _58.name])) {
-        return;
-      }
-      node.property.name = "current";
-    }
-  };
-}
-function replaceValue(node) {
-  const initVal = node.arguments[0];
-  const newVal = t20.identifier("null");
-  newVal.start = _optionalChain([initVal, 'optionalAccess', _59 => _59.start]);
-  newVal.end = _optionalChain([initVal, 'optionalAccess', _60 => _60.end]);
-  newVal.loc = _optionalChain([initVal, 'optionalAccess', _61 => _61.loc]);
-  node.arguments[0] = newVal;
-}
-function addTypeParam(ctx, path7) {
-  const { templateData, scriptData } = ctx;
-  const { node, parent } = path7;
-  if (!scriptData.lang.startsWith("ts") && !t20.isVariableDeclarator(parent)) {
-    return;
-  }
-  const idName = parent.id.name;
-  const bindingMeta = templateData.refBindings[idName];
-  if (!node.typeParameters && bindingMeta) {
-    node.typeParameters = t20.tsTypeParameterInstantiation([
-      t20.tsTypeReference(t20.identifier(bindingMeta.htmlType))
-    ]);
-  }
-}
-
-// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-async-component.ts
-
-function resolveAsyncComponent(ctx) {
-  return {
-    CallExpression(path7) {
-      const { node } = path7;
-      if (!isCalleeNamed(node, "defineAsyncComponent")) {
+      if (!isCalleeNamed(node, VUE_API_MAP.defineAsyncComponent)) {
         return;
       }
       const [arg] = node.arguments;
@@ -2061,11 +2263,11 @@ function resolveAsyncComponent(ctx) {
   };
 }
 function checkIsUnsupported(ctx, arg) {
-  if (t21.isFunction(arg)) {
+  if (t20.isFunction(arg)) {
     checkIsDynamicImport(ctx, arg);
-  } else if (t21.isObjectExpression(arg)) {
+  } else if (t20.isObjectExpression(arg)) {
     const { value } = arg.properties.find(
-      (p) => t21.isObjectProperty(p) && t21.isIdentifier(p.key) && p.key.name === "loader"
+      (p) => t20.isObjectProperty(p) && t20.isIdentifier(p.key) && p.key.name === "loader"
     );
     checkIsDynamicImport(ctx, value);
     if (arg.properties.length > 1) {
@@ -2076,31 +2278,31 @@ function checkIsUnsupported(ctx, arg) {
 function checkIsDynamicImport(ctx, node) {
   const { scriptData, filename } = ctx;
   const warnIsNotImport = (target) => {
-    if (!target || !t21.isImport(target)) {
+    if (!target || !t20.isImport(target)) {
       logger.error(
         `Only ES module dynamic imports are supported. You must use and return import('...').`,
         {
           source: scriptData.source,
           file: filename,
-          loc: _optionalChain([target, 'optionalAccess', _62 => _62.loc]) || {}
+          loc: _optionalChain([target, 'optionalAccess', _59 => _59.loc]) || {}
         }
       );
     }
   };
-  if (t21.isFunction(node)) {
+  if (t20.isFunction(node)) {
     checkIsDynamicImport(ctx, node.body);
     return;
   }
-  if (t21.isBlockStatement(node)) {
+  if (t20.isBlockStatement(node)) {
     const [returnSmt] = node.body;
-    if (t21.isReturnStatement(returnSmt)) {
+    if (t20.isReturnStatement(returnSmt)) {
       warnIsNotImport(returnSmt.argument);
     }
     return;
   }
-  if (t21.isCallExpression(node)) {
+  if (t20.isCallExpression(node)) {
     warnIsNotImport(node.callee);
-    if (t21.isStringLiteral(node.arguments[0])) {
+    if (t20.isStringLiteral(node.arguments[0])) {
       replaceVueSuffix(ctx, node.arguments[0]);
     }
     return;
@@ -2134,7 +2336,7 @@ function pushToGlobalScope(path7, ctx) {
     declarationPath = declarationPath.parentPath;
   }
   let fullNode;
-  if (_optionalChain([declarationPath, 'optionalAccess', _63 => _63.isVariableDeclaration, 'call', _64 => _64()])) {
+  if (_optionalChain([declarationPath, 'optionalAccess', _60 => _60.isVariableDeclaration, 'call', _61 => _61()])) {
     fullNode = declarationPath.node;
     declarationPath.remove();
   } else if (path7.parentPath.isVariableDeclarator()) {
@@ -2148,61 +2350,64 @@ function pushToGlobalScope(path7, ctx) {
   scriptIR.statement.global.push(fullNode);
 }
 
-// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-emit-calls.ts
+// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-expose.ts
 
-function resolveEmitCalls(ctx) {
+
+// src/core/transform/sfc/script/shared/hook-creator.ts
+
+function createUseCallback(body, deps) {
+  return t21.callExpression(t21.identifier(REACT_API_MAP.useCallback), [
+    body,
+    _nullishCoalesce(deps, () => ( t21.arrayExpression([])))
+  ]);
+}
+function createUseMemo(body, deps) {
+  return t21.callExpression(t21.identifier(REACT_API_MAP.useMemo), [
+    t21.arrowFunctionExpression([], body),
+    _nullishCoalesce(deps, () => ( t21.arrayExpression([])))
+  ]);
+}
+function createUseImperativeHandle(refId, init) {
+  return t21.callExpression(t21.identifier(REACT_API_MAP.useImperativeHandle), [refId, init]);
+}
+
+// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-expose.ts
+function resolveDefineExpose(ctx) {
+  if (ctx.inputType !== "sfc") return {};
   return {
     CallExpression(path7) {
       const { node } = path7;
-      const { filename, templateData, scriptData } = ctx;
-      if (!t22.isIdentifier(node.callee)) return;
-      const { name } = node.callee;
-      const checkIfFromDefineEmits = () => {
-        let result = false;
-        const meta = templateData.reactiveBindings[name];
-        if (meta) {
-          result = meta.source === MACRO_API_NAMES.emits;
-        }
-        if (!result) {
-          const binding = path7.scope.getBinding(name);
-          if (binding) {
-            const parent = binding.path.node;
-            if (t22.isVariableDeclarator(parent) && t22.isCallExpression(parent.init) && t22.isIdentifier(parent.init.callee)) {
-              result = parent.init.callee.name === MACRO_API_NAMES.emits;
-            }
-          }
-        }
-        return result;
-      };
-      if (!checkIfFromDefineEmits()) return;
-      const [callee, ...args] = node.arguments;
-      const eventName = t22.isStringLiteral(callee) ? `on${capitalize(camelCase(callee.value))}` : void 0;
-      if (!eventName) {
-        logger.warn(`Expected String type but got ${_optionalChain([callee, 'optionalAccess', _65 => _65.type])}, expression will be removed`, {
-          file: filename,
-          source: scriptData.source,
-          loc: _optionalChain([callee, 'optionalAccess', _66 => _66.loc])
-        });
+      const { filename, scriptData } = ctx;
+      if (!isCalleeNamed(node, MACRO_API_NAMES.expose)) {
+        return;
+      }
+      const [expose] = node.arguments;
+      if (!expose) {
         path7.remove();
         return;
       }
-      const propCall = t22.callExpression(
-        t22.optionalMemberExpression(
-          t22.identifier(ctx.propField),
-          t22.identifier(eventName),
-          false,
-          true
-        ),
-        args
-      );
-      path7.replaceWith(propCall);
+      const adapter = ADAPTER_RULES.react[MACRO_API_NAMES.expose];
+      recordImport(ctx, adapter.package, REACT_API_MAP.forwardRef);
+      recordImport(ctx, adapter.package, adapter.target);
+      if (!t22.isObjectExpression(expose) && !t22.isFunction(expose)) {
+        logger.warn("Non-deterministic object literal may cause unknown risks.", {
+          file: filename,
+          loc: expose.loc,
+          source: scriptData.source
+        });
+      }
+      const init = !t22.isFunction(expose) ? t22.arrowFunctionExpression([], expose) : expose;
+      const { forwardRef } = scriptData;
+      const newNode = createUseImperativeHandle(t22.identifier(forwardRef.refField), init);
+      forwardRef.enabled = true;
+      path7.replaceWith(newNode);
     }
   };
 }
 
-// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-options.ts
+// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-options.ts
 
-function resolveOptions(ctx) {
+function resolveDefineOptions(ctx) {
   return {
     CallExpression(path7) {
       const { node } = path7;
@@ -2215,7 +2420,7 @@ function resolveOptions(ctx) {
         logger.warn("defineOptions was found, but no options were provided.", {
           source: scriptData.source,
           file: filename,
-          loc: _optionalChain([node, 'optionalAccess', _67 => _67.loc])
+          loc: _optionalChain([node, 'optionalAccess', _62 => _62.loc])
         });
         path7.remove();
         return;
@@ -2224,35 +2429,87 @@ function resolveOptions(ctx) {
         logger.warn("Argument for defineOptions must be an object expression.", {
           source: scriptData.source,
           file: filename,
-          loc: _optionalChain([options, 'optionalAccess', _68 => _68.loc])
+          loc: _optionalChain([options, 'optionalAccess', _63 => _63.loc])
         });
       } else {
         for (const prop of options.properties) {
           if (!t23.isObjectProperty(prop) || !t23.isIdentifier(prop.key)) {
             continue;
           }
-          extractName(prop, ctx);
+          extractName(prop, ctx);
+        }
+      }
+      path7.remove();
+    }
+  };
+}
+function extractName(prop, ctx) {
+  if (ctx.compName) return;
+  const { filename, scriptData } = ctx;
+  if (!prop.computed && prop.key.name === "name") {
+    if (t23.isStringLiteral(prop.value)) {
+      ctx.compName = prop.value.value;
+      return;
+    }
+    logger.error(`name must be a string type, but got ${prop.value.type}`, {
+      source: scriptData.source,
+      file: filename,
+      loc: _optionalChain([prop, 'access', _64 => _64.key, 'optionalAccess', _65 => _65.loc])
+    });
+  }
+}
+
+// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-emit-calls.ts
+
+function resolveEmitCalls(ctx) {
+  return {
+    CallExpression(path7) {
+      const { node } = path7;
+      const { filename, templateData, scriptData } = ctx;
+      if (!t24.isIdentifier(node.callee)) return;
+      const { name } = node.callee;
+      const checkIfFromDefineEmits = () => {
+        let result = false;
+        const meta = templateData.reactiveBindings[name];
+        if (meta) {
+          result = meta.source === MACRO_API_NAMES.emits;
+        }
+        if (!result) {
+          const binding = path7.scope.getBinding(name);
+          if (binding) {
+            const parent = binding.path.node;
+            if (t24.isVariableDeclarator(parent) && t24.isCallExpression(parent.init) && t24.isIdentifier(parent.init.callee)) {
+              result = parent.init.callee.name === MACRO_API_NAMES.emits;
+            }
+          }
         }
+        return result;
+      };
+      if (!checkIfFromDefineEmits()) return;
+      const [callee, ...args] = node.arguments;
+      const eventName = t24.isStringLiteral(callee) ? `on${capitalize(camelCase(callee.value))}` : void 0;
+      if (!eventName) {
+        logger.warn(`Expected String type but got ${_optionalChain([callee, 'optionalAccess', _66 => _66.type])}, expression will be removed`, {
+          file: filename,
+          source: scriptData.source,
+          loc: _optionalChain([callee, 'optionalAccess', _67 => _67.loc])
+        });
+        path7.remove();
+        return;
       }
-      path7.remove();
+      const propCall = t24.callExpression(
+        t24.optionalMemberExpression(
+          t24.identifier(ctx.propField),
+          t24.identifier(eventName),
+          false,
+          true
+        ),
+        args
+      );
+      path7.replaceWith(propCall);
     }
   };
 }
-function extractName(prop, ctx) {
-  if (ctx.compName) return;
-  const { filename, scriptData } = ctx;
-  if (!prop.computed && prop.key.name === "name") {
-    if (t23.isStringLiteral(prop.value)) {
-      ctx.compName = prop.value.value;
-      return;
-    }
-    logger.error(`name must be a string type, but got ${prop.value.type}`, {
-      source: scriptData.source,
-      file: filename,
-      loc: _optionalChain([prop, 'access', _69 => _69.key, 'optionalAccess', _70 => _70.loc])
-    });
-  }
-}
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/index.ts
 
@@ -2264,21 +2521,21 @@ function extractName(prop, ctx) {
 
 function cloneCallableParams(params) {
   const cloneCallableParam = (param, index) => {
-    if (t24.isRestElement(param)) {
+    if (t25.isRestElement(param)) {
       const arg = param.argument;
-      const name = t24.isIdentifier(arg) ? arg.name : `args${index}`;
-      const rest = t24.restElement(t24.identifier(name));
-      rest.typeAnnotation = param.typeAnnotation || (t24.isIdentifier(arg) ? arg.typeAnnotation : null) || t24.tsTypeAnnotation(t24.tsArrayType(t24.tsAnyKeyword()));
+      const name = t25.isIdentifier(arg) ? arg.name : `args${index}`;
+      const rest = t25.restElement(t25.identifier(name));
+      rest.typeAnnotation = param.typeAnnotation || (t25.isIdentifier(arg) ? arg.typeAnnotation : null) || t25.tsTypeAnnotation(t25.tsArrayType(t25.tsAnyKeyword()));
       return rest;
     }
-    if (t24.isIdentifier(param)) {
-      const id = t24.identifier(param.name || `arg${index}`);
+    if (t25.isIdentifier(param)) {
+      const id = t25.identifier(param.name || `arg${index}`);
       id.optional = param.optional;
-      id.typeAnnotation = param.typeAnnotation || t24.tsTypeAnnotation(t24.tsAnyKeyword());
+      id.typeAnnotation = param.typeAnnotation || t25.tsTypeAnnotation(t25.tsAnyKeyword());
       return id;
     }
-    const fallback = t24.identifier(`arg${index}`);
-    fallback.typeAnnotation = t24.tsTypeAnnotation(t24.tsAnyKeyword());
+    const fallback = t25.identifier(`arg${index}`);
+    fallback.typeAnnotation = t25.tsTypeAnnotation(t25.tsAnyKeyword());
     return fallback;
   };
   return params.map(cloneCallableParam);
@@ -2288,18 +2545,18 @@ function cloneCallableParams(params) {
 function resolveEmitsTopLevelTypes(ctx) {
   return {
     "TSInterfaceDeclaration|TSTypeAliasDeclaration"(path7) {
-      if (!t25.isProgram(path7.parent)) return;
+      if (!t26.isProgram(path7.parent)) return;
       const { node } = path7;
-      if (t25.isTSInterfaceDeclaration(node)) {
-        const typeLiteral = t25.tsTypeLiteral(node.body.body);
+      if (t26.isTSInterfaceDeclaration(node)) {
+        const typeLiteral = t26.tsTypeLiteral(node.body.body);
         if (!hasEmitsSignatureInType(typeLiteral)) return;
         const resolved = resolveTopLevelEmitType(typeLiteral);
-        if (resolved && t25.isTSTypeLiteral(resolved)) {
+        if (resolved && t26.isTSTypeLiteral(resolved)) {
           node.body.body = resolved.members;
         }
         return;
       }
-      if (t25.isTSTypeAliasDeclaration(node)) {
+      if (t26.isTSTypeAliasDeclaration(node)) {
         if (!hasEmitsSignatureInType(node.typeAnnotation)) return;
         const resolved = resolveTopLevelEmitType(node.typeAnnotation);
         if (resolved) {
@@ -2310,55 +2567,55 @@ function resolveEmitsTopLevelTypes(ctx) {
   };
 }
 function resolveTopLevelEmitType(tsType) {
-  if (t25.isTSParenthesizedType(tsType)) {
+  if (t26.isTSParenthesizedType(tsType)) {
     return resolveTopLevelEmitType(tsType.typeAnnotation);
   }
-  if (t25.isTSTypeReference(tsType)) {
+  if (t26.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return tsType;
     }
     const params = tsType.typeParameters.params.map((param) => resolveTopLevelEmitType(param)).filter(Boolean);
-    return t25.tsTypeReference(
+    return t26.tsTypeReference(
       tsType.typeName,
-      t25.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
+      t26.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
     );
   }
-  if (t25.isTSIntersectionType(tsType)) {
+  if (t26.isTSIntersectionType(tsType)) {
     const types = tsType.types.map(resolveTopLevelEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t25.tsIntersectionType(types);
+    return t26.tsIntersectionType(types);
   }
-  if (t25.isTSUnionType(tsType)) {
+  if (t26.isTSUnionType(tsType)) {
     const types = tsType.types.map(resolveTopLevelEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t25.tsUnionType(types);
+    return t26.tsUnionType(types);
   }
-  if (t25.isTSTypeLiteral(tsType)) {
+  if (t26.isTSTypeLiteral(tsType)) {
     const members = [];
     for (const member of tsType.members) {
-      if (t25.isTSCallSignatureDeclaration(member)) {
+      if (t26.isTSCallSignatureDeclaration(member)) {
         members.push(...resolveEmitPropsFromCallSignature(member));
         continue;
       }
       members.push(member);
     }
     if (!members.length) return null;
-    return t25.tsTypeLiteral(members);
+    return t26.tsTypeLiteral(members);
   }
-  if (t25.isTSFunctionType(tsType)) {
+  if (t26.isTSFunctionType(tsType)) {
     const props = resolveEmitPropsFromCallable(tsType.parameters, tsType.typeAnnotation);
     if (!props.length) return null;
-    return t25.tsTypeLiteral(props);
+    return t26.tsTypeLiteral(props);
   }
   return tsType;
 }
 function resolveDefineEmitsIface(path7, ctx) {
   const { node } = path7;
   const [runtimeArg] = node.arguments;
-  const tsParams = _optionalChain([node, 'access', _71 => _71.typeParameters, 'optionalAccess', _72 => _72.params]);
-  if (_optionalChain([tsParams, 'optionalAccess', _73 => _73.length])) {
+  const tsParams = _optionalChain([node, 'access', _68 => _68.typeParameters, 'optionalAccess', _69 => _69.params]);
+  if (_optionalChain([tsParams, 'optionalAccess', _70 => _70.length])) {
     processExplicitType(ctx, tsParams);
     return;
   }
@@ -2371,41 +2628,41 @@ function processInferredTypes(ctx, runtimeArg) {
     propsTSIface: { emitTypes }
   } = ctx.scriptData;
   const members = [];
-  if (t25.isArrayExpression(runtimeArg)) {
+  if (t26.isArrayExpression(runtimeArg)) {
     for (const element of runtimeArg.elements) {
-      if (!element || !t25.isStringLiteral(element)) continue;
+      if (!element || !t26.isStringLiteral(element)) continue;
       const handlerName = resolveEmitHandlerName(element.value);
       const key = buildKey(handlerName);
-      const fnType = t25.tsFunctionType(
+      const fnType = t26.tsFunctionType(
         null,
         [createRestAnyParam("args")],
-        t25.tsTypeAnnotation(t25.tsAnyKeyword())
+        t26.tsTypeAnnotation(t26.tsAnyKeyword())
       );
-      const prop = t25.tsPropertySignature(key, t25.tsTypeAnnotation(fnType));
+      const prop = t26.tsPropertySignature(key, t26.tsTypeAnnotation(fnType));
       prop.optional = true;
       members.push(prop);
     }
     if (members.length) {
-      emitTypes.push(t25.tsTypeLiteral(members));
+      emitTypes.push(t26.tsTypeLiteral(members));
     }
     return;
   }
-  if (t25.isObjectExpression(runtimeArg)) {
+  if (t26.isObjectExpression(runtimeArg)) {
     for (const prop of runtimeArg.properties) {
-      if (!t25.isObjectProperty(prop)) continue;
-      if (t25.isSpreadElement(prop)) continue;
+      if (!t26.isObjectProperty(prop)) continue;
+      if (t26.isSpreadElement(prop)) continue;
       const rawName = resolvePropName(prop.key);
       if (!rawName) continue;
       const handlerName = resolveEmitHandlerName(rawName);
       const key = buildKey(handlerName);
-      const params = t25.isArrayExpression(prop.value) ? resolveRuntimeTupleParams(prop.value) : [createRestAnyParam("args")];
-      const fnType = t25.tsFunctionType(null, params, t25.tsTypeAnnotation(t25.tsAnyKeyword()));
-      const propSig = t25.tsPropertySignature(key, t25.tsTypeAnnotation(fnType));
+      const params = t26.isArrayExpression(prop.value) ? resolveRuntimeTupleParams(prop.value) : [createRestAnyParam("args")];
+      const fnType = t26.tsFunctionType(null, params, t26.tsTypeAnnotation(t26.tsAnyKeyword()));
+      const propSig = t26.tsPropertySignature(key, t26.tsTypeAnnotation(fnType));
       propSig.optional = true;
       members.push(propSig);
     }
     if (members.length) {
-      emitTypes.push(t25.tsTypeLiteral(members));
+      emitTypes.push(t26.tsTypeLiteral(members));
     }
   }
 }
@@ -2426,129 +2683,129 @@ function resolveEmitHandlerName(rawName) {
   return `on${name}`;
 }
 function resolvePropName(key) {
-  if (t25.isIdentifier(key)) return key.name;
-  if (t25.isStringLiteral(key)) return key.value;
-  if (t25.isNumericLiteral(key)) return String(key.value);
+  if (t26.isIdentifier(key)) return key.name;
+  if (t26.isStringLiteral(key)) return key.value;
+  if (t26.isNumericLiteral(key)) return String(key.value);
   return null;
 }
 function buildKey(name) {
-  return t25.isValidIdentifier(name) ? t25.identifier(name) : t25.stringLiteral(name);
+  return t26.isValidIdentifier(name) ? t26.identifier(name) : t26.stringLiteral(name);
 }
 function createRestAnyParam(name) {
-  const id = t25.identifier(name);
-  const rest = t25.restElement(id);
-  rest.typeAnnotation = t25.tsTypeAnnotation(t25.tsArrayType(t25.tsAnyKeyword()));
+  const id = t26.identifier(name);
+  const rest = t26.restElement(id);
+  rest.typeAnnotation = t26.tsTypeAnnotation(t26.tsArrayType(t26.tsAnyKeyword()));
   return rest;
 }
 function resolveRuntimeTupleParams(value) {
   const params = [];
   value.elements.forEach((element, index) => {
     if (!element) return;
-    if (t25.isSpreadElement(element)) {
+    if (t26.isSpreadElement(element)) {
       params.push(createRestAnyParam(`args${index}`));
       return;
     }
-    if (t25.isIdentifier(element)) {
-      const id = t25.identifier(element.name);
-      id.typeAnnotation = element.typeAnnotation || t25.tsTypeAnnotation(t25.tsAnyKeyword());
+    if (t26.isIdentifier(element)) {
+      const id = t26.identifier(element.name);
+      id.typeAnnotation = element.typeAnnotation || t26.tsTypeAnnotation(t26.tsAnyKeyword());
       params.push(id);
       return;
     }
-    if (t25.isTSAsExpression(element)) {
-      const id = t25.identifier(`arg${index}`);
-      id.typeAnnotation = t25.tsTypeAnnotation(element.typeAnnotation);
+    if (t26.isTSAsExpression(element)) {
+      const id = t26.identifier(`arg${index}`);
+      id.typeAnnotation = t26.tsTypeAnnotation(element.typeAnnotation);
       params.push(id);
       return;
     }
-    const fallback = t25.identifier(`arg${index}`);
-    fallback.typeAnnotation = t25.tsTypeAnnotation(t25.tsAnyKeyword());
+    const fallback = t26.identifier(`arg${index}`);
+    fallback.typeAnnotation = t26.tsTypeAnnotation(t26.tsAnyKeyword());
     params.push(fallback);
   });
   return params;
 }
 function resolveExplicitEmitType(tsType) {
-  if (t25.isTSParenthesizedType(tsType)) {
+  if (t26.isTSParenthesizedType(tsType)) {
     return resolveExplicitEmitType(tsType.typeAnnotation);
   }
-  if (t25.isTSTypeReference(tsType)) {
+  if (t26.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return tsType;
     }
     const params = tsType.typeParameters.params.map((param) => resolveExplicitEmitType(param)).filter(Boolean);
-    return t25.tsTypeReference(
+    return t26.tsTypeReference(
       tsType.typeName,
-      t25.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
+      t26.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
     );
   }
-  if (t25.isTSIntersectionType(tsType)) {
+  if (t26.isTSIntersectionType(tsType)) {
     const types = tsType.types.map(resolveExplicitEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t25.tsIntersectionType(types);
+    return t26.tsIntersectionType(types);
   }
-  if (t25.isTSUnionType(tsType)) {
+  if (t26.isTSUnionType(tsType)) {
     const types = tsType.types.map(resolveExplicitEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t25.tsUnionType(types);
+    return t26.tsUnionType(types);
   }
-  if (t25.isTSTypeLiteral(tsType)) {
+  if (t26.isTSTypeLiteral(tsType)) {
     const members = [];
     for (const member of tsType.members) {
-      if (t25.isTSPropertySignature(member)) {
+      if (t26.isTSPropertySignature(member)) {
         const prop = resolveEmitPropFromPropertySignature(member);
         if (prop) members.push(prop);
         continue;
       }
-      if (t25.isTSCallSignatureDeclaration(member)) {
+      if (t26.isTSCallSignatureDeclaration(member)) {
         members.push(...resolveEmitPropsFromCallSignature(member));
         continue;
       }
     }
     if (!members.length) return null;
-    return t25.tsTypeLiteral(members);
+    return t26.tsTypeLiteral(members);
   }
-  if (t25.isTSFunctionType(tsType)) {
+  if (t26.isTSFunctionType(tsType)) {
     const props = resolveEmitPropsFromCallable(tsType.parameters, tsType.typeAnnotation);
     if (!props.length) return null;
-    return t25.tsTypeLiteral(props);
+    return t26.tsTypeLiteral(props);
   }
   return tsType;
 }
 function hasEmitsSignatureInType(tsType) {
-  if (t25.isTSParenthesizedType(tsType)) {
+  if (t26.isTSParenthesizedType(tsType)) {
     return hasEmitsSignatureInType(tsType.typeAnnotation);
   }
-  if (t25.isTSTypeReference(tsType)) {
+  if (t26.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return false;
     }
     return tsType.typeParameters.params.some(hasEmitsSignatureInType);
   }
-  if (t25.isTSIntersectionType(tsType) || t25.isTSUnionType(tsType)) {
+  if (t26.isTSIntersectionType(tsType) || t26.isTSUnionType(tsType)) {
     return tsType.types.some(hasEmitsSignatureInType);
   }
-  if (t25.isTSTypeLiteral(tsType)) {
+  if (t26.isTSTypeLiteral(tsType)) {
     return tsType.members.some(hasEmitsSignatureInMember);
   }
-  if (t25.isTSFunctionType(tsType)) {
+  if (t26.isTSFunctionType(tsType)) {
     return isEmitsCallable(tsType.parameters);
   }
   return false;
 }
 function hasEmitsSignatureInMember(member) {
-  if (t25.isTSCallSignatureDeclaration(member)) {
+  if (t26.isTSCallSignatureDeclaration(member)) {
     return isEmitsCallable(member.parameters);
   }
   return false;
 }
 function isEmitsCallable(parameters) {
   const [eventParam] = parameters;
-  if (!eventParam || !t25.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
+  if (!eventParam || !t26.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
     return false;
   }
   const { typeAnnotation } = eventParam;
-  if (t25.isNoop(typeAnnotation)) return false;
+  if (t26.isNoop(typeAnnotation)) return false;
   return resolveEventNames(typeAnnotation.typeAnnotation).length > 0;
 }
 function resolveEmitPropFromPropertySignature(member) {
@@ -2556,21 +2813,21 @@ function resolveEmitPropFromPropertySignature(member) {
   if (!rawName) return null;
   const handlerName = resolveEmitHandlerName(rawName);
   const key = buildKey(handlerName);
-  const typeAnnotation = _optionalChain([member, 'access', _74 => _74.typeAnnotation, 'optionalAccess', _75 => _75.typeAnnotation]);
+  const typeAnnotation = _optionalChain([member, 'access', _71 => _71.typeAnnotation, 'optionalAccess', _72 => _72.typeAnnotation]);
   let params = [];
-  let returnType = t25.tsAnyKeyword();
-  if (typeAnnotation && t25.isTSFunctionType(typeAnnotation)) {
+  let returnType = t26.tsAnyKeyword();
+  if (typeAnnotation && t26.isTSFunctionType(typeAnnotation)) {
     params = cloneCallableParams(typeAnnotation.parameters);
-    returnType = _nullishCoalesce(_optionalChain([typeAnnotation, 'access', _76 => _76.typeAnnotation, 'optionalAccess', _77 => _77.typeAnnotation]), () => ( returnType));
-  } else if (typeAnnotation && t25.isTSTupleType(typeAnnotation)) {
+    returnType = _nullishCoalesce(_optionalChain([typeAnnotation, 'access', _73 => _73.typeAnnotation, 'optionalAccess', _74 => _74.typeAnnotation]), () => ( returnType));
+  } else if (typeAnnotation && t26.isTSTupleType(typeAnnotation)) {
     params = resolveTupleTypeParams(typeAnnotation);
   } else if (typeAnnotation) {
-    const id = t25.identifier("value");
-    id.typeAnnotation = t25.tsTypeAnnotation(typeAnnotation);
+    const id = t26.identifier("value");
+    id.typeAnnotation = t26.tsTypeAnnotation(typeAnnotation);
     params = [id];
   }
-  const fnType = t25.tsFunctionType(null, params, t25.tsTypeAnnotation(returnType));
-  const prop = t25.tsPropertySignature(key, t25.tsTypeAnnotation(fnType));
+  const fnType = t26.tsFunctionType(null, params, t26.tsTypeAnnotation(returnType));
+  const prop = t26.tsPropertySignature(key, t26.tsTypeAnnotation(fnType));
   prop.optional = !!member.optional;
   return prop;
 }
@@ -2579,32 +2836,32 @@ function resolveEmitPropsFromCallSignature(member) {
 }
 function resolveEmitPropsFromCallable(parameters, typeAnnotation) {
   const [eventParam, ...restParams] = parameters;
-  if (!eventParam || !t25.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
+  if (!eventParam || !t26.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
     return [];
   }
   const { typeAnnotation: paramTypeAnnotation } = eventParam;
-  if (t25.isNoop(paramTypeAnnotation)) return [];
+  if (t26.isNoop(paramTypeAnnotation)) return [];
   const eventNames = resolveEventNames(paramTypeAnnotation.typeAnnotation);
   if (!eventNames.length) return [];
-  const returnType = _nullishCoalesce(_optionalChain([typeAnnotation, 'optionalAccess', _78 => _78.typeAnnotation]), () => ( t25.tsAnyKeyword()));
+  const returnType = _nullishCoalesce(_optionalChain([typeAnnotation, 'optionalAccess', _75 => _75.typeAnnotation]), () => ( t26.tsAnyKeyword()));
   return eventNames.map((eventName) => {
     const handlerName = resolveEmitHandlerName(eventName);
     const key = buildKey(handlerName);
     const params = cloneCallableParams(restParams);
-    const fnType = t25.tsFunctionType(null, params, t25.tsTypeAnnotation(returnType));
-    const prop = t25.tsPropertySignature(key, t25.tsTypeAnnotation(fnType));
+    const fnType = t26.tsFunctionType(null, params, t26.tsTypeAnnotation(returnType));
+    const prop = t26.tsPropertySignature(key, t26.tsTypeAnnotation(fnType));
     prop.optional = true;
     return prop;
   });
 }
 function resolveEventNames(type) {
-  if (t25.isTSLiteralType(type) && t25.isStringLiteral(type.literal)) {
+  if (t26.isTSLiteralType(type) && t26.isStringLiteral(type.literal)) {
     return [type.literal.value];
   }
-  if (t25.isTSUnionType(type)) {
+  if (t26.isTSUnionType(type)) {
     return type.types.flatMap(resolveEventNames);
   }
-  if (t25.isTSParenthesizedType(type)) {
+  if (t26.isTSParenthesizedType(type)) {
     return resolveEventNames(type.typeAnnotation);
   }
   return [];
@@ -2617,39 +2874,39 @@ function resolveTupleTypeParams(tuple) {
   return params;
 }
 function resolveTupleElementParam(element, index) {
-  const isNamedTuple = typeof t25.isTSNamedTupleMember === "function" && t25.isTSNamedTupleMember(element);
+  const isNamedTuple = typeof t26.isTSNamedTupleMember === "function" && t26.isTSNamedTupleMember(element);
   if (isNamedTuple) {
     const tupleMember = element;
-    const name = _optionalChain([tupleMember, 'access', _79 => _79.label, 'optionalAccess', _80 => _80.name]) || `arg${index}`;
+    const name = _optionalChain([tupleMember, 'access', _76 => _76.label, 'optionalAccess', _77 => _77.name]) || `arg${index}`;
     let innerType = tupleMember.elementType;
     let optional = tupleMember.optional;
-    if (t25.isTSOptionalType(innerType)) {
+    if (t26.isTSOptionalType(innerType)) {
       optional = true;
       innerType = innerType.typeAnnotation;
     }
-    if (t25.isTSRestType(innerType)) {
-      const rest = t25.restElement(t25.identifier(name));
-      rest.typeAnnotation = t25.tsTypeAnnotation(innerType.typeAnnotation);
+    if (t26.isTSRestType(innerType)) {
+      const rest = t26.restElement(t26.identifier(name));
+      rest.typeAnnotation = t26.tsTypeAnnotation(innerType.typeAnnotation);
       return rest;
     }
-    const id2 = t25.identifier(name);
+    const id2 = t26.identifier(name);
     id2.optional = optional;
-    id2.typeAnnotation = t25.tsTypeAnnotation(innerType);
+    id2.typeAnnotation = t26.tsTypeAnnotation(innerType);
     return id2;
   }
-  if (t25.isTSRestType(element)) {
-    const rest = t25.restElement(t25.identifier(`args${index}`));
-    rest.typeAnnotation = t25.tsTypeAnnotation(element.typeAnnotation);
+  if (t26.isTSRestType(element)) {
+    const rest = t26.restElement(t26.identifier(`args${index}`));
+    rest.typeAnnotation = t26.tsTypeAnnotation(element.typeAnnotation);
     return rest;
   }
-  if (t25.isTSOptionalType(element)) {
-    const id2 = t25.identifier(`arg${index}`);
+  if (t26.isTSOptionalType(element)) {
+    const id2 = t26.identifier(`arg${index}`);
     id2.optional = true;
-    id2.typeAnnotation = t25.tsTypeAnnotation(element.typeAnnotation);
+    id2.typeAnnotation = t26.tsTypeAnnotation(element.typeAnnotation);
     return id2;
   }
-  const id = t25.identifier(`arg${index}`);
-  id.typeAnnotation = t25.tsTypeAnnotation(element);
+  const id = t26.identifier(`arg${index}`);
+  id.typeAnnotation = t26.tsTypeAnnotation(element);
   return id;
 }
 
@@ -2658,8 +2915,8 @@ function resolveTupleElementParam(element, index) {
 function resolveDefinePropsIface(path7, ctx) {
   const { node } = path7;
   const [runtimeArg] = node.arguments;
-  const tsParams = _optionalChain([node, 'access', _81 => _81.typeParameters, 'optionalAccess', _82 => _82.params]);
-  if (_optionalChain([tsParams, 'optionalAccess', _83 => _83.length])) {
+  const tsParams = _optionalChain([node, 'access', _78 => _78.typeParameters, 'optionalAccess', _79 => _79.params]);
+  if (_optionalChain([tsParams, 'optionalAccess', _80 => _80.length])) {
     const { propsTSIface } = ctx.scriptData;
     propsTSIface.propsTypes = tsParams;
     return;
@@ -2674,38 +2931,38 @@ function processInferredTypes2(ctx, runtimeArg) {
   } = scriptData;
   if (!runtimeArg) return;
   const members = [];
-  if (t26.isArrayExpression(runtimeArg)) {
+  if (t27.isArrayExpression(runtimeArg)) {
     for (const element of runtimeArg.elements) {
-      if (!element || !t26.isStringLiteral(element)) continue;
-      const key = t26.isValidIdentifier(element.value) ? t26.identifier(element.value) : t26.stringLiteral(element.value);
-      const prop = t26.tsPropertySignature(key, t26.tsTypeAnnotation(t26.tsAnyKeyword()));
+      if (!element || !t27.isStringLiteral(element)) continue;
+      const key = t27.isValidIdentifier(element.value) ? t27.identifier(element.value) : t27.stringLiteral(element.value);
+      const prop = t27.tsPropertySignature(key, t27.tsTypeAnnotation(t27.tsAnyKeyword()));
       prop.optional = true;
       members.push(prop);
     }
     if (members.length) {
-      propsTypes.push(t26.tsTypeLiteral(members));
+      propsTypes.push(t27.tsTypeLiteral(members));
     }
     return;
   }
-  if (t26.isObjectExpression(runtimeArg)) {
+  if (t27.isObjectExpression(runtimeArg)) {
     for (const prop of runtimeArg.properties) {
-      if (!t26.isObjectProperty(prop)) continue;
-      if (t26.isSpreadElement(prop)) continue;
+      if (!t27.isObjectProperty(prop)) continue;
+      if (t27.isSpreadElement(prop)) continue;
       const key = prop.key;
       let propName = null;
-      if (t26.isIdentifier(key)) propName = key.name;
-      if (t26.isStringLiteral(key)) propName = key.value;
-      if (t26.isNumericLiteral(key)) propName = String(key.value);
+      if (t27.isIdentifier(key)) propName = key.name;
+      if (t27.isStringLiteral(key)) propName = key.value;
+      if (t27.isNumericLiteral(key)) propName = String(key.value);
       if (!propName) continue;
       const { type, required } = resolveRuntimePropMeta(prop.value);
-      const tsType = _nullishCoalesce(type, () => ( t26.tsAnyKeyword()));
-      const tsKey = t26.isValidIdentifier(propName) ? t26.identifier(propName) : t26.stringLiteral(propName);
-      const tsProp = t26.tsPropertySignature(tsKey, t26.tsTypeAnnotation(tsType));
+      const tsType = _nullishCoalesce(type, () => ( t27.tsAnyKeyword()));
+      const tsKey = t27.isValidIdentifier(propName) ? t27.identifier(propName) : t27.stringLiteral(propName);
+      const tsProp = t27.tsPropertySignature(tsKey, t27.tsTypeAnnotation(tsType));
       tsProp.optional = !required;
       members.push(tsProp);
     }
     if (members.length) {
-      propsTypes.push(t26.tsTypeLiteral(members));
+      propsTypes.push(t27.tsTypeLiteral(members));
     }
     return;
   }
@@ -2714,47 +2971,47 @@ function processInferredTypes2(ctx, runtimeArg) {
     {
       source,
       file: filename,
-      loc: _optionalChain([runtimeArg, 'optionalAccess', _84 => _84.loc])
+      loc: _optionalChain([runtimeArg, 'optionalAccess', _81 => _81.loc])
     }
   );
 }
 function resolveRuntimePropMeta(value) {
-  if (t26.isIdentifier(value)) {
+  if (t27.isIdentifier(value)) {
     return {
       type: mapRuntimeTypeToTSType(value),
       required: false
     };
   }
-  if (t26.isArrayExpression(value)) {
+  if (t27.isArrayExpression(value)) {
     return {
       type: resolveRuntimeUnionType(value),
       required: false
     };
   }
-  if (!t26.isObjectExpression(value)) {
+  if (!t27.isObjectExpression(value)) {
     return { required: false };
   }
   let type;
   let required = false;
   for (const prop of value.properties) {
-    if (!t26.isObjectProperty(prop)) continue;
-    if (t26.isSpreadElement(prop)) continue;
+    if (!t27.isObjectProperty(prop)) continue;
+    if (t27.isSpreadElement(prop)) continue;
     const key = prop.key;
-    const propName = t26.isIdentifier(key) ? key.name : t26.isStringLiteral(key) ? key.value : null;
+    const propName = t27.isIdentifier(key) ? key.name : t27.isStringLiteral(key) ? key.value : null;
     if (!propName) continue;
     if (propName === "type") {
       const valueNode = prop.value;
-      if (t26.isArrayExpression(valueNode)) {
+      if (t27.isArrayExpression(valueNode)) {
         type = resolveRuntimeUnionType(valueNode);
         continue;
       }
-      if (t26.isIdentifier(valueNode)) {
+      if (t27.isIdentifier(valueNode)) {
         type = mapRuntimeTypeToTSType(valueNode);
         continue;
       }
     }
     if (propName === "required") {
-      if (t26.isBooleanLiteral(prop.value)) {
+      if (t27.isBooleanLiteral(prop.value)) {
         required = prop.value.value;
       }
     }
@@ -2764,34 +3021,34 @@ function resolveRuntimePropMeta(value) {
 function resolveRuntimeUnionType(value) {
   const types = [];
   for (const element of value.elements) {
-    if (!element || !t26.isIdentifier(element)) continue;
+    if (!element || !t27.isIdentifier(element)) continue;
     const resolved = mapRuntimeTypeToTSType(element);
     if (resolved) types.push(resolved);
   }
-  if (!types.length) return t26.tsAnyKeyword();
+  if (!types.length) return t27.tsAnyKeyword();
   if (types.length === 1) return types[0];
-  return t26.tsUnionType(types);
+  return t27.tsUnionType(types);
 }
 function mapRuntimeTypeToTSType(value) {
   switch (value.name) {
     case "String":
-      return t26.tsStringKeyword();
+      return t27.tsStringKeyword();
     case "Number":
-      return t26.tsNumberKeyword();
+      return t27.tsNumberKeyword();
     case "Boolean":
-      return t26.tsBooleanKeyword();
+      return t27.tsBooleanKeyword();
     case "Object":
-      return t26.tsTypeLiteral([]);
+      return t27.tsTypeLiteral([]);
     case "Array":
-      return t26.tsArrayType(t26.tsAnyKeyword());
+      return t27.tsArrayType(t27.tsAnyKeyword());
     case "Function":
-      return t26.tsFunctionType(null, [], t26.tsTypeAnnotation(t26.tsAnyKeyword()));
+      return t27.tsFunctionType(null, [], t27.tsTypeAnnotation(t27.tsAnyKeyword()));
     case "Symbol":
-      return t26.tsSymbolKeyword();
+      return t27.tsSymbolKeyword();
     case "BigInt":
-      return t26.tsBigIntKeyword();
+      return t27.tsBigIntKeyword();
     default:
-      return t26.tsAnyKeyword();
+      return t27.tsAnyKeyword();
   }
 }
 
@@ -2803,19 +3060,19 @@ var SLOT_FN_PARAM_NAME = "props";
 function resolveSlotsTopLevelTypes(ctx) {
   return {
     "TSInterfaceDeclaration|TSTypeAliasDeclaration"(path7) {
-      if (!t27.isProgram(path7.parent)) return;
+      if (!t28.isProgram(path7.parent)) return;
       const { node } = path7;
-      if (t27.isTSInterfaceDeclaration(node)) {
-        const typeLiteral = t27.tsTypeLiteral(node.body.body);
+      if (t28.isTSInterfaceDeclaration(node)) {
+        const typeLiteral = t28.tsTypeLiteral(node.body.body);
         if (!hasSlotsSignatureInType(typeLiteral)) return;
         const resolved = resolveSlotType(typeLiteral);
-        if (resolved && t27.isTSTypeLiteral(resolved)) {
+        if (resolved && t28.isTSTypeLiteral(resolved)) {
           node.body.body = resolved.members;
           recordReactNode(ctx);
         }
         return;
       }
-      if (t27.isTSTypeAliasDeclaration(node)) {
+      if (t28.isTSTypeAliasDeclaration(node)) {
         if (!hasSlotsSignatureInType(node.typeAnnotation)) return;
         const resolved = resolveSlotType(node.typeAnnotation);
         if (resolved) {
@@ -2828,8 +3085,8 @@ function resolveSlotsTopLevelTypes(ctx) {
 }
 function resolveDefineSlotsIface(path7, ctx) {
   const { node } = path7;
-  const tsParams = _optionalChain([node, 'access', _85 => _85.typeParameters, 'optionalAccess', _86 => _86.params]);
-  if (!_optionalChain([tsParams, 'optionalAccess', _87 => _87.length])) return;
+  const tsParams = _optionalChain([node, 'access', _82 => _82.typeParameters, 'optionalAccess', _83 => _83.params]);
+  if (!_optionalChain([tsParams, 'optionalAccess', _84 => _84.length])) return;
   const {
     propsTSIface: { slotTypes }
   } = ctx.scriptData;
@@ -2860,7 +3117,7 @@ function resolveTemplateSlotIface(ctx) {
   }
   if (tsMembers.length) {
     recordReactNode(ctx);
-    slotTypes.push(t27.tsTypeLiteral(tsMembers));
+    slotTypes.push(t28.tsTypeLiteral(tsMembers));
   }
 }
 function recordReactNode(ctx) {
@@ -2870,32 +3127,32 @@ function recordReactNode(ctx) {
   recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.ReactNode);
 }
 function resolveSlotType(tsType) {
-  if (t27.isTSParenthesizedType(tsType)) {
+  if (t28.isTSParenthesizedType(tsType)) {
     return resolveSlotType(tsType.typeAnnotation);
   }
-  if (t27.isTSTypeReference(tsType)) {
+  if (t28.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return tsType;
     }
     const params = tsType.typeParameters.params.map((param) => resolveSlotType(param)).filter(Boolean);
-    return t27.tsTypeReference(
+    return t28.tsTypeReference(
       tsType.typeName,
-      t27.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
+      t28.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
     );
   }
-  if (t27.isTSIntersectionType(tsType)) {
+  if (t28.isTSIntersectionType(tsType)) {
     const types = tsType.types.map(resolveSlotType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t27.tsIntersectionType(types);
+    return t28.tsIntersectionType(types);
   }
-  if (t27.isTSUnionType(tsType)) {
+  if (t28.isTSUnionType(tsType)) {
     const types = tsType.types.map(resolveSlotType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t27.tsUnionType(types);
+    return t28.tsUnionType(types);
   }
-  if (t27.isTSTypeLiteral(tsType)) {
+  if (t28.isTSTypeLiteral(tsType)) {
     const members = [];
     for (const member of tsType.members) {
       const resolved = resolveSlotPropFromMember(member);
@@ -2906,110 +3163,110 @@ function resolveSlotType(tsType) {
       members.push(member);
     }
     if (!members.length) return null;
-    return t27.tsTypeLiteral(members);
+    return t28.tsTypeLiteral(members);
   }
-  if (t27.isTSFunctionType(tsType)) {
+  if (t28.isTSFunctionType(tsType)) {
     const props = buildSlotPropSignature(
       SLOT_DEFAULT_NAME,
       cloneCallableParams(tsType.parameters),
       false
     );
-    return t27.tsTypeLiteral([props]);
+    return t28.tsTypeLiteral([props]);
   }
   return tsType;
 }
 function hasSlotsSignatureInType(tsType) {
-  if (t27.isTSParenthesizedType(tsType)) {
+  if (t28.isTSParenthesizedType(tsType)) {
     return hasSlotsSignatureInType(tsType.typeAnnotation);
   }
-  if (t27.isTSTypeReference(tsType)) {
+  if (t28.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return false;
     }
     return tsType.typeParameters.params.some(hasSlotsSignatureInType);
   }
-  if (t27.isTSIntersectionType(tsType) || t27.isTSUnionType(tsType)) {
+  if (t28.isTSIntersectionType(tsType) || t28.isTSUnionType(tsType)) {
     return tsType.types.some(hasSlotsSignatureInType);
   }
-  if (t27.isTSTypeLiteral(tsType)) {
+  if (t28.isTSTypeLiteral(tsType)) {
     return tsType.members.some(hasSlotsSignatureInMember);
   }
-  if (t27.isTSFunctionType(tsType)) {
+  if (t28.isTSFunctionType(tsType)) {
     return true;
   }
   return false;
 }
 function hasSlotsSignatureInMember(member) {
-  if (t27.isTSMethodSignature(member)) return true;
-  if (t27.isTSCallSignatureDeclaration(member)) return true;
-  if (t27.isTSPropertySignature(member)) {
-    const typeAnnotation = _optionalChain([member, 'access', _88 => _88.typeAnnotation, 'optionalAccess', _89 => _89.typeAnnotation]);
+  if (t28.isTSMethodSignature(member)) return true;
+  if (t28.isTSCallSignatureDeclaration(member)) return true;
+  if (t28.isTSPropertySignature(member)) {
+    const typeAnnotation = _optionalChain([member, 'access', _85 => _85.typeAnnotation, 'optionalAccess', _86 => _86.typeAnnotation]);
     return !!(typeAnnotation && resolveCallableType(typeAnnotation));
   }
   return false;
 }
 function resolveSlotPropFromMember(member) {
-  if (t27.isTSMethodSignature(member)) {
+  if (t28.isTSMethodSignature(member)) {
     const rawName = resolvePropName2(member.key);
     if (!rawName) return null;
     const params = cloneCallableParams(member.parameters);
     return buildSlotPropSignature(rawName, params, !!member.optional);
   }
-  if (t27.isTSPropertySignature(member)) {
+  if (t28.isTSPropertySignature(member)) {
     const rawName = resolvePropName2(member.key);
     if (!rawName) return null;
-    const typeAnnotation = _optionalChain([member, 'access', _90 => _90.typeAnnotation, 'optionalAccess', _91 => _91.typeAnnotation]);
+    const typeAnnotation = _optionalChain([member, 'access', _87 => _87.typeAnnotation, 'optionalAccess', _88 => _88.typeAnnotation]);
     const callable = typeAnnotation ? resolveCallableType(typeAnnotation) : null;
     if (!callable) return null;
     const params = cloneCallableParams(callable.parameters);
     return buildSlotPropSignature(rawName, params, !!member.optional);
   }
-  if (t27.isTSCallSignatureDeclaration(member)) {
+  if (t28.isTSCallSignatureDeclaration(member)) {
     const params = cloneCallableParams(member.parameters);
     return buildSlotPropSignature(SLOT_DEFAULT_NAME, params, true);
   }
   return null;
 }
 function resolveCallableType(tsType) {
-  if (t27.isTSFunctionType(tsType)) return tsType;
-  if (t27.isTSParenthesizedType(tsType)) return resolveCallableType(tsType.typeAnnotation);
+  if (t28.isTSFunctionType(tsType)) return tsType;
+  if (t28.isTSParenthesizedType(tsType)) return resolveCallableType(tsType.typeAnnotation);
   return null;
 }
 function buildSlotPropSignature(rawName, params, optional) {
   const propName = rawName === SLOT_DEFAULT_NAME ? SLOT_CHILDREN_NAME : rawName;
-  const key = t27.isValidIdentifier(propName) ? t27.identifier(propName) : t27.stringLiteral(propName);
-  const reactNodeType = t27.tsTypeAnnotation(
-    t27.tsTypeReference(t27.identifier(REACT_API_MAP.ReactNode))
+  const key = t28.isValidIdentifier(propName) ? t28.identifier(propName) : t28.stringLiteral(propName);
+  const reactNodeType = t28.tsTypeAnnotation(
+    t28.tsTypeReference(t28.identifier(REACT_API_MAP.ReactNode))
   );
   let typeAnnotation;
   if (rawName === SLOT_DEFAULT_NAME && params.length === 0 || params.length === 0) {
     typeAnnotation = reactNodeType;
   } else {
-    const fnType = t27.tsFunctionType(null, params, reactNodeType);
-    typeAnnotation = t27.tsTypeAnnotation(fnType);
+    const fnType = t28.tsFunctionType(null, params, reactNodeType);
+    typeAnnotation = t28.tsTypeAnnotation(fnType);
   }
-  const prop = t27.tsPropertySignature(key, typeAnnotation);
+  const prop = t28.tsPropertySignature(key, typeAnnotation);
   prop.optional = optional;
   return prop;
 }
 function createSlotScopeParam(props, ctx) {
-  const paramId = t27.identifier(SLOT_FN_PARAM_NAME);
+  const paramId = t28.identifier(SLOT_FN_PARAM_NAME);
   const propsSigns = [];
   const { reactiveBindings } = ctx.templateData;
   props.forEach(({ prop, tsType }) => {
-    const foundBindingValue = _optionalChain([reactiveBindings, 'access', _92 => _92[prop], 'optionalAccess', _93 => _93.value]);
+    const foundBindingValue = _optionalChain([reactiveBindings, 'access', _89 => _89[prop], 'optionalAccess', _90 => _90.value]);
     const foundBindingTypes = foundBindingValue ? expressionToTSType(foundBindingValue) : null;
-    const typeAnnotation = foundBindingTypes ? t27.tsTypeAnnotation(foundBindingTypes) : tsType;
-    const propSign = t27.tsPropertySignature(t27.identifier(prop), typeAnnotation);
+    const typeAnnotation = foundBindingTypes ? t28.tsTypeAnnotation(foundBindingTypes) : tsType;
+    const propSign = t28.tsPropertySignature(t28.identifier(prop), typeAnnotation);
     propsSigns.push(propSign);
   });
-  paramId.typeAnnotation = t27.tsTypeAnnotation(t27.tsTypeLiteral(propsSigns));
+  paramId.typeAnnotation = t28.tsTypeAnnotation(t28.tsTypeLiteral(propsSigns));
   return paramId;
 }
 function resolvePropName2(key) {
-  if (t27.isIdentifier(key)) return key.name;
-  if (t27.isStringLiteral(key)) return key.value;
-  if (t27.isNumericLiteral(key)) return String(key.value);
+  if (t28.isIdentifier(key)) return key.name;
+  if (t28.isStringLiteral(key)) return key.value;
+  if (t28.isNumericLiteral(key)) return String(key.value);
   return null;
 }
 
@@ -3061,65 +3318,17 @@ function resolveCompIProps(ctx, ast) {
   }
   const n = ctx.compName || "Comp";
   const ns = `I${camelCase(capitalize(n))}Props`;
-  const typeNode = t28.tsIntersectionType(tsTypes);
-  const typeAliasDecl = t28.tsTypeAliasDeclaration(t28.identifier(ns), null, typeNode);
-  const exportDecl = t28.exportNamedDeclaration(typeAliasDecl);
+  const typeNode = t29.tsIntersectionType(tsTypes);
+  const typeAliasDecl = t29.tsTypeAliasDeclaration(t29.identifier(ns), null, typeNode);
+  const exportDecl = t29.exportNamedDeclaration(typeAliasDecl);
   propsTSIface.name = ns;
   const scriptIR = getScriptIR(ctx);
   scriptIR.exports.push(exportDecl);
   void ast;
 }
 
-// src/core/transform/sfc/script/syntax-processor/process/lint-rules.ts
+// src/core/transform/sfc/script/syntax-processor/process/resolve-analysis-only-adapter.ts
 
-function lintRules(ctx, ast) {
-  const inScriptFile = ctx.inputType !== "sfc";
-  return {
-    CallExpression(path7) {
-      const { node, parentPath } = path7;
-      if (!t29.isIdentifier(node.callee)) return;
-      const { name: callName } = node.callee;
-      const addLog = (t40) => {
-        logger.error(t40, {
-          file: ctx.filename,
-          source: ctx.scriptData.source,
-          loc: node.loc
-        });
-      };
-      const lintMacros = () => {
-        const macro = Object.values(MACRO_API_NAMES).find((v) => v === callName);
-        if (!macro) return;
-        if (inScriptFile) {
-          addLog(
-            `The ${macro} can only be used inside Vue SFC <script> blocks, not in separate script files.`
-          );
-          return;
-        }
-        if (!atComponentOrHookRoot(path7, ast.program)) {
-          addLog(
-            `The ${macro} must be defined at the top level of the component, not inside blocks or functions.`
-          );
-          return;
-        }
-        if (!parentPath.isVariableDeclarator()) {
-          addLog(
-            `The ${macro} macro must be assigned to a variable (e.g., const props = defineProps(...)).`
-          );
-        }
-      };
-      const lintHooks = () => {
-        if (!callName.startsWith("use")) return;
-        if (!atComponentOrHookRoot(path7, ast.program, inScriptFile)) {
-          addLog(
-            `The ${callName} hook must be called at the top level, not inside loops, conditions, or nested functions.`
-          );
-        }
-      };
-      lintMacros();
-      lintHooks();
-    }
-  };
-}
 
 // src/core/transform/sfc/script/shared/dependency-analyzer.ts
 
@@ -3245,7 +3454,7 @@ function analyzeDeps(node, ctx, parentPath) {
     const declaratorPath = getVariableDeclaratorPath(bindingPath);
     const isImportBinding = bindingPath.isImportSpecifier() || bindingPath.isImportDefaultSpecifier() || bindingPath.isImportNamespaceSpecifier();
     const isReactiveVarBinding = !!declaratorPath && isReactiveBinding(declaratorPath.node);
-    const nodeInit = _optionalChain([declaratorPath, 'optionalAccess', _94 => _94.node, 'access', _95 => _95.init]);
+    const nodeInit = _optionalChain([declaratorPath, 'optionalAccess', _91 => _91.node, 'access', _92 => _92.init]);
     const isReactiveApiCallVarBinding = !!declaratorPath && t30.isCallExpression(nodeInit) && t30.isIdentifier(nodeInit.callee) && reactiveStateApis.has(nodeInit.callee.name);
     const isHookCallVarBinding = !!declaratorPath && t30.isCallExpression(nodeInit) && isHookLikeCallee(nodeInit.callee);
     const isFunctionBinding = bindingPath.isFunctionDeclaration() || !!declaratorPath && !!nodeInit && (t30.isArrowFunctionExpression(nodeInit) || t30.isFunctionExpression(nodeInit));
@@ -3358,7 +3567,7 @@ function isNestedMemberObject(path7) {
 }
 function isReactiveBinding(node) {
   if (!node) return false;
-  return !!_optionalChain([getScriptNodeMeta, 'call', _96 => _96(node), 'optionalAccess', _97 => _97.is_reactive]);
+  return !!_optionalChain([getScriptNodeMeta, 'call', _93 => _93(node), 'optionalAccess', _94 => _94.is_reactive]);
 }
 function markAsAnalyzed(node, flag = true) {
   const analyzed = getIsAnalyzed(node);
@@ -3366,22 +3575,51 @@ function markAsAnalyzed(node, flag = true) {
   setScriptNodeMeta(node, { is_deps_analyzed: flag });
 }
 function getIsAnalyzed(node) {
-  return _optionalChain([getScriptNodeMeta, 'call', _98 => _98(node), 'optionalAccess', _99 => _99.is_deps_analyzed]);
+  return _optionalChain([getScriptNodeMeta, 'call', _95 => _95(node), 'optionalAccess', _96 => _96.is_deps_analyzed]);
 }
 
-// src/core/transform/sfc/script/shared/hook-creator.ts
-
-function createUseCallback(body, deps) {
-  return t31.callExpression(t31.identifier(REACT_API_MAP.useCallback), [
-    body,
-    _nullishCoalesce(deps, () => ( t31.arrayExpression([])))
-  ]);
+// src/core/transform/sfc/script/syntax-processor/process/resolve-analysis-only-adapter.ts
+function resolveAnalysisOnlyAdapter(ctx) {
+  return {
+    "CallExpression|Identifier"(path7) {
+      const node = path7.node;
+      const apiName = getApiName(node);
+      const adapter = ADAPTER_RULES.runtime[apiName];
+      if (!adapter || adapter.type !== "analyzed-deps") {
+        return;
+      }
+      if (t31.isCallExpression(node)) {
+        resolveCallNode(path7, adapter, ctx);
+      } else {
+        replaceIdName(node, adapter.target);
+      }
+      recordImport(ctx, adapter.package, adapter.target);
+    }
+  };
 }
-function createUseMemo(body, deps) {
-  return t31.callExpression(t31.identifier(REACT_API_MAP.useMemo), [
-    t31.arrowFunctionExpression([], body),
-    _nullishCoalesce(deps, () => ( t31.arrayExpression([])))
-  ]);
+function getApiName(node) {
+  const isCallNode = t31.isCallExpression(node);
+  let apiName = "";
+  if (t31.isIdentifier(node)) {
+    apiName = node.name;
+  } else if (isCallNode && t31.isIdentifier(node.callee)) {
+    apiName = node.callee.name;
+  }
+  return apiName;
+}
+function resolveCallNode(path7, adapter, ctx) {
+  const { node } = path7;
+  const { arguments: args } = node;
+  if (!args.length) return;
+  const fn = args[0];
+  if (!t31.isArrowFunctionExpression(fn) && !t31.isFunctionExpression(fn)) {
+    return;
+  }
+  const fnPath = path7.get("arguments")[0];
+  const deps = analyzeDeps(fn, ctx, fnPath);
+  args.push(deps);
+  replaceCallName(node, adapter.target);
+  recordImport(ctx, adapter.package, adapter.target);
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-arrow-deps.ts
@@ -3398,7 +3636,7 @@ function resolveArrowFnDeps(ctx, ast) {
       const declaratorPath = getVariableDeclaratorPath(path7);
       markAsAnalyzed(newNode.arguments[0]);
       recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.useCallback);
-      setScriptNodeMeta(_optionalChain([declaratorPath, 'optionalAccess', _100 => _100.node]), { is_reactive: true, reactive_type: "indirect" });
+      setScriptNodeMeta(_optionalChain([declaratorPath, 'optionalAccess', _97 => _97.node]), { is_reactive: true, reactive_type: "indirect" });
       path7.replaceWith(newNode);
     }
   };
@@ -3411,7 +3649,7 @@ function resolveUnanalyzedArrow(ctx) {
       if (typeof analyzed === "undefined" || analyzed) return;
       const newNode = createUseCallback(node);
       const declaratorPath = getVariableDeclaratorPath(path7);
-      if (_optionalChain([declaratorPath, 'optionalAccess', _101 => _101.node])) {
+      if (_optionalChain([declaratorPath, 'optionalAccess', _98 => _98.node])) {
         setScriptNodeMeta(declaratorPath.node, { is_reactive: true, reactive_type: "indirect" });
       }
       markAsAnalyzed(newNode.arguments[0]);
@@ -3455,6 +3693,76 @@ function isSkip(path7) {
   return (isCallback() || isMethod() || !isVariableDecl()) && !isReturnFunc();
 }
 
+// src/core/transform/sfc/script/syntax-processor/process/resolve-element-ref.ts
+
+function resolveElementRef(ctx) {
+  return {
+    CallExpression(path7) {
+      const {
+        inputType,
+        templateData: { refBindings }
+      } = ctx;
+      if (inputType !== "sfc") return;
+      const { node } = path7;
+      const isUseTemplateRef = isCalleeNamed(node, VUE_API_MAP.useTemplateRef);
+      const isCompRefBindings = Object.keys(refBindings.componentRefs).length > 0 && isCalleeNamed(node, VUE_API_MAP.ref);
+      const shouldProcess = isUseTemplateRef || isCompRefBindings;
+      if (!shouldProcess) {
+        return;
+      }
+      if (isCompRefBindings) {
+        const varDeclaratorPath = _optionalChain([getVariableDeclaratorPath, 'call', _99 => _99(path7), 'optionalAccess', _100 => _100.node]);
+        if (!t32.isIdentifier(_optionalChain([varDeclaratorPath, 'optionalAccess', _101 => _101.id]))) {
+          return;
+        }
+        const varName = varDeclaratorPath.id.name;
+        const compRef = refBindings.componentRefs[varName];
+        if (!compRef) return;
+      }
+      node.arguments[0] = t32.identifier("null");
+      resolveTypeParameters(ctx, path7);
+      replaceCallName(node, REACT_API_MAP.useRef);
+      recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.useRef);
+    },
+    MemberExpression(path7) {
+      resolveRefValueToCurrent(path7);
+    }
+  };
+}
+function resolveTypeParameters(ctx, path7) {
+  const {
+    templateData: { refBindings },
+    scriptData
+  } = ctx;
+  const { node } = path7;
+  const varDeclaratorNode = _optionalChain([getVariableDeclaratorPath, 'call', _102 => _102(path7), 'optionalAccess', _103 => _103.node]);
+  if (!scriptData.lang.startsWith("ts") || !varDeclaratorNode) {
+    return;
+  }
+  const idName = varDeclaratorNode.id.name;
+  const domBindingMeta = refBindings.domRefs[idName];
+  const compBindingMeta = refBindings.componentRefs[idName];
+  if (!node.typeParameters && (domBindingMeta || compBindingMeta)) {
+    const type = compBindingMeta ? "any" : domBindingMeta.htmlType;
+    node.typeParameters = t32.tsTypeParameterInstantiation([t32.tsTypeReference(t32.identifier(type))]);
+  }
+}
+function resolveRefValueToCurrent(path7) {
+  const { node } = path7;
+  if (node.computed || !t32.isIdentifier(node.property) || node.property.name !== "value") {
+    return;
+  }
+  const rootPath = findRootVariablePath(path7);
+  if (!_optionalChain([rootPath, 'optionalAccess', _104 => _104.node]) || !t32.isCallExpression(rootPath.node.init) || !isCalleeNamed(rootPath.node.init, REACT_API_MAP.useRef)) {
+    return;
+  }
+  const rootId = findRootIdentifier(node);
+  if (!t32.isIdentifier(node.object) || node.object.name !== _optionalChain([rootId, 'optionalAccess', _105 => _105.name])) {
+    return;
+  }
+  node.property.name = "current";
+}
+
 // src/core/transform/sfc/script/syntax-processor/process/resolve-expression-memo.ts
 
 function resolveExprMemo(ctx, ast) {
@@ -3468,7 +3776,7 @@ function resolveExprMemo(ctx, ast) {
         if (!atComponentOrHookRoot(path7, ast.program, isScriptFile)) {
           return false;
         }
-        if (t32.isCallExpression(init) && t32.isIdentifier(init.callee) && init.callee.name.startsWith("use")) {
+        if (t33.isCallExpression(init) && t33.isIdentifier(init.callee) && init.callee.name.startsWith("use")) {
           return false;
         }
         return true;
@@ -3485,6 +3793,59 @@ function resolveExprMemo(ctx, ast) {
   };
 }
 
+// src/core/transform/sfc/script/syntax-processor/process/resolve-lint-rules.ts
+
+function resolveLintRules(ctx, ast) {
+  const inScriptFile = ctx.inputType !== "sfc";
+  return {
+    CallExpression(path7) {
+      const { node, parentPath } = path7;
+      if (!t34.isIdentifier(node.callee)) return;
+      const { name: callName } = node.callee;
+      const addLog = (t41) => {
+        logger.error(t41, {
+          file: ctx.filename,
+          source: ctx.scriptData.source,
+          loc: node.loc
+        });
+      };
+      const lintMacros = () => {
+        const macro = Object.values(MACRO_API_NAMES).find((v) => v === callName);
+        if (!macro) return;
+        if (inScriptFile) {
+          addLog(
+            `The ${macro} can only be used inside Vue SFC <script> blocks, not in separate script files.`
+          );
+          return;
+        }
+        if (!atComponentOrHookRoot(path7, ast.program)) {
+          addLog(
+            `The ${macro} must be defined at the top level of the component, not inside blocks or functions.`
+          );
+          return;
+        }
+        if (!parentPath.isVariableDeclarator()) {
+          if (macro === MACRO_API_NAMES.props || macro === MACRO_API_NAMES.emits) {
+            addLog(
+              `The ${macro} macro must be assigned to a variable (e.g., const props = defineProps(...)).`
+            );
+          }
+        }
+      };
+      const lintHooks = () => {
+        if (!callName.startsWith("use")) return;
+        if (!atComponentOrHookRoot(path7, ast.program, inScriptFile)) {
+          addLog(
+            `The ${callName} hook must be called at the top level, not inside loops, conditions, or nested functions.`
+          );
+        }
+      };
+      lintMacros();
+      lintHooks();
+    }
+  };
+}
+
 // src/core/transform/sfc/script/syntax-processor/process/resolve-provide.ts
 
 
@@ -3493,12 +3854,13 @@ function resolveProvide(ctx) {
   return {
     CallExpression(path7) {
       const { node } = path7;
-      if (!isCalleeNamed(node, "provide")) return;
+      if (!isCalleeNamed(node, VUE_API_MAP.provide)) return;
       const { provide } = ctx.scriptData;
       const [key, value] = node.arguments;
       const target = findOrCreateCtxProvider(provide);
+      const adapter = ADAPTER_RULES.runtime[VUE_API_MAP.provide];
       assignProviderValue(target, key, value);
-      recordImport(ctx, PACKAGE_NAME.runtime, ADAPTER_COMPS.Provider);
+      recordImport(ctx, adapter.package, adapter.target);
       path7.parentPath.remove();
     }
   };
@@ -3508,7 +3870,7 @@ function findOrCreateCtxProvider(root) {
     return root;
   }
   let cur = root.provide;
-  while (_optionalChain([cur, 'optionalAccess', _102 => _102.isOccupied])) {
+  while (_optionalChain([cur, 'optionalAccess', _106 => _106.isOccupied])) {
     cur = _nullishCoalesce(cur.provide, () => ( {}));
   }
   return cur || (root.provide = {});
@@ -3516,13 +3878,13 @@ function findOrCreateCtxProvider(root) {
 function assignProviderValue(target, key, value) {
   const getRawExp = (exp) => {
     if (!exp) return "''";
-    if (t33.isStringLiteral(exp)) {
+    if (t35.isStringLiteral(exp)) {
       return `'${exp.value}'`;
     }
-    if (t33.isNumericLiteral(exp)) {
+    if (t35.isNumericLiteral(exp)) {
       return exp.value.toString();
     }
-    if (t33.isIdentifier(exp)) {
+    if (t35.isIdentifier(exp)) {
       return exp.name;
     }
     try {
@@ -3537,165 +3899,70 @@ function assignProviderValue(target, key, value) {
   target.provide = {};
 }
 
-// src/core/transform/sfc/script/syntax-processor/process/resolve-rename-only-adapter.ts
-
-function resolveRenameOnlyAdapter(ctx) {
-  return {
-    "Identifier|CallExpression"(path7) {
-      resolveAdapterRules(PACKAGE_NAME.runtime, ADAPTER_HOOKS, path7, ctx);
-      resolveAdapterRules(PACKAGE_NAME.router, ADAPTER_ROUTER_APIS, path7, ctx);
-    }
-  };
-}
-function resolveAdapterRules(pkgName, rules, path7, ctx) {
-  const node = path7.node;
-  const isCallExpr = t34.isCallExpression(node);
-  let sourceName = "";
-  if (t34.isIdentifier(node)) {
-    sourceName = node.name;
-  } else if (isCallExpr && t34.isIdentifier(node.callee)) {
-    sourceName = node.callee.name;
-  }
-  const { pure, effectful } = rules.renameOnly;
-  const pureApi = pure[sourceName];
-  const effectfulApi = effectful[sourceName];
-  const adapter = pureApi || effectfulApi;
-  if (!adapter) return;
-  if (effectfulApi) {
-    const reactiveType = getReactiveType(sourceName);
-    const declaratorPath = getVariableDeclaratorPath(path7);
-    setScriptNodeMeta(_optionalChain([declaratorPath, 'optionalAccess', _103 => _103.node]), {
-      is_reactive: true,
-      reactive_type: reactiveType
-    });
-  }
-  if (isCallExpr) {
-    replaceCallName(node, adapter);
-  } else {
-    replaceIdName(node, adapter);
-  }
-  recordImport(ctx, pkgName, adapter);
-  if (pkgName === PACKAGE_NAME.router && !ctx.route) {
-    ctx.route = true;
-  }
-}
-
-// src/core/transform/sfc/script/syntax-processor/process/resolve-transform-adapter.ts
+// src/core/transform/sfc/script/syntax-processor/process/resolve-rename-adapter.ts
 
-function resolveTransformAdapter(ctx) {
+function resolveRenameAdapter(ctx) {
   return {
-    "Identifier|CallExpression"(path7) {
-      resolveTransformAdapterRules(PACKAGE_NAME.runtime, ADAPTER_HOOKS, path7, ctx);
-      resolveTransformAdapterRules(PACKAGE_NAME.router, ADAPTER_ROUTER_APIS, path7, ctx);
+    "CallExpression|Identifier"(path7) {
+      const node = path7.node;
+      const isCallNode = t36.isCallExpression(node);
+      let apiName = "";
+      if (t36.isIdentifier(node)) {
+        apiName = node.name;
+      } else if (isCallNode && t36.isIdentifier(node.callee)) {
+        apiName = node.callee.name;
+      }
+      const runtimeAdapter = ADAPTER_RULES.runtime[apiName];
+      const routerAdapter = ADAPTER_RULES.router[apiName];
+      const adapter = runtimeAdapter || routerAdapter;
+      if (!adapter || adapter.type !== "rename") {
+        return;
+      }
+      if (adapter.isTrackable) {
+        const reactiveType = getReactiveType(apiName);
+        const declaratorPath = getVariableDeclaratorPath(path7);
+        setScriptNodeMeta(_optionalChain([declaratorPath, 'optionalAccess', _107 => _107.node]), {
+          is_reactive: true,
+          reactive_type: reactiveType
+        });
+      }
+      if (isCallNode) {
+        replaceCallName(node, adapter.target);
+      } else {
+        replaceIdName(node, adapter.target);
+      }
+      if (adapter.package === PACKAGE_NAME.router && !ctx.route) {
+        ctx.route = true;
+      }
+      recordImport(ctx, adapter.package, adapter.target);
     }
   };
 }
-function resolveTransformAdapterRules(pkgName, rules, path7, ctx) {
-  const node = path7.node;
-  const isCallExpr = t35.isCallExpression(node);
-  let sourceName = "";
-  if (t35.isIdentifier(node)) {
-    sourceName = node.name;
-  } else if (isCallExpr && t35.isIdentifier(node.callee)) {
-    sourceName = node.callee.name;
-  }
-  const { pure, effectful } = rules.transform;
-  const watchEffectAdapter = findNestedAdapter(sourceName, pure.watchEffect);
-  if (watchEffectAdapter) {
-    if (isCallExpr) {
-      handleDependencyAnalysisAPI(
-        path7,
-        ctx,
-        watchEffectAdapter,
-        pkgName
-      );
-    } else {
-      replaceIdName(node, watchEffectAdapter);
-      recordImport(ctx, pkgName, watchEffectAdapter);
-    }
-    return;
-  }
-  const lifecycleAdapter = findNestedAdapter(sourceName, pure.lifecycle);
-  if (lifecycleAdapter) {
-    if (isCallExpr) {
-      handleDependencyAnalysisAPI(
-        path7,
-        ctx,
-        lifecycleAdapter,
-        pkgName
-      );
-    } else {
-      replaceIdName(node, lifecycleAdapter);
-      recordImport(ctx, pkgName, lifecycleAdapter);
-    }
-    return;
-  }
-  const pureApi = pure[sourceName];
-  if (pureApi) {
-    if (isCallExpr) {
-      replaceCallName(node, pureApi);
-    } else {
-      replaceIdName(node, pureApi);
-    }
-    recordImport(ctx, pkgName, pureApi);
-    return;
-  }
-  const effectfulApi = effectful[sourceName];
-  if (effectfulApi) {
-    if (isCallExpr) {
-      replaceCallName(node, effectfulApi);
-    } else {
-      replaceIdName(node, effectfulApi);
-    }
-    recordImport(ctx, pkgName, effectfulApi);
-    return;
-  }
-}
-function findNestedAdapter(sourceName, nestedMap) {
-  if (!nestedMap) return void 0;
-  if (typeof nestedMap === "string") {
-    return nestedMap;
-  }
-  return nestedMap[sourceName];
-}
-function handleDependencyAnalysisAPI(path7, ctx, adapter, pkgName) {
-  const { node } = path7;
-  const { arguments: args } = node;
-  if (args.length === 0) return;
-  const fn = args[0];
-  if (!t35.isArrowFunctionExpression(fn) && !t35.isFunctionExpression(fn)) {
-    return;
-  }
-  const fnPath = path7.get("arguments")[0];
-  const deps = analyzeDeps(fn, ctx, fnPath);
-  args.push(deps);
-  replaceCallName(node, adapter);
-  recordImport(ctx, pkgName, adapter);
-}
 
 // src/core/transform/sfc/script/syntax-processor/index.ts
 function processVueSyntax2(ast, ctx) {
   vueSyntaxProcessor2(ast, ctx, {
     preprocess: {
       applyBabel: [
-        resolveOptions,
+        resolvePropsIface,
         resolveEmitsTopLevelTypes,
         resolveSlotsTopLevelTypes,
-        resolvePropsIface,
-        resolveAsyncComponent,
+        resolveDefineOptions,
+        resolveDefineExpose,
+        resolveDefineAsyncComponent,
         resolveEmitCalls
       ]
     },
     process: {
       applyBabel: [
-        resolveRenameOnlyAdapter,
+        resolveElementRef,
+        resolveRenameAdapter,
         resolveArrowFnDeps,
         resolveUnanalyzedArrow,
-        resolveTransformAdapter,
-        resolveTemplateRef,
+        resolveAnalysisOnlyAdapter,
         resolveProvide,
         resolveExprMemo,
-        lintRules
+        resolveLintRules
       ],
       excludeBabel: [resolveTemplateSlotIface, resolveCompIProps]
     },
@@ -3707,12 +3974,12 @@ function processVueSyntax2(ast, ctx) {
 }
 function vueSyntaxProcessor2(ast, ctx, options) {
   const runExcludeThenApply = (cfg) => {
-    _optionalChain([cfg, 'access', _104 => _104.excludeBabel, 'optionalAccess', _105 => _105.forEach, 'call', _106 => _106((fn) => fn(ctx, ast))]);
-    _optionalChain([cfg, 'access', _107 => _107.applyBabel, 'optionalAccess', _108 => _108.forEach, 'call', _109 => _109((fn) => _core.traverse.call(void 0, ast, fn(ctx, ast)))]);
+    _optionalChain([cfg, 'access', _108 => _108.excludeBabel, 'optionalAccess', _109 => _109.forEach, 'call', _110 => _110((fn) => fn(ctx, ast))]);
+    _optionalChain([cfg, 'access', _111 => _111.applyBabel, 'optionalAccess', _112 => _112.forEach, 'call', _113 => _113((fn) => _core.traverse.call(void 0, ast, fn(ctx, ast)))]);
   };
   const runApplyThenExclude = (cfg) => {
-    _optionalChain([cfg, 'access', _110 => _110.applyBabel, 'optionalAccess', _111 => _111.forEach, 'call', _112 => _112((fn) => _core.traverse.call(void 0, ast, fn(ctx, ast)))]);
-    _optionalChain([cfg, 'access', _113 => _113.excludeBabel, 'optionalAccess', _114 => _114.forEach, 'call', _115 => _115((fn) => fn(ctx, ast))]);
+    _optionalChain([cfg, 'access', _114 => _114.applyBabel, 'optionalAccess', _115 => _115.forEach, 'call', _116 => _116((fn) => _core.traverse.call(void 0, ast, fn(ctx, ast)))]);
+    _optionalChain([cfg, 'access', _117 => _117.excludeBabel, 'optionalAccess', _118 => _118.forEach, 'call', _119 => _119((fn) => fn(ctx, ast))]);
   };
   runExcludeThenApply(options.preprocess);
   runExcludeThenApply(options.process);
@@ -3810,22 +4077,22 @@ function isSimpleExpression(code, excludeVar = false) {
   } catch (e5) {
     return false;
   }
-  if (t36.isLiteral(node)) {
+  if (t37.isLiteral(node)) {
     return true;
   }
-  if (!excludeVar && t36.isIdentifier(node)) {
+  if (!excludeVar && t37.isIdentifier(node)) {
     return true;
   }
-  if (t36.isMemberExpression(node)) {
-    return isSimpleExpression(node.object) && t36.isIdentifier(node.property);
+  if (t37.isMemberExpression(node)) {
+    return isSimpleExpression(node.object) && t37.isIdentifier(node.property);
   }
-  if (t36.isObjectExpression(node) || t36.isArrayExpression(node)) {
+  if (t37.isObjectExpression(node) || t37.isArrayExpression(node)) {
     return false;
   }
-  if (t36.isCallExpression(node) || t36.isAssignmentExpression(node)) {
+  if (t37.isCallExpression(node) || t37.isAssignmentExpression(node)) {
     return false;
   }
-  if (t36.isBinaryExpression(node) || t36.isUnaryExpression(node)) {
+  if (t37.isBinaryExpression(node) || t37.isUnaryExpression(node)) {
     return true;
   }
   return false;
@@ -3833,7 +4100,7 @@ function isSimpleExpression(code, excludeVar = false) {
 function isIdentifier20(code) {
   try {
     const node = _parser.parseExpression.call(void 0, code);
-    return t36.isIdentifier(node);
+    return t37.isIdentifier(node);
   } catch (e6) {
     return false;
   }
@@ -3841,7 +4108,7 @@ function isIdentifier20(code) {
 function isStringLiteral12(code) {
   try {
     const node = _parser.parseExpression.call(void 0, code);
-    return t36.isStringLiteral(node) || t36.isTemplateLiteral(node);
+    return t37.isStringLiteral(node) || t37.isTemplateLiteral(node);
   } catch (e7) {
     return false;
   }
@@ -3886,7 +4153,7 @@ function resolveRefVariable(input, ctx) {
   };
   for (const name in reactiveBindings) {
     const binding = reactiveBindings[name];
-    if (_optionalChain([binding, 'optionalAccess', _116 => _116.reactiveType]) !== "ref") continue;
+    if (_optionalChain([binding, 'optionalAccess', _120 => _120.reactiveType]) !== "ref") continue;
     input = addValueProperty(input, name);
   }
   return input;
@@ -3894,13 +4161,13 @@ function resolveRefVariable(input, ctx) {
 
 // src/core/transform/sfc/template/shared/resolve-string-expression/index.ts
 function resolveStringExpr(input, ctx, toStrLiteral = false) {
-  if (toStrLiteral) return t37.stringLiteral(input);
+  if (toStrLiteral) return t38.stringLiteral(input);
   const { filename, scriptData } = ctx;
   const newContent = resolveSpecialExpressions(input, ctx);
   try {
     return stringToExpr(newContent, scriptData.lang, filename);
   } catch (e8) {
-    return t37.identifier(newContent);
+    return t38.identifier(newContent);
   }
 }
 
@@ -4005,12 +4272,12 @@ function wrapSingleQuotes(content, condition) {
   return condition || strCodeTypes.isStringLiteral(content) ? `'${content}'` : content;
 }
 function checkPropIsDynamicKey(ctx, node) {
-  const isKeyStatic = _optionalChain([node, 'access', _117 => _117.arg, 'optionalAccess', _118 => _118.isStatic]);
+  const isKeyStatic = _optionalChain([node, 'access', _121 => _121.arg, 'optionalAccess', _122 => _122.isStatic]);
   const { source, filename } = ctx;
   if (node.rawName === "v-bind" && !node.name) {
     logger.warn("Keyless v-bind will overwrite all previously declared props at runtime.", {
       source,
-      loc: _optionalChain([node, 'access', _119 => _119.arg, 'optionalAccess', _120 => _120.loc]),
+      loc: _optionalChain([node, 'access', _123 => _123.arg, 'optionalAccess', _124 => _124.loc]),
       file: filename
     });
     return;
@@ -4018,7 +4285,7 @@ function checkPropIsDynamicKey(ctx, node) {
   if (isKeyStatic === false) {
     logger.warn("Avoid using dynamic slot names, as they generate complex JSX prop expressions.", {
       source,
-      loc: _optionalChain([node, 'access', _121 => _121.arg, 'optionalAccess', _122 => _122.loc]),
+      loc: _optionalChain([node, 'access', _125 => _125.arg, 'optionalAccess', _126 => _126.loc]),
       file: filename
     });
   }
@@ -4037,7 +4304,7 @@ function resolvePropAsBabelExp(ir, ctx) {
   const mergedItems = value.merge;
   const setNameIdentifier = (target, valueName) => {
     target.content = valueName;
-    target.ast = t38.jsxIdentifier(valueName);
+    target.ast = t39.jsxIdentifier(valueName);
   };
   const setValueExpression = (target, content, isStringLiteral13) => {
     target.content = content;
@@ -4051,29 +4318,34 @@ function resolvePropAsBabelExp(ir, ctx) {
     if (setName && nameIdentifier) {
       setNameIdentifier(nameExp, nameIdentifier);
     }
+    const dir = ADAPTER_RULES.runtime.dir;
+    recordImport(ctx, dir.package, dir.target);
     setValueExpression(value.babelExp, expression, isStringLiteral13);
-    recordImport(ctx, PACKAGE_NAME.runtime, ADAPTER_UTILS_MAP.dir);
   };
   if (ir.isKeyLessVBind) {
-    const expression = createRuntimeCall(ADAPTER_UTILS_MAP.dirKeyless, [valueContent]);
+    const dirKeyless = ADAPTER_RULES.runtime.dirKeyless;
+    const expression = createRuntimeCall(dirKeyless.target, [valueContent]);
     applyRuntimeExpression(expression, false);
     return;
   }
   if (isClassAttr(name) && !value.isStringLiteral && !valueContent.startsWith(STYLE_MODULE_NAME)) {
-    const arg = _optionalChain([mergedItems, 'optionalAccess', _123 => _123.join, 'call', _124 => _124(",")]) || wrapSingleQuotes(valueContent);
-    const expression = createRuntimeCall(ADAPTER_UTILS_MAP.dirCls, [arg]);
+    const dirCls = ADAPTER_RULES.runtime.dirCls;
+    const arg = _optionalChain([mergedItems, 'optionalAccess', _127 => _127.join, 'call', _128 => _128(",")]) || wrapSingleQuotes(valueContent);
+    const expression = createRuntimeCall(dirCls.target, [arg]);
     applyRuntimeExpression(expression, true, name);
     return;
   }
-  if (isStyleAttr(name) && (!isSimpleStyle(valueContent) || _optionalChain([mergedItems, 'optionalAccess', _125 => _125.some, 'call', _126 => _126((item) => !isSimpleStyle(item))]))) {
-    const arg = _optionalChain([mergedItems, 'optionalAccess', _127 => _127.join, 'call', _128 => _128(",")]) || valueContent;
-    const expression = createRuntimeCall(ADAPTER_UTILS_MAP.dirStyle, [arg]);
+  if (isStyleAttr(name) && (!isSimpleStyle(valueContent) || _optionalChain([mergedItems, 'optionalAccess', _129 => _129.some, 'call', _130 => _130((item) => !isSimpleStyle(item))]))) {
+    const dirStyle = ADAPTER_RULES.runtime.dirStyle;
+    const arg = _optionalChain([mergedItems, 'optionalAccess', _131 => _131.join, 'call', _132 => _132(",")]) || valueContent;
+    const expression = createRuntimeCall(dirStyle.target, [arg]);
     applyRuntimeExpression(expression, true, name);
     return;
   }
-  if (ir.type === 3 /* EVENT */ && _optionalChain([ir, 'access', _129 => _129.modifiers, 'optionalAccess', _130 => _130.length])) {
+  if (ir.type === 3 /* EVENT */ && _optionalChain([ir, 'access', _133 => _133.modifiers, 'optionalAccess', _134 => _134.length])) {
+    const dirOn = ADAPTER_RULES.runtime.dirOn;
     const eventName = wrapSingleQuotes(ir.__vOnEvName || name, ir.isStatic);
-    const expression = createRuntimeCall(ADAPTER_UTILS_MAP.dirOn, [eventName, valueContent]);
+    const expression = createRuntimeCall(dirOn.target, [eventName, valueContent]);
     applyRuntimeExpression(expression, true, name);
     return;
   }
@@ -4125,13 +4397,13 @@ function resolveElementChildrenRules(children, ctx, parentIR, ir) {
       continue;
     }
     const nodeIR = child;
-    if (_optionalChain([parentIR, 'optionalAccess', _131 => _131.isBuiltIn])) {
-      if (parentIR.tag == ADAPTER_COMPS.Transition) {
+    if (_optionalChain([parentIR, 'optionalAccess', _135 => _135.isBuiltIn])) {
+      if (parentIR.tag == VUE_API_MAP.Transition) {
         resolveTransitionRules(nodeIR, parentIR, ir, ctx);
       }
     }
     if (nodeIR.isRoute) {
-      if (nodeIR.tag === ADAPTER_ROUTER_COMPS.RouterLink) {
+      if (nodeIR.tag === VUE_API_MAP.RouterLink) {
         resolveRouterLinkRules(nodeIR, ctx);
       }
     }
@@ -4166,7 +4438,7 @@ function walkElementNodes(node, onElement) {
 }
 function resolveDefaultStyleModuleName(node) {
   const { exp } = node;
-  if (_optionalChain([exp, 'optionalAccess', _132 => _132.type]) !== _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
+  if (_optionalChain([exp, 'optionalAccess', _136 => _136.type]) !== _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
     return;
   }
   if (exp.content.includes("$style")) {
@@ -4202,7 +4474,7 @@ function injectStyleScopeAttribute(node, ctx) {
     return;
   }
   const hasDynamicIs = node.props.some((prop) => {
-    if (prop.type !== _compilercore.NodeTypes.DIRECTIVE || _optionalChain([prop, 'access', _133 => _133.arg, 'optionalAccess', _134 => _134.type]) !== _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
+    if (prop.type !== _compilercore.NodeTypes.DIRECTIVE || _optionalChain([prop, 'access', _137 => _137.arg, 'optionalAccess', _138 => _138.type]) !== _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
       return false;
     }
     return prop.arg.content === "is";
@@ -4268,7 +4540,7 @@ function mergeStyleProps(oldAttr, newAttr) {
   const oldStyle = oldAttr.value.content;
   const newStyle = parseStyleString(newAttr.value.content);
   let merged = oldAttr.value.merge;
-  if (!_optionalChain([merged, 'optionalAccess', _135 => _135.length])) {
+  if (!_optionalChain([merged, 'optionalAccess', _139 => _139.length])) {
     merged = oldAttr.value.merge = [oldStyle, newStyle];
   } else {
     merged.push(newStyle);
@@ -4298,7 +4570,7 @@ function warnUnsupportedVueDollarVar(ctx, node) {
   const { source, filename } = ctx;
   let value = "";
   let loc;
-  if (node.type === _compilercore.NodeTypes.DIRECTIVE && _optionalChain([node, 'access', _136 => _136.exp, 'optionalAccess', _137 => _137.type]) === _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
+  if (node.type === _compilercore.NodeTypes.DIRECTIVE && _optionalChain([node, 'access', _140 => _140.exp, 'optionalAccess', _141 => _141.type]) === _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
     value = node.exp.content;
     loc = node.exp.loc;
   } else if (node.type === _compilercore.NodeTypes.INTERPOLATION && node.content.type === _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
@@ -4338,7 +4610,7 @@ function resolveDynamicIsProp(node, ir, ctx, nodeIR) {
   }
   const propIR = createPropsIR("is", "is", content);
   resolvePropAsBabelExp(propIR, ctx);
-  nodeIR.tag = ADAPTER_COMPS.Component;
+  nodeIR.tag = VUE_API_MAP.DynamicComponent;
   nodeIR.isComponent = true;
   nodeIR.props.push(propIR);
   recordImport(ctx, PACKAGE_NAME.runtime, nodeIR.tag);
@@ -4347,15 +4619,20 @@ function resolveDynamicIsProp(node, ir, ctx, nodeIR) {
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-ref-prop.ts
 
 function resolveRefProp(node, ctx, nodeIR) {
-  const { templateData } = ctx;
+  const {
+    templateData: { refBindings }
+  } = ctx;
   let propIR;
   if (node.type === _compilercore.NodeTypes.ATTRIBUTE) {
-    const tagName = _optionalChain([node, 'access', _138 => _138.value, 'optionalAccess', _139 => _139.content]);
-    const binding = Object.values(templateData.refBindings).find((r) => r.tag === tagName);
-    propIR = createPropsIR("ref", "ref", _optionalChain([binding, 'optionalAccess', _140 => _140.name]) || "null");
+    const tag = _optionalChain([node, 'access', _142 => _142.value, 'optionalAccess', _143 => _143.content]);
+    if (!tag) return;
+    collectComponentRef(tag, ctx);
+    const domRefBinding = Object.values(refBindings.domRefs).find((r) => r.tag === tag);
+    const refVar = _optionalChain([domRefBinding, 'optionalAccess', _144 => _144.name]) || _optionalChain([refBindings, 'access', _145 => _145.componentRefs, 'access', _146 => _146[tag], 'optionalAccess', _147 => _147.name]);
+    propIR = createPropsIR("ref", "ref", refVar || "null");
   } else {
     const exp = node.exp;
-    for (const name in templateData.refBindings) {
+    for (const name in refBindings.domRefs) {
       const newName = `${name}.current`;
       const regex = new RegExp(`${name}(?!\\.current)`, "g");
       exp.content = exp.content.replace(regex, newName);
@@ -4365,13 +4642,29 @@ function resolveRefProp(node, ctx, nodeIR) {
   resolvePropAsBabelExp(propIR, ctx);
   nodeIR.props.push(propIR);
 }
+function collectComponentRef(tag, ctx) {
+  if (tag in HTML_TAG_TYPES) {
+    return;
+  }
+  const { refBindings, reactiveBindings } = ctx.templateData;
+  refBindings.componentRefs[tag] = {
+    tag,
+    // 对应的标签名（随便填，不影响）
+    htmlType: "",
+    name: tag
+    // 对应的变量名（随便填，不影响）
+  };
+  if (reactiveBindings[tag]) {
+    delete reactiveBindings[tag];
+  }
+}
 
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-dynamic-attribute-prop.ts
 function resolveDynamicAttributeProp(node, ir, ctx, nodeIR) {
   const arg = node.arg;
   const exp = node.exp;
-  const name = _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _141 => _141.content]), () => ( ""));
-  const content = _nullishCoalesce(_optionalChain([exp, 'optionalAccess', _142 => _142.content]), () => ( "true"));
+  const name = _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _148 => _148.content]), () => ( ""));
+  const content = _nullishCoalesce(_optionalChain([exp, 'optionalAccess', _149 => _149.content]), () => ( "true"));
   warnUnsupportedVueDollarVar(ctx, node);
   if (name === "is") {
     resolveDynamicIsProp(node, ir, ctx, nodeIR);
@@ -4382,7 +4675,7 @@ function resolveDynamicAttributeProp(node, ir, ctx, nodeIR) {
     return;
   }
   const dynamicPropIR = createPropsIR(node.rawName, name, content);
-  dynamicPropIR.isStatic = _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _143 => _143.isStatic]), () => ( true));
+  dynamicPropIR.isStatic = _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _150 => _150.isStatic]), () => ( true));
   checkPropIsDynamicKey(ctx, node);
   resolvePropertyIR(dynamicPropIR, ir, ctx, nodeIR, true);
 }
@@ -4410,7 +4703,7 @@ function resolvePropertyIR(node, ir, ctx, nodeIR, isDynamic = false) {
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-attribute-prop.ts
 function resolveAttributeProp(node, ir, ctx, nodeIR) {
   const name = node.name;
-  const content = _nullishCoalesce(_optionalChain([node, 'access', _144 => _144.value, 'optionalAccess', _145 => _145.content]), () => ( "true"));
+  const content = _nullishCoalesce(_optionalChain([node, 'access', _151 => _151.value, 'optionalAccess', _152 => _152.content]), () => ( "true"));
   if (name === "is") {
     resolveStaticIsProp(content, ir, ctx, nodeIR);
     return;
@@ -4434,10 +4727,10 @@ function resolveRouterLinkVSlotProp(node, nodeIR, ctx) {
     type: 2 /* SLOT */,
     name: "customRender",
     rawName: _nullishCoalesce(node.rawName, () => ( "v-slot")),
-    isStatic: _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _146 => _146.isStatic]), () => ( true)),
+    isStatic: _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _153 => _153.isStatic]), () => ( true)),
     isScoped: true,
     callback: {
-      arg: _nullishCoalesce(_optionalChain([exp, 'optionalAccess', _147 => _147.content, 'optionalAccess', _148 => _148.trim, 'call', _149 => _149()]), () => ( "")),
+      arg: _nullishCoalesce(_optionalChain([exp, 'optionalAccess', _154 => _154.content, 'optionalAccess', _155 => _155.trim, 'call', _156 => _156()]), () => ( "")),
       exp: []
     }
   };
@@ -4453,10 +4746,10 @@ function resolveVFor(node, _ir, _ctx, nodeIR) {
   };
 }
 function resolveForResult(forParseResult) {
-  const source = _optionalChain([forParseResult, 'access', _150 => _150.source, 'optionalAccess', _151 => _151.content]);
-  const value = _optionalChain([forParseResult, 'access', _152 => _152.value, 'optionalAccess', _153 => _153.content]);
-  const index = _optionalChain([forParseResult, 'access', _154 => _154.index, 'optionalAccess', _155 => _155.content]);
-  const key = _optionalChain([forParseResult, 'access', _156 => _156.key, 'optionalAccess', _157 => _157.content]);
+  const source = _optionalChain([forParseResult, 'access', _157 => _157.source, 'optionalAccess', _158 => _158.content]);
+  const value = _optionalChain([forParseResult, 'access', _159 => _159.value, 'optionalAccess', _160 => _160.content]);
+  const index = _optionalChain([forParseResult, 'access', _161 => _161.index, 'optionalAccess', _162 => _162.content]);
+  const key = _optionalChain([forParseResult, 'access', _163 => _163.key, 'optionalAccess', _164 => _164.content]);
   return {
     source,
     value,
@@ -4476,7 +4769,7 @@ function resolveVHtml(node, ir, ctx, nodeIR) {
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-if.ts
 function resolveVIf(node, _ir, ctx, nodeIR, siblingNodesIR) {
   const name = node.name === "else-if" ? "elseIf" : node.name;
-  const value = _nullishCoalesce(_optionalChain([node, 'access', _158 => _158.exp, 'optionalAccess', _159 => _159.content]), () => ( "true"));
+  const value = _nullishCoalesce(_optionalChain([node, 'access', _165 => _165.exp, 'optionalAccess', _166 => _166.content]), () => ( "true"));
   const prevNode = siblingNodesIR[siblingNodesIR.length - 1];
   const isElseBranch = name === "else" || name === "elseIf";
   let hasError = false;
@@ -4515,7 +4808,7 @@ function resolveVIf(node, _ir, ctx, nodeIR, siblingNodesIR) {
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-memo.ts
 function resolveVMemo(node, _ir, ctx, nodeIR) {
   const exp = node.exp;
-  let value = _optionalChain([exp, 'optionalAccess', _160 => _160.content]);
+  let value = _optionalChain([exp, 'optionalAccess', _167 => _167.content]);
   if (value !== void 0) {
     if (!value.trim() || !value.startsWith("[") && !value.endsWith("]")) {
       const { source, filename } = ctx;
@@ -4555,7 +4848,7 @@ function resolveVModel(node, _ir, ctx, elementNode, nodeIR) {
   const getterName = exp.content;
   const isComponent = elementNode.tagType === _compilercore.ElementTypes.COMPONENT;
   const inputType = resolveHtmlInput(elementNode, isComponent);
-  const propName = _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _161 => _161.content]), () => ( resolveModelPropName(inputType, isComponent)));
+  const propName = _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _168 => _168.content]), () => ( resolveModelPropName(inputType, isComponent)));
   let valuePropIR;
   let eventPropIR;
   if (isComponent) {
@@ -4563,7 +4856,7 @@ function resolveVModel(node, _ir, ctx, elementNode, nodeIR) {
     const getterNamespace = getRootIdName(getterName);
     const eventReactName = `onUpdate${capitalize(getterNamespace)}`;
     const eventVueName = `update:${getterNamespace}`;
-    const isTS = _optionalChain([ctx, 'access', _162 => _162.scriptData, 'optionalAccess', _163 => _163.lang, 'optionalAccess', _164 => _164.startsWith, 'call', _165 => _165("ts")]);
+    const isTS = _optionalChain([ctx, 'access', _169 => _169.scriptData, 'optionalAccess', _170 => _170.lang, 'optionalAccess', _171 => _171.startsWith, 'call', _172 => _172("ts")]);
     const valueArg = isTS ? "value: any" : "value";
     const processedValue = applyValueModifiers("value", modifiers);
     const handlerBody = `(${valueArg}) => { ${getterName} = ${processedValue} }`;
@@ -4601,7 +4894,7 @@ function getRadioValue(elementNode) {
   const valueAttr = elementNode.props.find(
     (prop) => prop.type === _compilercore.NodeTypes.ATTRIBUTE && prop.name === "value"
   );
-  if (!_optionalChain([valueAttr, 'optionalAccess', _166 => _166.value, 'optionalAccess', _167 => _167.content])) return '""';
+  if (!_optionalChain([valueAttr, 'optionalAccess', _173 => _173.value, 'optionalAccess', _174 => _174.content])) return '""';
   const content = valueAttr.value.content;
   return /^['"]/.test(content) ? content : `"${content}"`;
 }
@@ -4611,7 +4904,7 @@ function resolveHtmlInput(node, isComponent) {
   const typeProp = node.props.find(
     (prop) => prop.type === _compilercore.NodeTypes.ATTRIBUTE && prop.name === "type"
   );
-  return _optionalChain([typeProp, 'optionalAccess', _168 => _168.value, 'optionalAccess', _169 => _169.content, 'optionalAccess', _170 => _170.toLowerCase, 'call', _171 => _171()]);
+  return _optionalChain([typeProp, 'optionalAccess', _175 => _175.value, 'optionalAccess', _176 => _176.content, 'optionalAccess', _177 => _177.toLowerCase, 'call', _178 => _178()]);
 }
 function applyValueModifiers(valueExp, modifiers) {
   let result = valueExp;
@@ -4627,7 +4920,7 @@ function getRootIdName(expr) {
   if (typeof expr !== "string") return;
   const pattern = /^([a-zA-Z_$][a-zA-Z0-9_$]*)(?:[\.\?\.\[\(].*)?$/;
   const match = pattern.exec(expr.trim());
-  return _optionalChain([match, 'optionalAccess', _172 => _172[1]]);
+  return _optionalChain([match, 'optionalAccess', _179 => _179[1]]);
 }
 
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-on.ts
@@ -4648,7 +4941,7 @@ function resolveVOn(node, _ir, ctx, nodeIR) {
     originalVueEventName = `${arg.content}.${modifiers.join(".")}`;
   } else {
     const expr = stringToExpr(handler);
-    if (!t39.isFunctionExpression(expr) && !t39.isIdentifier(expr)) {
+    if (!t40.isFunctionExpression(expr) && !t40.isIdentifier(expr)) {
       handler = `() => {${handler}}`;
     }
   }
@@ -4775,7 +5068,7 @@ function resolveDirectiveProp(node, ir, ctx, elementNode, nodeIR, siblingNodesIR
       return resolveVOn(node, ir, ctx, nodeIR);
     }
     if (isVSlot(rawName2)) {
-      if (nodeIR.tag === ADAPTER_ROUTER_COMPS.RouterLink) {
+      if (nodeIR.tag === VUE_API_MAP.RouterLink) {
         resolveRouterLinkVSlotProp(node, nodeIR, ctx);
       }
       return true;
@@ -4816,7 +5109,7 @@ function resolveVSlotProp(node, _ir, ctx) {
   const name = !arg || arg.content === "default" ? "children" : arg.content;
   const content = !isScoped ? [] : void 0;
   const callback = isScoped ? {
-    arg: _nullishCoalesce(_optionalChain([exp, 'optionalAccess', _173 => _173.content, 'optionalAccess', _174 => _174.trim, 'call', _175 => _175()]), () => ( "")),
+    arg: _nullishCoalesce(_optionalChain([exp, 'optionalAccess', _180 => _180.content, 'optionalAccess', _181 => _181.trim, 'call', _182 => _182()]), () => ( "")),
     exp: []
   } : void 0;
   checkPropIsDynamicKey(ctx, node);
@@ -4824,7 +5117,7 @@ function resolveVSlotProp(node, _ir, ctx) {
     type: 2 /* SLOT */,
     name,
     rawName: _nullishCoalesce(node.rawName, () => ( "default")),
-    isStatic: _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _176 => _176.isStatic]), () => ( true)),
+    isStatic: _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _183 => _183.isStatic]), () => ( true)),
     isScoped,
     content,
     callback
@@ -4849,14 +5142,16 @@ function resolveElementNode(node, ir, ctx, siblingNodesIR) {
     isSelfClosing: node.isSelfClosing,
     loc: node.loc
   });
-  if (tag in ADAPTER_COMPS) {
+  const routerAdapter = ADAPTER_RULES.router[tag];
+  const runtimeAdapter = ADAPTER_RULES.runtime[tag];
+  if (runtimeAdapter) {
     nodeIR.isBuiltIn = true;
-    recordImport(ctx, PACKAGE_NAME.runtime, tag);
+    recordImport(ctx, runtimeAdapter.package, runtimeAdapter.target);
   }
-  if (tag in ADAPTER_ROUTER_COMPS) {
+  if (routerAdapter) {
     if (!ctx.route) ctx.route = true;
     nodeIR.isRoute = true;
-    recordImport(ctx, PACKAGE_NAME.router, tag);
+    recordImport(ctx, _optionalChain([routerAdapter, 'optionalAccess', _184 => _184.package]), routerAdapter.target);
   }
   resolveProps(node, ir, ctx, nodeIR, siblingNodesIR);
   return nodeIR;
@@ -4992,7 +5287,7 @@ function resolveSlotProps(node, ctx) {
   for (const prop of node.props) {
     if (prop.type === _compilercore.NodeTypes.ATTRIBUTE) {
       const attr = prop.name;
-      const value = _optionalChain([prop, 'access', _177 => _177.value, 'optionalAccess', _178 => _178.content, 'access', _179 => _179.trim, 'call', _180 => _180()]);
+      const value = _optionalChain([prop, 'access', _185 => _185.value, 'optionalAccess', _186 => _186.content, 'access', _187 => _187.trim, 'call', _188 => _188()]);
       if (attr === "name" && value) {
         result.name = camelCase(value);
       } else {
@@ -5082,19 +5377,19 @@ function resolveTemplate2(root, ctx) {
 // src/core/transform/sfc/index.ts
 function transform(ast, ctx, options) {
   const { template, script, style } = ast;
-  const templateIR = resolveTemplate2(_optionalChain([template, 'optionalAccess', _181 => _181.ast]), ctx);
-  const scriptIR = resolveScript2(_optionalChain([script, 'optionalAccess', _182 => _182.ast]), ctx);
+  const templateIR = resolveTemplate2(_optionalChain([template, 'optionalAccess', _189 => _189.ast]), ctx);
+  const scriptIR = resolveScript2(_optionalChain([script, 'optionalAccess', _190 => _190.ast]), ctx);
   const result = {
     template: templateIR,
     script: scriptIR,
-    style: _optionalChain([style, 'optionalAccess', _183 => _183.source, 'optionalAccess', _184 => _184.content])
+    style: _optionalChain([style, 'optionalAccess', _191 => _191.source, 'optionalAccess', _192 => _192.content])
   };
-  executePlugins(_optionalChain([options, 'optionalAccess', _185 => _185.plugins]), result, ctx);
+  executePlugins(_optionalChain([options, 'optionalAccess', _193 => _193.plugins]), result, ctx);
   return result;
 }
 
 // package.json
-var version = "1.1.0";
+var version = "1.1.1";
 var bin = {
   vureact: "./bin/vureact.js"
 };
@@ -5152,7 +5447,7 @@ var Helper = (_class3 = class {
   __init6() {this.outDir = "react-app"}
   constructor(opts) {;_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);
     this.compilerOpts = opts;
-    if (_optionalChain([opts, 'access', _186 => _186.output, 'optionalAccess', _187 => _187.workspace])) {
+    if (_optionalChain([opts, 'access', _194 => _194.output, 'optionalAccess', _195 => _195.workspace])) {
       this.workspaceDir = opts.output.workspace;
     }
     const excludePatterns = PathFilter.withDefaults(opts.exclude || []);
@@ -5187,7 +5482,7 @@ var Helper = (_class3 = class {
   }
   getOutDirName() {
     const { output } = this.compilerOpts;
-    return _optionalChain([output, 'optionalAccess', _188 => _188.outDir]) || this.outDir;
+    return _optionalChain([output, 'optionalAccess', _196 => _196.outDir]) || this.outDir;
   }
   getWorkspaceDir() {
     return _path2.default.resolve(this.getProjectRoot(), this.workspaceDir);
@@ -5201,7 +5496,7 @@ var Helper = (_class3 = class {
   }
   getIgnoreAssets() {
     const { output } = this.compilerOpts;
-    if (_optionalChain([output, 'optionalAccess', _189 => _189.ignoreAssets])) {
+    if (_optionalChain([output, 'optionalAccess', _197 => _197.ignoreAssets])) {
       return new Set(output.ignoreAssets.map(normalizePath));
     }
     return /* @__PURE__ */ new Set([
@@ -5282,12 +5577,12 @@ var Helper = (_class3 = class {
    */
   async formatCode({ code, fileInfo }) {
     const { format } = this.compilerOpts;
-    if (!_optionalChain([format, 'optionalAccess', _190 => _190.enabled])) return code;
-    if (_optionalChain([format, 'optionalAccess', _191 => _191.formatter]) === "builtin") {
+    if (!_optionalChain([format, 'optionalAccess', _198 => _198.enabled])) return code;
+    if (_optionalChain([format, 'optionalAccess', _199 => _199.formatter]) === "builtin") {
       return simpleFormat(code);
     }
-    const { lang } = _nullishCoalesce(_optionalChain([fileInfo, 'optionalAccess', _192 => _192.jsx]), () => ( _optionalChain([fileInfo, 'optionalAccess', _193 => _193.script])));
-    return await formatWithPrettier(code, lang, _optionalChain([format, 'optionalAccess', _194 => _194.prettierOptions]));
+    const { lang } = _nullishCoalesce(_optionalChain([fileInfo, 'optionalAccess', _200 => _200.jsx]), () => ( _optionalChain([fileInfo, 'optionalAccess', _201 => _201.script])));
+    return await formatWithPrettier(code, lang, _optionalChain([format, 'optionalAccess', _202 => _202.prettierOptions]));
   }
   /**
    * 通用的缓存校验工具函数
@@ -5420,7 +5715,7 @@ var Helper = (_class3 = class {
   }
   resolveViteCreateApp() {
     const { output } = this.compilerOpts;
-    const config = _optionalChain([output, 'optionalAccess', _195 => _195.bootstrapVite]);
+    const config = _optionalChain([output, 'optionalAccess', _203 => _203.bootstrapVite]);
     const template = typeof config === "object" ? config.template : "react-ts";
     const outDirName = this.getOutDirName();
     const cmd = `npm create vite@latest ${outDirName} -- --template ${template}`;
@@ -5434,7 +5729,7 @@ var Helper = (_class3 = class {
    * 获取需要排除编译的文件
    */
   getExcludes() {
-    if (!_optionalChain([this, 'access', _196 => _196.compilerOpts, 'access', _197 => _197.exclude, 'optionalAccess', _198 => _198.length])) {
+    if (!_optionalChain([this, 'access', _204 => _204.compilerOpts, 'access', _205 => _205.exclude, 'optionalAccess', _206 => _206.length])) {
       return PathFilter.withDefaults();
     }
     return this.compilerOpts.exclude;
@@ -5515,7 +5810,7 @@ function parseOnlyStyle(source, ctx, options) {
       ast: void 0
     }
   };
-  executePlugins(_optionalChain([options, 'optionalAccess', _199 => _199.plugins]), result, ctx);
+  executePlugins(_optionalChain([options, 'optionalAccess', _207 => _207.plugins]), result, ctx);
   return result;
 }
 
@@ -5549,7 +5844,10 @@ var CompilationContext = (_class4 = class {constructor() { _class4.prototype.__i
       propField: "$props",
       templateData: {
         slots: {},
-        refBindings: {},
+        refBindings: {
+          domRefs: {},
+          componentRefs: {}
+        },
         reactiveBindings: {}
       },
       scriptData: {
@@ -5566,6 +5864,10 @@ var CompilationContext = (_class4 = class {constructor() { _class4.prototype.__i
           emitTypes: [],
           slotTypes: []
         },
+        forwardRef: {
+          enabled: false,
+          refField: "expose"
+        },
         source: ""
       },
       styleData: {
@@ -5694,16 +5996,16 @@ var BaseCompiler = (_class5 = class extends Helper {
     });
     const genOptions = this.prepareGenerateOptions(filename);
     const resolveSFCAndScriptFile = () => {
-      const ast = parse(source, ctx.data, { plugins: _optionalChain([plugins, 'optionalAccess', _200 => _200.parser]) });
-      const ir = transform(ast, ctx.data, { plugins: _optionalChain([plugins, 'optionalAccess', _201 => _201.transformer]) });
+      const ast = parse(source, ctx.data, { plugins: _optionalChain([plugins, 'optionalAccess', _208 => _208.parser]) });
+      const ir = transform(ast, ctx.data, { plugins: _optionalChain([plugins, 'optionalAccess', _209 => _209.transformer]) });
       const gen = generate(ir, ctx.data, {
         ...genOptions,
-        plugins: _optionalChain([plugins, 'optionalAccess', _202 => _202.codegen])
+        plugins: _optionalChain([plugins, 'optionalAccess', _210 => _210.codegen])
       });
       return this.resolveMainResult(ir, gen, ctx.data);
     };
     const resolveStyleFile = () => {
-      const result = parseOnlyStyle(source, ctx.data, { plugins: _optionalChain([plugins, 'optionalAccess', _203 => _203.parser]) });
+      const result = parseOnlyStyle(source, ctx.data, { plugins: _optionalChain([plugins, 'optionalAccess', _211 => _211.parser]) });
       return this.resolveStyleResult(result, ctx.data);
     };
     try {
@@ -5830,9 +6132,9 @@ var BaseCompiler = (_class5 = class extends Helper {
             lang
           },
           css: {
-            file: _optionalChain([styleData, 'optionalAccess', _204 => _204.filePath]),
-            hash: _optionalChain([styleData, 'optionalAccess', _205 => _205.scopeId]),
-            code: _optionalChain([ir, 'optionalAccess', _206 => _206.style])
+            file: _optionalChain([styleData, 'optionalAccess', _212 => _212.filePath]),
+            hash: _optionalChain([styleData, 'optionalAccess', _213 => _213.scopeId]),
+            code: _optionalChain([ir, 'optionalAccess', _214 => _214.style])
           }
         },
         ...base
@@ -5906,7 +6208,7 @@ var AssetManager = (_class6 = class {
       const relativeToRoot = normalizePath(this.fileCompiler.relativePath(p));
       const filename = _path2.default.basename(p).toLowerCase();
       const ext = _path2.default.extname(p).toLowerCase();
-      if (!_optionalChain([this, 'access', _207 => _207.fileCompiler, 'access', _208 => _208.options, 'access', _209 => _209.output, 'optionalAccess', _210 => _210.ignoreAssets])) {
+      if (!_optionalChain([this, 'access', _215 => _215.fileCompiler, 'access', _216 => _216.options, 'access', _217 => _217.output, 'optionalAccess', _218 => _218.ignoreAssets])) {
         const shouldExclude = Array.from(exclusions).some((pattern) => {
           if (pattern.endsWith(".")) {
             return filename.startsWith(pattern);
@@ -6043,10 +6345,10 @@ var CleanupManager = class {
     const removeFn = async (m) => {
       if (key === "sfc" /* SFC */) {
         const meta = m;
-        if (!_optionalChain([meta, 'optionalAccess', _211 => _211.output])) return;
+        if (!_optionalChain([meta, 'optionalAccess', _219 => _219.output])) return;
         const { jsx, css } = meta.output;
         await this.fileCompiler.removeOutputFile(jsx.file);
-        if (_optionalChain([css, 'optionalAccess', _212 => _212.file])) {
+        if (_optionalChain([css, 'optionalAccess', _220 => _220.file])) {
           await this.fileCompiler.removeOutputFile(css.file);
         }
       } else if (key === "script" /* SCRIPT */ || key === "copied" /* ASSET */) {
@@ -6090,7 +6392,7 @@ var CompilationUnitProcessor = class {
     const isScriptFile = key === "script" /* SCRIPT */;
     const isStyleFile = key === "style" /* STYLE */;
     if (isSFC || isScriptFile) {
-      unit.hasRoute = _optionalChain([result, 'optionalAccess', _213 => _213.hasRoute]);
+      unit.hasRoute = _optionalChain([result, 'optionalAccess', _221 => _221.hasRoute]);
     }
     const resolveFileInfo = () => {
       if (isSFC) {
@@ -6110,7 +6412,7 @@ var CompilationUnitProcessor = class {
         const { script } = result.fileInfo;
         unit.output = {
           script: {
-            file: _optionalChain([script, 'optionalAccess', _214 => _214.file]),
+            file: _optionalChain([script, 'optionalAccess', _222 => _222.file]),
             code
           }
         };
@@ -6190,7 +6492,7 @@ var FileProcessor = (_class7 = class {
     const absPath = this.fileCompiler.getAbsPath(filePath);
     const fileMeta = await this.fileCompiler.getFileMeta(absPath);
     const cache = (this.fileCompiler.getIsCache() ? existingCache : void 0) || await this.fileCompiler.loadCache(key);
-    const record = _optionalChain([cache, 'optionalAccess', _215 => _215.target, 'access', _216 => _216.find, 'call', _217 => _217((c) => c.file === absPath)]);
+    const record = _optionalChain([cache, 'optionalAccess', _223 => _223.target, 'access', _224 => _224.find, 'call', _225 => _225((c) => c.file === absPath)]);
     const { shouldCompile, hash } = await this.fileCompiler.checkCacheStatus(
       fileMeta,
       record,
@@ -6209,10 +6511,10 @@ var FileProcessor = (_class7 = class {
       hash: hash || this.fileCompiler.genHash(source)
     };
     const processed = await this.compilationUnitProcessor.resolve(initUnit, key);
-    if (_optionalChain([processed, 'optionalAccess', _218 => _218.output])) {
+    if (_optionalChain([processed, 'optionalAccess', _226 => _226.output])) {
       await this.compilationUnitProcessor.saveCompiledFiles(processed, key);
       if (key === "sfc" /* SFC */ || key === "script" /* SCRIPT */) {
-        if (_optionalChain([processed, 'optionalAccess', _219 => _219.hasRoute])) {
+        if (_optionalChain([processed, 'optionalAccess', _227 => _227.hasRoute])) {
           await this.injectVuReactRouteDep();
         }
       }
@@ -6402,7 +6704,7 @@ var ViteBootstrapper = (_class9 = class {
    */
   resolveViteCreateApp() {
     const { output } = this.options;
-    const config = _optionalChain([output, 'optionalAccess', _220 => _220.bootstrapVite]);
+    const config = _optionalChain([output, 'optionalAccess', _228 => _228.bootstrapVite]);
     const template = typeof config === "object" ? config.template : "react-ts";
     const outDirName = this.fileCompiler.getOutDirName();
     const cmd = `npm create vite@latest ${outDirName} -- --template ${template}`;
@@ -6490,7 +6792,7 @@ var FileCompiler = (_class10 = class extends BaseCompiler {
       this.spinner.start("Copying assets...");
       const assetCount = await this.assetManager.runAssetPipeline();
       this.spinner.stop();
-      await _optionalChain([this, 'access', _221 => _221.options, 'access', _222 => _222.onSuccess, 'optionalCall', _223 => _223()]);
+      await _optionalChain([this, 'access', _229 => _229.options, 'access', _230 => _230.onSuccess, 'optionalCall', _231 => _231()]);
       const endTime = calcElapsedTime(startTime);
       this.printCoreLogs();
       this.showCompileStats(endTime, sfcCount, scriptCount, styleCount, assetCount);