@vureact/compiler-core 1.5.2 → 1.6.0

package/lib/{chunk-UYTNAOAJ.esm.js → chunk-H756PRG7.esm.js}

@@ -1,5 +1,5 @@
 /**
- * @vureact/compiler-core v1.5.2
+ * @vureact/compiler-core v1.6.0
  * (c) 2025-present Ruihong Zhong (Ryan John)
  * @license MIT
  */
@@ -78,6 +78,23 @@ var VUE_PACKAGES = [
   // 不需要带到 React 项目中
   "@vureact/compiler-core"
 ];
+var SUPPORTED_DIRECTIVES = /* @__PURE__ */ new Set([
+  "text",
+  "html",
+  "show",
+  "if",
+  "else",
+  "else-if",
+  "for",
+  "on",
+  "once",
+  "bind",
+  "model",
+  "cloak",
+  "slot",
+  "memo",
+  "is"
+]);
 
 // src/consts/adapters-map.ts
 var ADAPTER_RULES = {
@@ -392,7 +409,8 @@ var VUE_API_MAP = {
   defineAsyncComponent: "defineAsyncComponent",
   DynamicComponent: "Component",
   Transition: "Transition",
-  RouterLink: "RouterLink"
+  RouterLink: "RouterLink",
+  useAttrs: "useAttrs"
 };
 
 // src/shared/babel-utils.ts
@@ -572,34 +590,31 @@ var capitalize = (str) => {
   return str.charAt(0).toUpperCase() + str.slice(1);
 };
 
-// src/core/transform/sfc/template/shared/resolve-string-expression/special-expressions.ts
-function resolveSpecialExpressions(input, ctx) {
-  input = resolveEmitsCalls(input, ctx);
-  input = resolveRefVariable(input, ctx);
-  return input;
-}
+// src/core/transform/sfc/template/shared/resolve-string-expression/resolve-special-expression/resolve-emit-call.ts
 function resolveEmitsCalls(input, ctx) {
-  const result = matchEmitCalls(input, ctx);
+  const { reactiveBindings } = ctx.templateData;
+  const matchEmitCalls = () => {
+    const macroBinding = Object.values(reactiveBindings).find((b) => b.source === "defineEmits");
+    if (!macroBinding) return null;
+    const escapedName = macroBinding.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(
+      `${escapedName}\\s*\\(\\s*(['"\`])([^\\1]*?)\\1\\s*(?:,\\s*(.*?))?\\s*\\)$`,
+      // 可选的第二个参数
+      "s"
+      // s 标志让 . 匹配换行符
+    );
+    return input.trim().match(regex);
+  };
+  const result = matchEmitCalls();
   if (!result) return input;
   const [, , eventName, args] = result;
   const callee = eventName.split(/[:\-]/).map((part) => capitalize(camelCase(part))).join("");
   const event = args ? `on${callee}?.(${args})` : `on${callee}?.()`;
-  return `${ctx.propField}?.${event}`;
-}
-function matchEmitCalls(input, ctx) {
-  const { reactiveBindings } = ctx.templateData;
-  const macroBinding = Object.values(reactiveBindings).find((b) => b.source === "defineEmits");
-  if (!macroBinding) return null;
-  const escapedName = macroBinding.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const regex = new RegExp(
-    `${escapedName}\\s*\\(\\s*(['"\`])([^\\1]*?)\\1\\s*(?:,\\s*(.*?))?\\s*\\)$`,
-    // 可选的第二个参数
-    "s"
-    // s 标志让 . 匹配换行符
-  );
-  return input.trim().match(regex);
+  return `${ctx.propField}.${event}`;
 }
-function resolveRefVariable(input, ctx) {
+
+// src/core/transform/sfc/template/shared/resolve-string-expression/resolve-special-expression/resolve-ref-access.ts
+function resolveRefAccess(input, ctx) {
   const { reactiveBindings } = ctx.templateData;
   const addValueProperty = (input2, varName) => {
     const escapedVarName = varName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -617,11 +632,20 @@ function resolveRefVariable(input, ctx) {
   return input;
 }
 
+// src/core/transform/sfc/template/shared/resolve-string-expression/resolve-special-expression/index.ts
+function resolveSpecialExpression(input, ctx) {
+  const resolver = [resolveEmitsCalls, resolveRefAccess];
+  input = resolver.reduce((result, fn) => fn(result, ctx), input);
+  return input;
+}
+
 // src/core/transform/sfc/template/shared/resolve-string-expression/index.ts
 function resolveStringExpr(input, ctx, toStrLiteral = false) {
-  if (toStrLiteral) return t5.stringLiteral(input);
+  if (toStrLiteral) {
+    return t5.stringLiteral(input);
+  }
   const { filename, scriptData } = ctx;
-  const newContent = resolveSpecialExpressions(input, ctx);
+  const newContent = resolveSpecialExpression(input, ctx);
   try {
     return stringToExpr(newContent, scriptData.lang, filename);
   } catch {
@@ -1029,7 +1053,7 @@ function buildStandardProp(nodeIR) {
     babelExp: { ast: keyAST },
     value: {
       content,
-      isStringLiteral: isStringLiteral12,
+      isStringLiteral: isStringLiteral14,
       babelExp: { ast: valueAST }
     }
   } = nodeIR;
@@ -1038,18 +1062,34 @@ function buildStandardProp(nodeIR) {
   }
   let value;
   if (content !== "true") {
-    value = isStringLiteral12 ? t9.stringLiteral(content) : buildJsxExpressionNode(valueAST);
+    value = isStringLiteral14 ? t9.stringLiteral(content) : buildJsxExpressionNode(valueAST);
   }
   return t9.jsxAttribute(keyAST, value);
 }
 
-// src/core/codegen/component/jsx/syntax-processor/process/build-element-node.ts
+// src/core/codegen/component/jsx/syntax-processor/process/build-element-node/resolve-template-node.ts
+function resolveTemplateNode(nodeIR, children) {
+  const hasCondition = !!nodeIR.meta?.condition;
+  const hasLoop = !!nodeIR.meta?.loop?.isLoop;
+  const hasSlot = nodeIR.props.some((p) => p.type === 2 /* SLOT */);
+  if (hasCondition || hasLoop || hasSlot) {
+    if (!children.length) {
+      return buildFragmentNode([]);
+    }
+    if (children.length === 1) {
+      return children[0];
+    }
+    return buildFragmentNode(children);
+  }
+}
+
+// src/core/codegen/component/jsx/syntax-processor/process/build-element-node/index.ts
 function buildElementNode(nodeIR, ctx) {
   const mutableNodeIR = nodeIR;
   if (nodeIR.conditionIsHandled && !mutableNodeIR.__processing) {
     return null;
   }
-  const meta = nodeIR.meta;
+  const { meta } = nodeIR;
   if (meta?.condition && !meta.condition.isHandled) {
     return buildConditionNode(nodeIR, ctx);
   }
@@ -1061,6 +1101,10 @@ function buildElementNode(nodeIR, ctx) {
   }
   const props = buildProps(nodeIR, ctx);
   const children = buildJsxChildren(nodeIR.children, ctx);
+  if (nodeIR.tag === "template") {
+    const jsxChild = resolveTemplateNode(nodeIR, children);
+    if (jsxChild) return jsxChild;
+  }
   return createJsxElement(nodeIR.tag, props, children, nodeIR.isSelfClosing);
 }
 
@@ -1260,17 +1304,16 @@ function resolveMemoComponent(local, jsxStmt, ctx) {
   return t13.variableDeclaration("const", [t13.variableDeclarator(name, memoCall)]);
 }
 function resolveComponentName(ctx) {
-  const { filename, compName } = ctx;
-  let name = compName;
+  const { filename, scriptData } = ctx;
+  let { name } = scriptData.declaredOptions;
   if (!name) {
-    name = basename(filename).split(".")[0] || `FC${genHashByXXH(filename)}`;
-  }
-  name = capitalize(camelCase(name));
-  if (!compName) {
-    logger.warn("Missing component name, it falls back to the filename. " + name, {
+    const defaultName = basename(filename).split(".")[0] || `FC${genHashByXXH(filename)}`;
+    name = capitalize(camelCase(defaultName));
+    logger.warn(`Unnamed component detected. Using file name: <${name}>`, {
       file: filename
     });
   }
+  scriptData.declaredOptions.name = name;
   return t13.identifier(name);
 }
 function resolveLocalStatements(local, jsx) {
@@ -1320,21 +1363,32 @@ function resolveForwardRef(body, ctx) {
 }
 function resolvePropsParam(ctx) {
   const { propField, scriptData } = ctx;
-  const { propsTSIface } = scriptData;
+  const { propsTSIface, hasUseAttrsCall } = scriptData;
   const propsIdentifier = t13.identifier(propField);
   if (scriptData.lang.startsWith("js")) {
-    if (propsTSIface.hasPropsInJsEnv) {
+    if (propsTSIface.hasPropsInJsEnv || hasUseAttrsCall) {
       return propsIdentifier;
     }
     return;
   }
   if (!propsTSIface.name) {
+    if (hasUseAttrsCall) {
+      return withPropsTypeAnnotation(propsIdentifier);
+    }
     return;
   }
-  const typeIdentifier = t13.identifier(propsTSIface.name);
-  propsIdentifier.typeAnnotation = t13.tsTypeAnnotation(t13.tsTypeReference(typeIdentifier));
+  const typeName = resolvePropsTypeName(propsTSIface.name, hasUseAttrsCall);
+  return withPropsTypeAnnotation(propsIdentifier, typeName);
+}
+function withPropsTypeAnnotation(propsIdentifier, typeName = "Record<string, unknown>") {
+  const typeRef = t13.tsTypeReference(t13.identifier(typeName));
+  const typeAnnotation = t13.tsTypeAnnotation(typeRef);
+  propsIdentifier.typeAnnotation = typeAnnotation;
   return propsIdentifier;
 }
+function resolvePropsTypeName(name, hasUseAttrsCall) {
+  return typeof hasUseAttrsCall !== "undefined" ? `${name} & Record<string, unknown>` : name;
+}
 
 // src/core/codegen/component/script/syntax-processor/process/build-program-preamble.ts
 function buildProgramPreamble(nodeIR, ctx, state) {
@@ -1454,220 +1508,927 @@ import {
   parse as parseVueSFC
 } from "@vue/compiler-sfc";
 
-// src/core/parse/sfc/process/resolve-script.ts
-import { parse as babelParse2 } from "@babel/parser";
-function resolveScript(descriptor, ctx, parseResult) {
-  if (descriptor.script) {
-    throw new Error(
-      `Traditional Vue <script> syntax is not supported. Please migrate to <script setup>. 
-    at <anonymous> (${ctx.filename})`
-    );
-  }
-  const { scriptSetup } = descriptor;
-  if (!scriptSetup) return null;
-  if (scriptSetup?.warnings) {
-    scriptSetup?.warnings.forEach((msg) => {
-      logger.warn(msg, { file: ctx.filename });
-    });
-  }
-  resolveContext(scriptSetup, ctx);
-  const parseOpts = getBabelParseOptions(scriptSetup.lang, "script", ctx.filename);
-  parseResult.script = {
-    ast: babelParse2(scriptSetup.content, parseOpts),
-    source: scriptSetup
-  };
-}
-function resolveContext(scriptSetup, ctx) {
-  let { content, lang } = scriptSetup;
-  const resolveVRComment = (source) => {
-    const regx = /\/\/\s*@vr-name:\s*(\w+)/;
-    const nameMatch = source.match(regx);
-    content = content.replace(regx, "");
-    return nameMatch?.[1]?.trim() || "";
-  };
-  ctx.compName = resolveVRComment(content);
-  ctx.scriptData.source = content;
-  ctx.scriptData.lang = lang || "js";
-  scriptSetup.content = content;
-}
-
-// src/core/parse/sfc/process/resolve-script-meta.ts
+// src/core/parse/sfc/postprocess/resolve-script-metadata/index.ts
 import { traverse } from "@babel/core";
-import * as t15 from "@babel/types";
-
-// src/consts/html-tag-types.ts
-var HTML_TAG_TYPES = {
-  a: "HTMLAnchorElement",
-  p: "HTMLParagraphElement",
-  div: "HTMLDivElement",
-  span: "HTMLSpanElement",
-  h1: "HTMLHeadingElement",
-  h2: "HTMLHeadingElement",
-  h3: "HTMLHeadingElement",
-  h4: "HTMLHeadingElement",
-  h5: "HTMLHeadingElement",
-  h6: "HTMLHeadingElement",
-  button: "HTMLButtonElement",
-  input: "HTMLInputElement",
-  form: "HTMLFormElement",
-  textarea: "HTMLTextAreaElement",
-  select: "HTMLSelectElement",
-  option: "HTMLOptionElement",
-  label: "HTMLLabelElement",
-  fieldset: "HTMLFieldSetElement",
-  legend: "HTMLLegendElement",
-  img: "HTMLImageElement",
-  video: "HTMLVideoElement",
-  audio: "HTMLAudioElement",
-  canvas: "HTMLCanvasElement",
-  picture: "HTMLPictureElement",
-  source: "HTMLSourceElement",
-  track: "HTMLTrackElement",
-  ul: "HTMLUListElement",
-  ol: "HTMLOListElement",
-  li: "HTMLLIElement",
-  dl: "HTMLDListElement",
-  table: "HTMLTableElement",
-  thead: "HTMLTableSectionElement",
-  tbody: "HTMLTableSectionElement",
-  tfoot: "HTMLTableSectionElement",
-  tr: "HTMLTableRowElement",
-  td: "HTMLTableCellElement",
-  th: "HTMLTableCellElement",
-  caption: "HTMLTableCaptionElement",
-  col: "HTMLTableColElement",
-  colgroup: "HTMLTableColElement",
-  html: "HTMLHtmlElement",
-  head: "HTMLHeadElement",
-  body: "HTMLBodyElement",
-  title: "HTMLTitleElement",
-  meta: "HTMLMetaElement",
-  link: "HTMLLinkElement",
-  style: "HTMLStyleElement",
-  script: "HTMLScriptElement",
-  base: "HTMLBaseElement",
-  br: "HTMLBRElement",
-  hr: "HTMLHRElement",
-  del: "HTMLModElement",
-  ins: "HTMLModElement",
-  iframe: "HTMLIFrameElement",
-  embed: "HTMLEmbedElement",
-  object: "HTMLObjectElement",
-  param: "HTMLParamElement",
-  details: "HTMLDetailsElement",
-  dialog: "HTMLDialogElement",
-  menu: "HTMLMenuElement",
-  progress: "HTMLProgressElement",
-  meter: "HTMLMeterElement",
-  output: "HTMLOutputElement",
-  frame: "HTMLFrameElement"
-};
 
-// src/consts/reactive-type-map.ts
-var REACTIVE_TYPE_MAP = {
-  ref: "ref",
-  toRef: "ref",
-  toRefs: "ref",
-  customRef: "ref",
-  shallowRef: "ref",
-  reactive: "reactive",
-  shallowReactive: "reactive",
-  computed: "ref",
-  readonly: "reactive",
-  shallowReadonly: "reactive",
-  provide: "reactive",
-  inject: "reactive",
-  defineProps: "reactive",
-  defineEmits: "reactive",
-  useRoute: "reactive",
-  useRouter: "reactive",
-  useLink: "reactive"
-};
+// src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-declared-options.ts
+import * as t16 from "@babel/types";
 
-// src/shared/reactive-utils.ts
-function getReactiveType(originalName) {
-  return REACTIVE_TYPE_MAP[originalName] || "none";
+// src/core/transform/sfc/script/shared/babel-utils.ts
+import * as t15 from "@babel/types";
+function findRootVariablePath(path9) {
+  const rootId = findRootIdentifier(path9.node);
+  if (!rootId?.name) return null;
+  const binding = path9.scope.getBinding(rootId.name);
+  if (!binding) return null;
+  const rootPath = getVariableDeclaratorPath(binding.path);
+  return rootPath;
 }
-function getReactiveStateApis() {
-  return new Set(Object.keys(REACTIVE_TYPE_MAP));
+function findRootIdentifier(node) {
+  let current = node.object;
+  while (t15.isMemberExpression(current) || t15.isOptionalMemberExpression(current)) {
+    current = current.object;
+  }
+  return t15.isIdentifier(current) ? current : null;
 }
-
-// src/core/parse/sfc/process/resolve-script-meta.ts
-function resolveScriptMeta(result, ctx) {
-  const scriptAST = result.script?.ast;
-  if (!scriptAST) return;
-  traverse(scriptAST, {
-    VariableDeclarator(path9) {
-      const { node } = path9;
-      if (!atComponentOrHookRoot(path9, scriptAST.program) || !t15.isIdentifier(node.id)) {
-        return;
-      }
-      if (node.init && t15.isCallExpression(node.init) && t15.isIdentifier(node.init.callee)) {
-        collectReactiveBindings(node, ctx);
-        collectRefBindings(node, ctx);
-      }
-    }
-  });
+function getVariableDeclaratorPath(path9) {
+  if (path9.isVariableDeclarator()) {
+    return path9;
+  }
+  return path9.findParent((p) => p.isVariableDeclarator());
 }
-function collectReactiveBindings(node, ctx) {
-  const { reactiveBindings } = ctx.templateData;
-  const reactiveStateApis = getReactiveStateApis();
-  const init = node.init;
-  const callee = init.callee;
-  const source = callee.name;
-  if (!reactiveStateApis.has(source)) return;
-  const varName = node.id.name;
-  const value = init.arguments[0];
-  if (source === MACRO_API_NAMES.props) {
-    ctx.propField = varName;
+function isVariableDeclTopLevel(path9) {
+  const variableDeclaratorPath = path9;
+  const variableDeclarationPath = variableDeclaratorPath.parentPath;
+  if (!variableDeclarationPath) {
+    return false;
   }
-  reactiveBindings[varName] = {
-    name: varName,
-    value,
-    source,
-    reactiveType: getReactiveType(source)
-  };
+  if (variableDeclarationPath.isProgram()) {
+    return true;
+  }
+  const variableDeclarationParentPath = variableDeclarationPath.parentPath;
+  if (variableDeclarationParentPath && variableDeclarationParentPath.isProgram()) {
+    return true;
+  }
+  return false;
 }
-function collectRefBindings(node, ctx) {
-  const { refBindings } = ctx.templateData;
-  const init = node.init;
-  const callee = init.callee;
-  if (callee.name !== VUE_API_MAP.useTemplateRef) return;
-  const idName = node.id.name;
-  const tag = init.arguments[0]?.value;
-  refBindings.domRefs[idName] = {
-    tag,
-    htmlType: HTML_TAG_TYPES[tag] || "HTMLElement",
-    name: idName
-  };
+function isRealVariableAccess(path9) {
+  return isIdentifierAccess(path9) && !isPropertyName(path9);
 }
-
-// src/plugins/postcss.ts
-import postcss from "postcss";
-function processScopedWithPostCss(input, hash) {
-  const scopeId = `data-css-${hash}`;
-  const result = postcss([
-    {
-      postcssPlugin: "postcss-scoped-simple",
-      Rule(rule) {
-        if (rule.parent && rule.parent.type === "atrule" && rule.parent.name === "keyframes") {
-          return;
-        }
-        rule.selectors = rule.selectors.map((selector) => {
-          if (selector.includes(":global(")) {
-            return selector.replace(/:global\((.*)\)/, "$1");
-          }
-          if (selector.includes(":deep(")) {
-            return selector.replace(/:deep\((.*)\)/, "$1");
-          }
-          const pseudoElementRegex = /(::[a-zA-Z-]+)$/;
-          const match = selector.match(pseudoElementRegex);
-          if (match) {
-            const base = selector.replace(pseudoElementRegex, "");
-            const pseudo = match[1];
-            return `${base}[${scopeId}]${pseudo}`;
-          }
-          return `${selector}[${scopeId}]`;
+function isIdentifierAccess(path9) {
+  if (isIdentifierDeclaration(path9)) {
+    return false;
+  }
+  const binding = path9.scope.getBinding(path9.node.name);
+  if (!binding) {
+    return true;
+  }
+  return binding.identifier !== path9.node;
+}
+function isIdentifierDeclaration(path9) {
+  const parent = path9.parentPath;
+  if (!parent) return false;
+  if (parent.isVariableDeclarator() && parent.node.id === path9.node) {
+    return true;
+  }
+  if (parent.isFunctionDeclaration() && parent.node.id === path9.node) {
+    return true;
+  }
+  if (parent.isFunctionExpression() && parent.node.id === path9.node) {
+    return true;
+  }
+  if (parent.isClassDeclaration() && parent.node.id === path9.node) {
+    return true;
+  }
+  if (parent.isImportSpecifier() && parent.node.local === path9.node) {
+    return true;
+  }
+  if (parent.isImportDefaultSpecifier() && parent.node.local === path9.node) {
+    return true;
+  }
+  if (parent.isImportNamespaceSpecifier() && parent.node.local === path9.node) {
+    return true;
+  }
+  if (parent.isFunction() && parent.node.params.includes(path9.node)) {
+    return true;
+  }
+  if (parent.isCatchClause() && parent.node.param === path9.node) {
+    return true;
+  }
+  return false;
+}
+function isPropertyName(path9) {
+  const parent = path9.parentPath;
+  if (!parent) return false;
+  if (parent.isObjectProperty() && parent.node.key === path9.node) {
+    return true;
+  }
+  if (parent.isClassProperty() && parent.node.key === path9.node) {
+    return true;
+  }
+  if (parent.isMemberExpression() && parent.node.property === path9.node) {
+    return true;
+  }
+  return false;
+}
+function replaceCallName(callExp, identifierName) {
+  const { callee } = callExp;
+  if (!t15.isIdentifier(callee)) return;
+  callee.name = identifierName;
+  if (callee.loc) {
+    callee.loc.identifierName = identifierName;
+  }
+}
+function replaceIdName(id, newName) {
+  if (!t15.isIdentifier(id)) return;
+  id.name = newName;
+  if (id.loc) {
+    id.loc.identifierName = newName;
+  }
+}
+function stringValueToTSType(ctx, input, tsTypeAnnotation7) {
+  const { filename, scriptData } = ctx;
+  const exp = stringToExpr(input, scriptData.lang, filename);
+  const ts = expressionToTSType(exp);
+  return tsTypeAnnotation7 ? t15.tsTypeAnnotation(ts) : ts;
+}
+function expressionToTSType(exp) {
+  if (t15.isStringLiteral(exp)) return t15.tsStringKeyword();
+  if (t15.isNumericLiteral(exp)) return t15.tsNumberKeyword();
+  if (t15.isBooleanLiteral(exp)) return t15.tsBooleanKeyword();
+  if (t15.isArrayExpression(exp)) return t15.tsArrayType(t15.tsAnyKeyword());
+  if (t15.isObjectExpression(exp)) {
+    const members = [];
+    for (const p of exp.properties) {
+      if (!t15.isObjectProperty(p)) continue;
+      let key;
+      if (t15.isIdentifier(p.key)) key = p.key.name;
+      else if (t15.isStringLiteral(p.key)) key = p.key.value;
+      if (!key) continue;
+      if (t15.isExpression(p.value)) {
+        members.push(
+          t15.tsPropertySignature(t15.identifier(key), t15.tsTypeAnnotation(expressionToTSType(p.value)))
+        );
+      } else {
+        members.push(
+          t15.tsPropertySignature(t15.identifier(key), t15.tsTypeAnnotation(t15.tsAnyKeyword()))
+        );
+      }
+    }
+    return t15.tsTypeLiteral(members);
+  }
+  if (t15.isArrowFunctionExpression(exp) || t15.isFunctionExpression(exp)) {
+    const params = exp.params.map((p, i) => {
+      const id = t15.isIdentifier(p) ? t15.identifier(p.name) : t15.identifier(`arg${i}`);
+      id.typeAnnotation = t15.tsTypeAnnotation(t15.tsAnyKeyword());
+      return id;
+    });
+    let returnType = t15.tsAnyKeyword();
+    if (t15.isBlockStatement(exp.body)) {
+      for (const stmt of exp.body.body) {
+        if (t15.isReturnStatement(stmt) && stmt.argument) {
+          if (t15.isExpression(stmt.argument)) {
+            returnType = expressionToTSType(stmt.argument);
+            break;
+          }
+        }
+      }
+    } else if (t15.isExpression(exp.body)) {
+      returnType = expressionToTSType(exp.body);
+    }
+    return t15.tsFunctionType(null, params, t15.tsTypeAnnotation(returnType));
+  }
+  return t15.tsAnyKeyword();
+}
+function isCalleeNamed(node, name) {
+  if (!t15.isIdentifier(node.callee)) {
+    return false;
+  }
+  return node.callee.name === name;
+}
+function isSimpleLiteral(node) {
+  if (!node) return false;
+  if (t15.isStringLiteral(node) || t15.isNumericLiteral(node) || t15.isBooleanLiteral(node) || t15.isNullLiteral(node) || t15.isRegExpLiteral(node) || t15.isBigIntLiteral(node) || t15.isDecimalLiteral(node)) {
+    return true;
+  }
+  return false;
+}
+function forkNode(node, deep = true) {
+  const newNode = t15.cloneNode(node, deep);
+  newNode.leadingComments = node.leadingComments;
+  newNode.innerComments = node.innerComments;
+  newNode.trailingComments = null;
+  cleanNodeLoc(node);
+  cleanNodeComments(node);
+  return newNode;
+}
+function replaceNode(path9, target, source) {
+  const { start, end, loc, leadingComments, innerComments, trailingComments } = source;
+  target.start = start;
+  target.end = end;
+  target.loc = loc;
+  target.leadingComments = leadingComments;
+  target.innerComments = innerComments;
+  target.trailingComments = trailingComments;
+  cleanNodeLoc(source);
+  cleanNodeComments(source);
+  path9.replaceWith(target);
+}
+function cleanNodeLoc(node) {
+  node.start = null;
+  node.end = null;
+  node.loc = null;
+}
+function cleanNodeComments(node) {
+  node.leadingComments = null;
+  node.innerComments = null;
+  node.trailingComments = null;
+}
+
+// src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-declared-options.ts
+function resolveDeclaredOptions(path9, ctx) {
+  const { node } = path9;
+  const { filename, scriptData } = ctx;
+  if (!isCalleeNamed(node, MACRO_API_NAMES.options)) {
+    return;
+  }
+  const [options] = node.arguments;
+  if (!options || !t16.isObjectExpression(options)) {
+    logger.warn(
+      `Expected argument to be of a type ["ObjectExpression"] but instead got "${options?.type}".`,
+      {
+        file: filename,
+        source: scriptData.source,
+        loc: options?.loc || node.loc
+      }
+    );
+    return;
+  }
+  const { source, declaredOptions } = scriptData;
+  declaredOptions.inheritAttrs = true;
+  for (const property of options.properties) {
+    if (!t16.isObjectProperty(property) || !t16.isIdentifier(property.key) || property.computed) {
+      continue;
+    }
+    const propKey = property.key;
+    const propValue = property.value;
+    if (propKey.name === "name") {
+      if (!t16.isStringLiteral(propValue)) {
+        logger.warn(
+          `Expected property to be of a type ["StringLiteral"] but instead got "${propValue.type}".`,
+          {
+            source,
+            file: filename,
+            loc: propKey?.loc
+          }
+        );
+        continue;
+      }
+      if (propValue.value.trim()) {
+        declaredOptions.name = propValue.value.trim();
+      }
+      continue;
+    }
+    if (propKey.name === "inheritAttrs") {
+      if (!t16.isBooleanLiteral(propValue)) {
+        logger.warn(
+          `Expected property to be of a type ["BooleanLiteral"] but instead got "${propValue.type}".`,
+          {
+            source,
+            file: filename,
+            loc: propKey?.loc
+          }
+        );
+        continue;
+      }
+      declaredOptions.inheritAttrs = propValue.value;
+    }
+  }
+}
+
+// src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-declared-props-emits/resolve-declared-emits.ts
+import * as t18 from "@babel/types";
+
+// src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-declared-props-emits/shared.ts
+import * as t17 from "@babel/types";
+function isJsLikeLang(lang) {
+  return lang === "js" || lang === "jsx";
+}
+function mergeNames(target, names) {
+  for (const name of names) {
+    target.add(name);
+  }
+}
+function resolveTsTypes(typeParams) {
+  if (!typeParams) {
+    return [];
+  }
+  if (t17.isTSTypeParameterInstantiation(typeParams)) {
+    return typeParams.params;
+  }
+  return [];
+}
+function resolveObjectOrArrayLiteralNames(value) {
+  const names = /* @__PURE__ */ new Set();
+  if (!value) {
+    return names;
+  }
+  if (t17.isArrayExpression(value)) {
+    for (const element of value.elements) {
+      if (element && t17.isStringLiteral(element)) {
+        names.add(element.value);
+      }
+    }
+    return names;
+  }
+  if (t17.isObjectExpression(value)) {
+    for (const property of value.properties) {
+      if (!t17.isObjectProperty(property) && !t17.isObjectMethod(property)) {
+        continue;
+      }
+      const name = resolveStaticName(property.key);
+      if (name) {
+        names.add(name);
+      }
+    }
+  }
+  return names;
+}
+function resolveStaticName(key) {
+  if (t17.isIdentifier(key)) {
+    return key.name;
+  }
+  if (t17.isStringLiteral(key)) {
+    return key.value;
+  }
+  if (t17.isNumericLiteral(key)) {
+    return String(key.value);
+  }
+  if (t17.isTemplateLiteral(key) && !key.expressions.length) {
+    return key.quasis.map((q) => q.value.cooked || "").join("");
+  }
+  return null;
+}
+function resolveLocalTypeFromReference(path9, typeRef, ctx, macroName, visitedTypeRefs, warnedImportedTypeRefs) {
+  const refName = resolveTypeReferenceName(typeRef.typeName);
+  if (!refName) return null;
+  if (visitedTypeRefs.has(refName)) return null;
+  const binding = path9.scope.getBinding(refName);
+  if (binding) {
+    if (binding.path.isImportSpecifier() || binding.path.isImportDefaultSpecifier() || binding.path.isImportNamespaceSpecifier()) {
+      const key = `${macroName}:${refName}`;
+      if (!warnedImportedTypeRefs.has(key)) {
+        warnedImportedTypeRefs.add(key);
+        logger.warn(
+          "Type reference comes from an external file. Cross-file analysis is not supported, so it was skipped.",
+          {
+            file: ctx.filename,
+            source: ctx.source,
+            loc: typeRef.loc || path9.node.loc
+          }
+        );
+      }
+      return null;
+    }
+    visitedTypeRefs.add(refName);
+    if (binding.path.isTSInterfaceDeclaration()) {
+      return t17.tsTypeLiteral(binding.path.node.body.body);
+    }
+    if (binding.path.isTSTypeAliasDeclaration()) {
+      return binding.path.node.typeAnnotation;
+    }
+  }
+  const programPath = path9.findParent((p) => p.isProgram());
+  if (!programPath?.isProgram()) {
+    return null;
+  }
+  const declaration = resolveTypeDeclarationInProgram(programPath.node.body, refName);
+  if (declaration) {
+    visitedTypeRefs.add(refName);
+    return declaration;
+  }
+  const importSource = resolveImportedTypeSourceInProgram(programPath.node.body, refName);
+  if (importSource) {
+    const key = `${macroName}:${refName}`;
+    if (!warnedImportedTypeRefs.has(key)) {
+      warnedImportedTypeRefs.add(key);
+      logger.warn(
+        "Type reference comes from an external file. Cross-file analysis is not supported, so it was skipped.",
+        {
+          file: ctx.filename,
+          source: ctx.source,
+          loc: typeRef.loc || path9.node.loc
+        }
+      );
+    }
+    return null;
+  }
+  return null;
+}
+function resolveTypeReferenceName(typeName) {
+  if (t17.isIdentifier(typeName)) {
+    return typeName.name;
+  }
+  return null;
+}
+function resolveTypeDeclarationInProgram(body, typeName) {
+  for (const statement of body) {
+    if (t17.isTSInterfaceDeclaration(statement) && statement.id.name === typeName) {
+      return t17.tsTypeLiteral(statement.body.body);
+    }
+    if (t17.isTSTypeAliasDeclaration(statement) && statement.id.name === typeName) {
+      return statement.typeAnnotation;
+    }
+    if (!t17.isExportNamedDeclaration(statement) || !statement.declaration) {
+      continue;
+    }
+    const declaration = statement.declaration;
+    if (t17.isTSInterfaceDeclaration(declaration) && declaration.id.name === typeName) {
+      return t17.tsTypeLiteral(declaration.body.body);
+    }
+    if (t17.isTSTypeAliasDeclaration(declaration) && declaration.id.name === typeName) {
+      return declaration.typeAnnotation;
+    }
+  }
+  return null;
+}
+function resolveImportedTypeSourceInProgram(body, typeName) {
+  for (const statement of body) {
+    if (!t17.isImportDeclaration(statement)) {
+      continue;
+    }
+    const imported = statement.specifiers.some((specifier) => {
+      if (!specifier.local || specifier.local.name !== typeName) {
+        return false;
+      }
+      if (t17.isImportSpecifier(specifier)) {
+        return specifier.importKind === "type" || statement.importKind === "type";
+      }
+      return true;
+    });
+    if (imported) {
+      return statement.source.value;
+    }
+  }
+  return null;
+}
+
+// src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-declared-props-emits/resolve-declared-emits.ts
+function resolveDeclaredEmits(path9, ctx) {
+  const { node } = path9;
+  const { templateData, scriptData } = ctx;
+  if (!isCalleeNamed(node, MACRO_API_NAMES.emits)) {
+    return;
+  }
+  const [initValue] = node.arguments;
+  const tsTypeDef = node.typeParameters;
+  if (isJsLikeLang(scriptData.lang)) {
+    mergeNames(templateData.declaredEmits, resolveObjectOrArrayLiteralNames(initValue));
+    return;
+  }
+  const namesFromType = resolveDeclaredEmitsFromTypeParams(tsTypeDef, path9, ctx);
+  if (namesFromType.size) {
+    mergeNames(templateData.declaredEmits, namesFromType);
+    return;
+  }
+  mergeNames(templateData.declaredEmits, resolveObjectOrArrayLiteralNames(initValue));
+}
+function resolveDeclaredEmitsFromTypeParams(typeParams, path9, ctx) {
+  const names = /* @__PURE__ */ new Set();
+  const visitedTypeRefs = /* @__PURE__ */ new Set();
+  const warnedImportedTypeRefs = /* @__PURE__ */ new Set();
+  for (const tsType of resolveTsTypes(typeParams)) {
+    collectEmitsFromTsType(tsType, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs);
+  }
+  return names;
+}
+function collectEmitsFromTsType(tsType, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs) {
+  if (t18.isTSParenthesizedType(tsType)) {
+    collectEmitsFromTsType(
+      tsType.typeAnnotation,
+      names,
+      path9,
+      ctx,
+      visitedTypeRefs,
+      warnedImportedTypeRefs
+    );
+    return;
+  }
+  if (t18.isTSIntersectionType(tsType) || t18.isTSUnionType(tsType)) {
+    for (const type of tsType.types) {
+      collectEmitsFromTsType(type, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs);
+    }
+    return;
+  }
+  if (t18.isTSTypeReference(tsType)) {
+    const innerTypes = tsType.typeParameters?.params || [];
+    for (const type of innerTypes) {
+      collectEmitsFromTsType(type, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs);
+    }
+    const localType = resolveLocalTypeFromReference(
+      path9,
+      tsType,
+      ctx,
+      MACRO_API_NAMES.emits,
+      visitedTypeRefs,
+      warnedImportedTypeRefs
+    );
+    if (localType) {
+      collectEmitsFromTsType(localType, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs);
+    }
+    return;
+  }
+  if (t18.isTSFunctionType(tsType)) {
+    collectEmitNamesFromCallable(tsType.parameters, names);
+    return;
+  }
+  if (!t18.isTSTypeLiteral(tsType)) {
+    return;
+  }
+  for (const member of tsType.members) {
+    if (t18.isTSPropertySignature(member) || t18.isTSMethodSignature(member)) {
+      const eventName = resolveStaticName(member.key);
+      if (eventName) {
+        names.add(eventName);
+      }
+      continue;
+    }
+    if (t18.isTSCallSignatureDeclaration(member)) {
+      collectEmitNamesFromCallable(member.parameters, names);
+    }
+  }
+}
+function collectEmitNamesFromCallable(parameters, names) {
+  const firstParamType = resolveFirstParamType(parameters[0]);
+  if (!firstParamType) {
+    return;
+  }
+  for (const eventName of resolveStringLiteralTypeNames(firstParamType)) {
+    names.add(eventName);
+  }
+}
+function resolveFirstParamType(param) {
+  if (!param) {
+    return null;
+  }
+  if (t18.isIdentifier(param) && param.typeAnnotation && !t18.isNoop(param.typeAnnotation)) {
+    return param.typeAnnotation.typeAnnotation;
+  }
+  if (t18.isAssignmentPattern(param)) {
+    const left = param.left;
+    if (t18.isIdentifier(left) && left.typeAnnotation && !t18.isNoop(left.typeAnnotation)) {
+      return left.typeAnnotation.typeAnnotation;
+    }
+  }
+  if (t18.isRestElement(param) && t18.isIdentifier(param.argument)) {
+    const { typeAnnotation } = param.argument;
+    if (typeAnnotation && !t18.isNoop(typeAnnotation)) {
+      return typeAnnotation.typeAnnotation;
+    }
+  }
+  return null;
+}
+function resolveStringLiteralTypeNames(type) {
+  if (t18.isTSParenthesizedType(type)) {
+    return resolveStringLiteralTypeNames(type.typeAnnotation);
+  }
+  if (t18.isTSUnionType(type)) {
+    return type.types.flatMap(resolveStringLiteralTypeNames);
+  }
+  if (!t18.isTSLiteralType(type)) {
+    return [];
+  }
+  if (t18.isStringLiteral(type.literal)) {
+    return [type.literal.value];
+  }
+  if (t18.isTemplateLiteral(type.literal) && !type.literal.expressions.length) {
+    const cooked = type.literal.quasis.map((q) => q.value.cooked || "").join("");
+    return cooked ? [cooked] : [];
+  }
+  return [];
+}
+
+// src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-declared-props-emits/resolve-declared-props.ts
+import * as t19 from "@babel/types";
+function resolveDeclaredProps(path9, ctx) {
+  const { node } = path9;
+  const { templateData, scriptData } = ctx;
+  if (!isCalleeNamed(node, MACRO_API_NAMES.props)) {
+    return;
+  }
+  const [initValue] = node.arguments;
+  const tsTypeDef = node.typeParameters;
+  if (isJsLikeLang(scriptData.lang)) {
+    mergeNames(templateData.declaredProps, resolveObjectOrArrayLiteralNames(initValue));
+    return;
+  }
+  const namesFromType = resolveDeclaredPropsFromTypeParams(tsTypeDef, path9, ctx);
+  if (namesFromType.size) {
+    mergeNames(templateData.declaredProps, namesFromType);
+    return;
+  }
+  mergeNames(templateData.declaredProps, resolveObjectOrArrayLiteralNames(initValue));
+}
+function resolveDeclaredPropsFromTypeParams(typeParams, path9, ctx) {
+  const names = /* @__PURE__ */ new Set();
+  const visitedTypeRefs = /* @__PURE__ */ new Set();
+  const warnedImportedTypeRefs = /* @__PURE__ */ new Set();
+  for (const tsType of resolveTsTypes(typeParams)) {
+    collectPropsFromTsType(tsType, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs);
+  }
+  return names;
+}
+function collectPropsFromTsType(tsType, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs) {
+  if (t19.isTSParenthesizedType(tsType)) {
+    collectPropsFromTsType(
+      tsType.typeAnnotation,
+      names,
+      path9,
+      ctx,
+      visitedTypeRefs,
+      warnedImportedTypeRefs
+    );
+    return;
+  }
+  if (t19.isTSIntersectionType(tsType) || t19.isTSUnionType(tsType)) {
+    for (const type of tsType.types) {
+      collectPropsFromTsType(type, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs);
+    }
+    return;
+  }
+  if (t19.isTSTypeReference(tsType)) {
+    const innerTypes = tsType.typeParameters?.params || [];
+    for (const type of innerTypes) {
+      collectPropsFromTsType(type, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs);
+    }
+    const localType = resolveLocalTypeFromReference(
+      path9,
+      tsType,
+      ctx,
+      MACRO_API_NAMES.props,
+      visitedTypeRefs,
+      warnedImportedTypeRefs
+    );
+    if (localType) {
+      collectPropsFromTsType(localType, names, path9, ctx, visitedTypeRefs, warnedImportedTypeRefs);
+    }
+    return;
+  }
+  if (!t19.isTSTypeLiteral(tsType)) {
+    return;
+  }
+  for (const member of tsType.members) {
+    if (!t19.isTSPropertySignature(member) && !t19.isTSMethodSignature(member)) {
+      continue;
+    }
+    const name = resolveStaticName(member.key);
+    if (name) {
+      names.add(name);
+    }
+  }
+}
+
+// src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-declared-props-emits/index.ts
+function resolveDeclaredPropsAndEmits(path9, ctx) {
+  resolveDeclaredProps(path9, ctx);
+  resolveDeclaredEmits(path9, ctx);
+}
+
+// src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-use-attrs-exists.ts
+import * as t20 from "@babel/types";
+function resolveUseAttrsExists(path9, ctx) {
+  const { node } = path9;
+  const { templateData, scriptData } = ctx;
+  if (!isCalleeNamed(node, VUE_API_MAP.useAttrs)) {
+    return;
+  }
+  if (scriptData?.hasUseAttrsCall) {
+    return;
+  }
+  scriptData.hasUseAttrsCall = true;
+  const parent = path9.parentPath?.node;
+  if (parent && t20.isVariableDeclarator(parent) && t20.isIdentifier(parent.id)) {
+    templateData.declaredAttrs = parent.id.name;
+  }
+}
+
+// src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-var-bindings/index.ts
+import * as t21 from "@babel/types";
+
+// src/consts/reactive-type-map.ts
+var REACTIVE_TYPE_MAP = {
+  ref: "ref",
+  toRef: "ref",
+  toRefs: "ref",
+  customRef: "ref",
+  shallowRef: "ref",
+  reactive: "reactive",
+  shallowReactive: "reactive",
+  computed: "ref",
+  readonly: "reactive",
+  shallowReadonly: "reactive",
+  provide: "reactive",
+  inject: "reactive",
+  defineProps: "reactive",
+  defineEmits: "reactive",
+  useRoute: "reactive",
+  useRouter: "reactive",
+  useLink: "reactive"
+};
+
+// src/shared/reactive-utils.ts
+function getReactiveType(originalName) {
+  return REACTIVE_TYPE_MAP[originalName] || "none";
+}
+function getReactiveStateApis() {
+  return new Set(Object.keys(REACTIVE_TYPE_MAP));
+}
+
+// src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-var-bindings/resolve-reactive-bindings.ts
+function resolveReactiveBindings(node, ctx) {
+  const { reactiveBindings } = ctx.templateData;
+  const reactiveStateApis = getReactiveStateApis();
+  const init = node.init;
+  const callName = init.callee.name;
+  if (!reactiveStateApis.has(callName)) {
+    return;
+  }
+  const varName = node.id.name;
+  const initValue = init.arguments[0];
+  reactiveBindings[varName] = {
+    name: varName,
+    value: initValue,
+    source: callName,
+    reactiveType: getReactiveType(callName)
+  };
+  if (callName === MACRO_API_NAMES.props) {
+    ctx.propField = varName;
+  }
+}
+
+// src/consts/html-tag-types.ts
+var HTML_TAG_TYPES = {
+  a: "HTMLAnchorElement",
+  p: "HTMLParagraphElement",
+  div: "HTMLDivElement",
+  span: "HTMLSpanElement",
+  h1: "HTMLHeadingElement",
+  h2: "HTMLHeadingElement",
+  h3: "HTMLHeadingElement",
+  h4: "HTMLHeadingElement",
+  h5: "HTMLHeadingElement",
+  h6: "HTMLHeadingElement",
+  button: "HTMLButtonElement",
+  input: "HTMLInputElement",
+  form: "HTMLFormElement",
+  textarea: "HTMLTextAreaElement",
+  select: "HTMLSelectElement",
+  option: "HTMLOptionElement",
+  label: "HTMLLabelElement",
+  fieldset: "HTMLFieldSetElement",
+  legend: "HTMLLegendElement",
+  img: "HTMLImageElement",
+  video: "HTMLVideoElement",
+  audio: "HTMLAudioElement",
+  canvas: "HTMLCanvasElement",
+  picture: "HTMLPictureElement",
+  source: "HTMLSourceElement",
+  track: "HTMLTrackElement",
+  ul: "HTMLUListElement",
+  ol: "HTMLOListElement",
+  li: "HTMLLIElement",
+  dl: "HTMLDListElement",
+  table: "HTMLTableElement",
+  thead: "HTMLTableSectionElement",
+  tbody: "HTMLTableSectionElement",
+  tfoot: "HTMLTableSectionElement",
+  tr: "HTMLTableRowElement",
+  td: "HTMLTableCellElement",
+  th: "HTMLTableCellElement",
+  caption: "HTMLTableCaptionElement",
+  col: "HTMLTableColElement",
+  colgroup: "HTMLTableColElement",
+  html: "HTMLHtmlElement",
+  head: "HTMLHeadElement",
+  body: "HTMLBodyElement",
+  title: "HTMLTitleElement",
+  meta: "HTMLMetaElement",
+  link: "HTMLLinkElement",
+  style: "HTMLStyleElement",
+  script: "HTMLScriptElement",
+  base: "HTMLBaseElement",
+  br: "HTMLBRElement",
+  hr: "HTMLHRElement",
+  del: "HTMLModElement",
+  ins: "HTMLModElement",
+  iframe: "HTMLIFrameElement",
+  embed: "HTMLEmbedElement",
+  object: "HTMLObjectElement",
+  param: "HTMLParamElement",
+  details: "HTMLDetailsElement",
+  dialog: "HTMLDialogElement",
+  menu: "HTMLMenuElement",
+  progress: "HTMLProgressElement",
+  meter: "HTMLMeterElement",
+  output: "HTMLOutputElement",
+  frame: "HTMLFrameElement"
+};
+
+// src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-var-bindings/resolve-template-ref-bindings.ts
+function resolveTemplateRefBindings(node, ctx) {
+  const { refBindings } = ctx.templateData;
+  const init = node.init;
+  const callee = init.callee;
+  if (callee.name !== VUE_API_MAP.useTemplateRef) {
+    return;
+  }
+  const varName = node.id.name;
+  const initValue = init.arguments[0]?.value;
+  refBindings.domRefs[varName] = {
+    tag: initValue,
+    name: varName,
+    htmlType: HTML_TAG_TYPES[initValue] || "HTMLElement"
+  };
+}
+
+// src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-var-bindings/index.ts
+function resolveVarBindings(node, ctx) {
+  const { init, id } = node;
+  if (!t21.isIdentifier(id) || !init) {
+    return;
+  }
+  const isCallExpr = t21.isCallExpression(init) && t21.isIdentifier(init.callee);
+  if (isCallExpr) {
+    resolveReactiveBindings(node, ctx);
+    resolveTemplateRefBindings(node, ctx);
+  }
+}
+
+// src/core/parse/sfc/postprocess/resolve-script-metadata/index.ts
+function resolveScriptMeta(result, ctx) {
+  const scriptAst = result.script?.ast;
+  if (ctx.inputType !== "sfc" || !scriptAst) {
+    return;
+  }
+  traverse(scriptAst, {
+    VariableDeclarator(path9) {
+      if (!atComponentOrHookRoot(path9, scriptAst.program)) {
+        return;
+      }
+      resolveVarBindings(path9.node, ctx);
+    },
+    CallExpression(path9) {
+      resolveDeclaredOptions(path9, ctx);
+      resolveDeclaredPropsAndEmits(path9, ctx);
+      resolveUseAttrsExists(path9, ctx);
+    }
+  });
+}
+
+// src/core/parse/sfc/process/resolve-script.ts
+import { parse as babelParse2 } from "@babel/parser";
+function resolveScript(descriptor, ctx, parseResult) {
+  if (descriptor.script) {
+    throw new Error(
+      `Traditional Vue <script> syntax is not supported. Please migrate to <script setup>. 
+    at <anonymous> (${ctx.filename})`
+    );
+  }
+  const { scriptSetup } = descriptor;
+  if (!scriptSetup) return null;
+  if (scriptSetup?.warnings) {
+    scriptSetup?.warnings.forEach((msg) => {
+      logger.warn(msg, { file: ctx.filename });
+    });
+  }
+  resolveContext(scriptSetup, ctx);
+  const parseOpts = getBabelParseOptions(scriptSetup.lang, "script", ctx.filename);
+  parseResult.script = {
+    ast: babelParse2(scriptSetup.content, parseOpts),
+    source: scriptSetup
+  };
+}
+function resolveContext(scriptSetup, ctx) {
+  const { scriptData } = ctx;
+  let { content, lang } = scriptSetup;
+  const resolveVRComment = (source) => {
+    const regx = /\/\/\s*@vr-name:\s*(\w+)/;
+    const nameMatch = source.match(regx);
+    content = content.replace(regx, "");
+    return nameMatch?.[1]?.trim() || "";
+  };
+  scriptData.declaredOptions.name = resolveVRComment(content);
+  scriptData.lang = lang || "js";
+  scriptData.source = content;
+  scriptSetup.content = content;
+}
+
+// src/plugins/postcss.ts
+import postcss from "postcss";
+function processScopedWithPostCss(input, hash) {
+  const scopeId = `data-css-${hash}`;
+  const result = postcss([
+    {
+      postcssPlugin: "postcss-scoped-simple",
+      Rule(rule) {
+        if (rule.parent && rule.parent.type === "atrule" && rule.parent.name === "keyframes") {
+          return;
+        }
+        rule.selectors = rule.selectors.map((selector) => {
+          if (selector.includes(":global(")) {
+            return selector.replace(/:global\((.*)\)/, "$1");
+          }
+          if (selector.includes(":deep(")) {
+            return selector.replace(/:deep\((.*)\)/, "$1");
+          }
+          const pseudoElementRegex = /(::[a-zA-Z-]+)$/;
+          const match = selector.match(pseudoElementRegex);
+          if (match) {
+            const base = selector.replace(pseudoElementRegex, "");
+            const pseudo = match[1];
+            return `${base}[${scopeId}]${pseudo}`;
+          }
+          return `${selector}[${scopeId}]`;
         });
       }
     }
@@ -1873,205 +2634,6 @@ import { parse as babelParse3 } from "@babel/parser";
 // src/core/transform/sfc/script/syntax-processor/index.ts
 import { traverse as traverse3 } from "@babel/core";
 
-// src/core/transform/sfc/script/shared/babel-utils.ts
-import * as t16 from "@babel/types";
-function findRootVariablePath(path9) {
-  const rootId = findRootIdentifier(path9.node);
-  if (!rootId?.name) return null;
-  const binding = path9.scope.getBinding(rootId.name);
-  if (!binding) return null;
-  const rootPath = getVariableDeclaratorPath(binding.path);
-  return rootPath;
-}
-function findRootIdentifier(node) {
-  let current = node.object;
-  while (t16.isMemberExpression(current) || t16.isOptionalMemberExpression(current)) {
-    current = current.object;
-  }
-  return t16.isIdentifier(current) ? current : null;
-}
-function getVariableDeclaratorPath(path9) {
-  if (path9.isVariableDeclarator()) {
-    return path9;
-  }
-  return path9.findParent((p) => p.isVariableDeclarator());
-}
-function isVariableDeclTopLevel(path9) {
-  const variableDeclaratorPath = path9;
-  const variableDeclarationPath = variableDeclaratorPath.parentPath;
-  if (!variableDeclarationPath) {
-    return false;
-  }
-  if (variableDeclarationPath.isProgram()) {
-    return true;
-  }
-  const variableDeclarationParentPath = variableDeclarationPath.parentPath;
-  if (variableDeclarationParentPath && variableDeclarationParentPath.isProgram()) {
-    return true;
-  }
-  return false;
-}
-function isRealVariableAccess(path9) {
-  return isIdentifierAccess(path9) && !isPropertyName(path9);
-}
-function isIdentifierAccess(path9) {
-  if (isIdentifierDeclaration(path9)) {
-    return false;
-  }
-  const binding = path9.scope.getBinding(path9.node.name);
-  if (!binding) {
-    return true;
-  }
-  return binding.identifier !== path9.node;
-}
-function isIdentifierDeclaration(path9) {
-  const parent = path9.parentPath;
-  if (!parent) return false;
-  if (parent.isVariableDeclarator() && parent.node.id === path9.node) {
-    return true;
-  }
-  if (parent.isFunctionDeclaration() && parent.node.id === path9.node) {
-    return true;
-  }
-  if (parent.isFunctionExpression() && parent.node.id === path9.node) {
-    return true;
-  }
-  if (parent.isClassDeclaration() && parent.node.id === path9.node) {
-    return true;
-  }
-  if (parent.isImportSpecifier() && parent.node.local === path9.node) {
-    return true;
-  }
-  if (parent.isImportDefaultSpecifier() && parent.node.local === path9.node) {
-    return true;
-  }
-  if (parent.isImportNamespaceSpecifier() && parent.node.local === path9.node) {
-    return true;
-  }
-  if (parent.isFunction() && parent.node.params.includes(path9.node)) {
-    return true;
-  }
-  if (parent.isCatchClause() && parent.node.param === path9.node) {
-    return true;
-  }
-  return false;
-}
-function isPropertyName(path9) {
-  const parent = path9.parentPath;
-  if (!parent) return false;
-  if (parent.isObjectProperty() && parent.node.key === path9.node) {
-    return true;
-  }
-  if (parent.isClassProperty() && parent.node.key === path9.node) {
-    return true;
-  }
-  if (parent.isMemberExpression() && parent.node.property === path9.node) {
-    return true;
-  }
-  return false;
-}
-function replaceCallName(callExp, identifierName) {
-  const { callee } = callExp;
-  if (!t16.isIdentifier(callee)) return;
-  callee.name = identifierName;
-  if (callee.loc) {
-    callee.loc.identifierName = identifierName;
-  }
-}
-function replaceIdName(id, newName) {
-  if (!t16.isIdentifier(id)) return;
-  id.name = newName;
-  if (id.loc) {
-    id.loc.identifierName = newName;
-  }
-}
-function stringValueToTSType(ctx, input, tsTypeAnnotation7) {
-  const { filename, scriptData } = ctx;
-  const exp = stringToExpr(input, scriptData.lang, filename);
-  const ts = expressionToTSType(exp);
-  return tsTypeAnnotation7 ? t16.tsTypeAnnotation(ts) : ts;
-}
-function expressionToTSType(exp) {
-  if (t16.isStringLiteral(exp)) return t16.tsStringKeyword();
-  if (t16.isNumericLiteral(exp)) return t16.tsNumberKeyword();
-  if (t16.isBooleanLiteral(exp)) return t16.tsBooleanKeyword();
-  if (t16.isArrayExpression(exp)) return t16.tsArrayType(t16.tsAnyKeyword());
-  if (t16.isObjectExpression(exp)) {
-    const members = [];
-    for (const p of exp.properties) {
-      if (!t16.isObjectProperty(p)) continue;
-      let key;
-      if (t16.isIdentifier(p.key)) key = p.key.name;
-      else if (t16.isStringLiteral(p.key)) key = p.key.value;
-      if (!key) continue;
-      if (t16.isExpression(p.value)) {
-        members.push(
-          t16.tsPropertySignature(t16.identifier(key), t16.tsTypeAnnotation(expressionToTSType(p.value)))
-        );
-      } else {
-        members.push(
-          t16.tsPropertySignature(t16.identifier(key), t16.tsTypeAnnotation(t16.tsAnyKeyword()))
-        );
-      }
-    }
-    return t16.tsTypeLiteral(members);
-  }
-  if (t16.isArrowFunctionExpression(exp) || t16.isFunctionExpression(exp)) {
-    const params = exp.params.map((p, i) => {
-      const id = t16.isIdentifier(p) ? t16.identifier(p.name) : t16.identifier(`arg${i}`);
-      id.typeAnnotation = t16.tsTypeAnnotation(t16.tsAnyKeyword());
-      return id;
-    });
-    let returnType = t16.tsAnyKeyword();
-    if (t16.isBlockStatement(exp.body)) {
-      for (const stmt of exp.body.body) {
-        if (t16.isReturnStatement(stmt) && stmt.argument) {
-          if (t16.isExpression(stmt.argument)) {
-            returnType = expressionToTSType(stmt.argument);
-            break;
-          }
-        }
-      }
-    } else if (t16.isExpression(exp.body)) {
-      returnType = expressionToTSType(exp.body);
-    }
-    return t16.tsFunctionType(null, params, t16.tsTypeAnnotation(returnType));
-  }
-  return t16.tsAnyKeyword();
-}
-function isCalleeNamed(node, name) {
-  if (!t16.isIdentifier(node.callee)) {
-    return false;
-  }
-  return node.callee.name === name;
-}
-function isSimpleLiteral(node) {
-  if (!node) return false;
-  if (t16.isStringLiteral(node) || t16.isNumericLiteral(node) || t16.isBooleanLiteral(node) || t16.isNullLiteral(node) || t16.isRegExpLiteral(node) || t16.isBigIntLiteral(node) || t16.isDecimalLiteral(node)) {
-    return true;
-  }
-  return false;
-}
-function forkNode(node, deep = true) {
-  const newNode = t16.cloneNode(node, deep);
-  newNode.leadingComments = node.leadingComments;
-  newNode.innerComments = node.innerComments;
-  newNode.trailingComments = null;
-  cleanNodeLoc(node);
-  cleanNodeComments(node);
-  return newNode;
-}
-function cleanNodeLoc(node) {
-  node.start = null;
-  node.end = null;
-  node.loc = null;
-}
-function cleanNodeComments(node) {
-  node.leadingComments = null;
-  node.innerComments = null;
-  node.trailingComments = null;
-}
-
 // src/core/transform/sfc/script/syntax-processor/postprocess/resolve-ast-chunks/resolve-global-type-chunk.ts
 function resolveGlobalTypeChunks(path9, ir) {
   if (!path9.parentPath?.isProgram()) {
@@ -2083,12 +2645,12 @@ function resolveGlobalTypeChunks(path9, ir) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/postprocess/resolve-ast-chunks/resolve-module-chunk.ts
-import * as t17 from "@babel/types";
+import * as t22 from "@babel/types";
 function resolveModuleChunks(path9, ir) {
   const forked = forkNode(path9.node);
-  if (t17.isImportDeclaration(forked)) {
+  if (t22.isImportDeclaration(forked)) {
     ir.imports.push(forked);
-  } else if (t17.isExportDeclaration(forked)) {
+  } else if (t22.isExportDeclaration(forked)) {
     ir.exports.push(forked);
   }
   path9.remove();
@@ -2146,7 +2708,7 @@ function resolveASTChunks(ctx, ast) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/postprocess/resolve-runtime-imports/index.ts
-import * as t18 from "@babel/types";
+import * as t23 from "@babel/types";
 
 // src/core/transform/shared.ts
 function recordImport(ctx, pkg, name, onDemand = true) {
@@ -2306,7 +2868,7 @@ function resolveRuntimeImports(ctx) {
           } else if (finalModuleName === PACKAGE_NAME.react) {
             path9.insertAfter(importNodes);
           } else {
-            forkLeadingComments(importNodes[0], node);
+            forkFilePreambleLeadingComments(importNodes[0], node);
             path9.insertBefore(importNodes);
           }
         }
@@ -2321,7 +2883,7 @@ function resolveRuntimeImports(ctx) {
         const { node } = path9;
         const importNodes = createImportNodes(ctx);
         if (!importNodes.length) return;
-        forkLeadingComments(importNodes[0], node);
+        forkProgramTopLeadingComments(importNodes[0], node);
         path9.unshiftContainer("body", importNodes);
       }
     }
@@ -2334,10 +2896,10 @@ function mergeImports(currentNode, ctx, moduleName) {
   }
   const currentImports = /* @__PURE__ */ new Set();
   for (const spec of currentNode.specifiers) {
-    if (t18.isImportSpecifier(spec) && t18.isIdentifier(spec.imported)) {
+    if (t23.isImportSpecifier(spec) && t23.isIdentifier(spec.imported)) {
       currentImports.add(spec.imported.name);
     }
-    if (t18.isImportDefaultSpecifier(spec) && t18.isIdentifier(spec.local)) {
+    if (t23.isImportDefaultSpecifier(spec) && t23.isIdentifier(spec.local)) {
       currentImports.add(spec.local.name);
     }
   }
@@ -2345,8 +2907,8 @@ function mergeImports(currentNode, ctx, moduleName) {
     if (currentImports.has(item.name)) {
       continue;
     }
-    const local = t18.identifier(item.name);
-    const newNode = !item.onDemand ? t18.importDefaultSpecifier(local) : t18.importSpecifier(local, local);
+    const local = t23.identifier(item.name);
+    const newNode = !item.onDemand ? t23.importDefaultSpecifier(local) : t23.importSpecifier(local, local);
     currentNode.specifiers.push(newNode);
   }
   ctx.imports.delete(moduleName);
@@ -2355,10 +2917,10 @@ function createImportNodes(ctx) {
   const result = [];
   const importDeclarations = Array.from(ctx.imports).map(([moduleName, items]) => {
     const specifiers = items.map((item) => {
-      const local = t18.identifier(item.name);
-      return item.onDemand ? t18.importSpecifier(local, local) : t18.importDefaultSpecifier(local);
+      const local = t23.identifier(item.name);
+      return item.onDemand ? t23.importSpecifier(local, local) : t23.importDefaultSpecifier(local);
     });
-    return t18.importDeclaration(specifiers, t18.stringLiteral(moduleName));
+    return t23.importDeclaration(specifiers, t23.stringLiteral(moduleName));
   });
   for (const decl of importDeclarations) {
     const name = decl.source.value;
@@ -2368,35 +2930,59 @@ function createImportNodes(ctx) {
       result.push(decl);
     }
   }
-  return result;
+  return result;
+}
+function forkProgramTopLeadingComments(target, program3) {
+  const [firstStatement] = program3.body;
+  if (!firstStatement) {
+    return;
+  }
+  forkFilePreambleLeadingComments(target, firstStatement);
 }
-function forkLeadingComments(target, source) {
+function forkFilePreambleLeadingComments(target, source) {
   const { leadingComments } = source;
   if (!leadingComments?.length) {
     return;
   }
-  const newComments = [...leadingComments];
-  source.leadingComments = null;
-  target.leadingComments = newComments;
+  const commentsToMove = [];
+  const remainingComments = [];
+  for (const comment of leadingComments) {
+    if (isFilePreambleComment(comment.value)) {
+      commentsToMove.push(comment);
+    } else {
+      remainingComments.push(comment);
+    }
+  }
+  if (!commentsToMove.length) {
+    return;
+  }
+  source.leadingComments = remainingComments.length ? remainingComments : null;
+  target.leadingComments = [...target.leadingComments ?? [], ...commentsToMove];
+}
+function isFilePreambleComment(commentValue) {
+  const value = commentValue.trim();
+  return /^(?:@ts-(?:nocheck|check)\b|eslint-(?:disable|enable|disable-next-line|env|global)\b|@jsx(?:ImportSource|Runtime)?\b|!)/.test(
+    value
+  );
 }
 
 // src/core/transform/sfc/script/syntax-processor/postprocess/resolve-sfc-css-import.ts
-import * as t19 from "@babel/types";
+import * as t24 from "@babel/types";
 function resolveSfcCssImport(ctx) {
   if (ctx.inputType !== "sfc") return;
   const scriptIR = getScriptIR(ctx);
   const { filePath, moduleName } = ctx.styleData;
   if (!filePath) return;
   const styleFilename = normalizePath(filePath).split("/").pop();
-  const importDecl = t19.importDeclaration(
-    !moduleName ? [] : [t19.importDefaultSpecifier(t19.identifier(moduleName))],
-    t19.stringLiteral(`./${styleFilename}`)
+  const importDecl = t24.importDeclaration(
+    !moduleName ? [] : [t24.importDefaultSpecifier(t24.identifier(moduleName))],
+    t24.stringLiteral(`./${styleFilename}`)
   );
   scriptIR.imports.push(importDecl);
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-async-component.ts
-import * as t20 from "@babel/types";
+import * as t25 from "@babel/types";
 function resolveDefineAsyncComponent(ctx) {
   return {
     CallExpression(path9) {
@@ -2412,11 +2998,11 @@ function resolveDefineAsyncComponent(ctx) {
   };
 }
 function checkIsUnsupported(ctx, arg) {
-  if (t20.isFunction(arg)) {
+  if (t25.isFunction(arg)) {
     checkIsDynamicImport(ctx, arg);
-  } else if (t20.isObjectExpression(arg)) {
+  } else if (t25.isObjectExpression(arg)) {
     const { value } = arg.properties.find(
-      (p) => t20.isObjectProperty(p) && t20.isIdentifier(p.key) && p.key.name === "loader"
+      (p) => t25.isObjectProperty(p) && t25.isIdentifier(p.key) && p.key.name === "loader"
     );
     checkIsDynamicImport(ctx, value);
     if (arg.properties.length > 1) {
@@ -2427,7 +3013,7 @@ function checkIsUnsupported(ctx, arg) {
 function checkIsDynamicImport(ctx, node) {
   const { scriptData, filename } = ctx;
   const warnIsNotImport = (target) => {
-    if (!target || !t20.isImport(target)) {
+    if (!target || !t25.isImport(target)) {
       logger.error(
         `Only ES module dynamic imports are supported. You must use and return import('...').`,
         {
@@ -2438,20 +3024,20 @@ function checkIsDynamicImport(ctx, node) {
       );
     }
   };
-  if (t20.isFunction(node)) {
+  if (t25.isFunction(node)) {
     checkIsDynamicImport(ctx, node.body);
     return;
   }
-  if (t20.isBlockStatement(node)) {
+  if (t25.isBlockStatement(node)) {
     const [returnSmt] = node.body;
-    if (t20.isReturnStatement(returnSmt)) {
+    if (t25.isReturnStatement(returnSmt)) {
       warnIsNotImport(returnSmt.argument);
     }
     return;
   }
-  if (t20.isCallExpression(node)) {
+  if (t25.isCallExpression(node)) {
     warnIsNotImport(node.callee);
-    if (t20.isStringLiteral(node.arguments[0])) {
+    if (t25.isStringLiteral(node.arguments[0])) {
       replaceVueSuffix(node.arguments[0]);
     }
     return;
@@ -2500,24 +3086,24 @@ function pushToGlobalScope(path9, ctx) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-expose.ts
-import * as t22 from "@babel/types";
+import * as t27 from "@babel/types";
 
 // src/core/transform/sfc/script/shared/hook-creator.ts
-import * as t21 from "@babel/types";
+import * as t26 from "@babel/types";
 function createUseCallback(body, deps) {
-  return t21.callExpression(t21.identifier(REACT_API_MAP.useCallback), [
+  return t26.callExpression(t26.identifier(REACT_API_MAP.useCallback), [
     body,
-    deps ?? t21.arrayExpression([])
+    deps ?? t26.arrayExpression([])
   ]);
 }
 function createUseMemo(body, deps) {
-  return t21.callExpression(t21.identifier(REACT_API_MAP.useMemo), [
-    t21.arrowFunctionExpression([], body),
-    deps ?? t21.arrayExpression([])
+  return t26.callExpression(t26.identifier(REACT_API_MAP.useMemo), [
+    t26.arrowFunctionExpression([], body),
+    deps ?? t26.arrayExpression([])
   ]);
 }
 function createUseImperativeHandle(refId, init) {
-  return t21.callExpression(t21.identifier(REACT_API_MAP.useImperativeHandle), [refId, init]);
+  return t26.callExpression(t26.identifier(REACT_API_MAP.useImperativeHandle), [refId, init]);
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-expose.ts
@@ -2538,24 +3124,23 @@ function resolveDefineExpose(ctx) {
       const adapter = ADAPTER_RULES.react[MACRO_API_NAMES.expose];
       recordImport(ctx, adapter.package, REACT_API_MAP.forwardRef);
       recordImport(ctx, adapter.package, adapter.target);
-      if (!t22.isObjectExpression(expose) && !t22.isFunction(expose)) {
+      if (!t27.isObjectExpression(expose) && !t27.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 init = !t27.isFunction(expose) ? t27.arrowFunctionExpression([], expose) : expose;
       const { forwardRef } = scriptData;
-      const newNode = createUseImperativeHandle(t22.identifier(forwardRef.refField), init);
+      const newNode = createUseImperativeHandle(t27.identifier(forwardRef.refField), init);
       forwardRef.enabled = true;
-      path9.replaceWith(newNode);
+      replaceNode(path9, newNode, node);
     }
   };
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-options.ts
-import * as t23 from "@babel/types";
 function resolveDefineOptions(ctx) {
   return {
     CallExpression(path9) {
@@ -2563,53 +3148,13 @@ function resolveDefineOptions(ctx) {
       if (!isCalleeNamed(node, MACRO_API_NAMES.options)) {
         return;
       }
-      const [options] = node.arguments;
-      const { filename, scriptData } = ctx;
-      if (!options) {
-        logger.warn("defineOptions was found, but no options were provided.", {
-          source: scriptData.source,
-          file: filename,
-          loc: node?.loc
-        });
-        path9.remove();
-        return;
-      }
-      if (!t23.isObjectExpression(options)) {
-        logger.warn("Argument for defineOptions must be an object expression.", {
-          source: scriptData.source,
-          file: filename,
-          loc: options?.loc
-        });
-      } else {
-        for (const prop of options.properties) {
-          if (!t23.isObjectProperty(prop) || !t23.isIdentifier(prop.key)) {
-            continue;
-          }
-          extractName(prop, ctx);
-        }
-      }
       path9.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: prop.key?.loc
-    });
-  }
-}
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-emit-calls.ts
-import * as t24 from "@babel/types";
+import * as t28 from "@babel/types";
 function resolveEmitCalls(ctx) {
   const formatEmitEventName = (raw) => {
     if (raw.startsWith("update:")) {
@@ -2623,7 +3168,7 @@ function resolveEmitCalls(ctx) {
     CallExpression(path9) {
       const { node } = path9;
       const { filename, templateData, scriptData } = ctx;
-      if (!t24.isIdentifier(node.callee)) return;
+      if (!t28.isIdentifier(node.callee)) return;
       const { name } = node.callee;
       const checkIfFromDefineEmits = () => {
         let result = false;
@@ -2635,7 +3180,7 @@ function resolveEmitCalls(ctx) {
           const binding = path9.scope.getBinding(name);
           if (binding) {
             const parent = binding.path.node;
-            if (t24.isVariableDeclarator(parent) && t24.isCallExpression(parent.init) && t24.isIdentifier(parent.init.callee)) {
+            if (t28.isVariableDeclarator(parent) && t28.isCallExpression(parent.init) && t28.isIdentifier(parent.init.callee)) {
               result = parent.init.callee.name === MACRO_API_NAMES.emits;
             }
           }
@@ -2644,7 +3189,7 @@ function resolveEmitCalls(ctx) {
       };
       if (!checkIfFromDefineEmits()) return;
       const [callee, ...args] = node.arguments;
-      const eventName = t24.isStringLiteral(callee) ? formatEmitEventName(callee.value) : void 0;
+      const eventName = t28.isStringLiteral(callee) ? formatEmitEventName(callee.value) : void 0;
       if (!eventName) {
         logger.warn(`Expected String type but got ${callee?.type}, expression will be removed`, {
           file: filename,
@@ -2654,46 +3199,46 @@ function resolveEmitCalls(ctx) {
         path9.remove();
         return;
       }
-      const propCall = t24.optionalCallExpression(
-        t24.optionalMemberExpression(
-          t24.identifier(ctx.propField),
-          t24.identifier(eventName),
+      const propCall = t28.optionalCallExpression(
+        t28.optionalMemberExpression(
+          t28.identifier(ctx.propField),
+          t28.identifier(eventName),
           false,
           true
         ),
         args,
         true
       );
-      path9.replaceWith(propCall);
+      replaceNode(path9, propCall, node);
     }
   };
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/index.ts
-import * as t29 from "@babel/types";
+import * as t36 from "@babel/types";
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-emits.ts
-import * as t26 from "@babel/types";
+import * as t30 from "@babel/types";
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/shared.ts
-import * as t25 from "@babel/types";
+import * as t29 from "@babel/types";
 function cloneCallableParams(params) {
   const cloneCallableParam = (param, index) => {
-    if (t25.isRestElement(param)) {
+    if (t29.isRestElement(param)) {
       const arg = param.argument;
-      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()));
+      const name = t29.isIdentifier(arg) ? arg.name : `args${index}`;
+      const rest = t29.restElement(t29.identifier(name));
+      rest.typeAnnotation = param.typeAnnotation || (t29.isIdentifier(arg) ? arg.typeAnnotation : null) || t29.tsTypeAnnotation(t29.tsArrayType(t29.tsAnyKeyword()));
       return rest;
     }
-    if (t25.isIdentifier(param)) {
-      const id = t25.identifier(param.name || `arg${index}`);
+    if (t29.isIdentifier(param)) {
+      const id = t29.identifier(param.name || `arg${index}`);
       id.optional = param.optional;
-      id.typeAnnotation = param.typeAnnotation || t25.tsTypeAnnotation(t25.tsAnyKeyword());
+      id.typeAnnotation = param.typeAnnotation || t29.tsTypeAnnotation(t29.tsAnyKeyword());
       return id;
     }
-    const fallback = t25.identifier(`arg${index}`);
-    fallback.typeAnnotation = t25.tsTypeAnnotation(t25.tsAnyKeyword());
+    const fallback = t29.identifier(`arg${index}`);
+    fallback.typeAnnotation = t29.tsTypeAnnotation(t29.tsAnyKeyword());
     return fallback;
   };
   return params.map(cloneCallableParam);
@@ -2703,18 +3248,18 @@ function cloneCallableParams(params) {
 function resolveEmitsTopLevelTypes(ctx) {
   return {
     "TSInterfaceDeclaration|TSTypeAliasDeclaration"(path9) {
-      if (!t26.isProgram(path9.parent)) return;
+      if (!t30.isProgram(path9.parent)) return;
       const { node } = path9;
-      if (t26.isTSInterfaceDeclaration(node)) {
-        const typeLiteral = t26.tsTypeLiteral(node.body.body);
+      if (t30.isTSInterfaceDeclaration(node)) {
+        const typeLiteral = t30.tsTypeLiteral(node.body.body);
         if (!hasEmitsSignatureInType(typeLiteral)) return;
         const resolved = resolveTopLevelEmitType(typeLiteral);
-        if (resolved && t26.isTSTypeLiteral(resolved)) {
+        if (resolved && t30.isTSTypeLiteral(resolved)) {
           node.body.body = resolved.members;
         }
         return;
       }
-      if (t26.isTSTypeAliasDeclaration(node)) {
+      if (t30.isTSTypeAliasDeclaration(node)) {
         if (!hasEmitsSignatureInType(node.typeAnnotation)) return;
         const resolved = resolveTopLevelEmitType(node.typeAnnotation);
         if (resolved) {
@@ -2725,47 +3270,47 @@ function resolveEmitsTopLevelTypes(ctx) {
   };
 }
 function resolveTopLevelEmitType(tsType) {
-  if (t26.isTSParenthesizedType(tsType)) {
+  if (t30.isTSParenthesizedType(tsType)) {
     return resolveTopLevelEmitType(tsType.typeAnnotation);
   }
-  if (t26.isTSTypeReference(tsType)) {
+  if (t30.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return tsType;
     }
     const params = tsType.typeParameters.params.map((param) => resolveTopLevelEmitType(param)).filter(Boolean);
-    return t26.tsTypeReference(
+    return t30.tsTypeReference(
       tsType.typeName,
-      t26.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
+      t30.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
     );
   }
-  if (t26.isTSIntersectionType(tsType)) {
+  if (t30.isTSIntersectionType(tsType)) {
     const types = tsType.types.map(resolveTopLevelEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t26.tsIntersectionType(types);
+    return t30.tsIntersectionType(types);
   }
-  if (t26.isTSUnionType(tsType)) {
+  if (t30.isTSUnionType(tsType)) {
     const types = tsType.types.map(resolveTopLevelEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t26.tsUnionType(types);
+    return t30.tsUnionType(types);
   }
-  if (t26.isTSTypeLiteral(tsType)) {
+  if (t30.isTSTypeLiteral(tsType)) {
     const members = [];
     for (const member of tsType.members) {
-      if (t26.isTSCallSignatureDeclaration(member)) {
+      if (t30.isTSCallSignatureDeclaration(member)) {
         members.push(...resolveEmitPropsFromCallSignature(member));
         continue;
       }
       members.push(member);
     }
     if (!members.length) return null;
-    return t26.tsTypeLiteral(members);
+    return t30.tsTypeLiteral(members);
   }
-  if (t26.isTSFunctionType(tsType)) {
+  if (t30.isTSFunctionType(tsType)) {
     const props = resolveEmitPropsFromCallable(tsType.parameters, tsType.typeAnnotation);
     if (!props.length) return null;
-    return t26.tsTypeLiteral(props);
+    return t30.tsTypeLiteral(props);
   }
   return tsType;
 }
@@ -2786,41 +3331,41 @@ function processInferredTypes(ctx, runtimeArg) {
     propsTSIface: { emitTypes }
   } = ctx.scriptData;
   const members = [];
-  if (t26.isArrayExpression(runtimeArg)) {
+  if (t30.isArrayExpression(runtimeArg)) {
     for (const element of runtimeArg.elements) {
-      if (!element || !t26.isStringLiteral(element)) continue;
+      if (!element || !t30.isStringLiteral(element)) continue;
       const handlerName = resolveEmitHandlerName(element.value);
       const key = buildKey(handlerName);
-      const fnType = t26.tsFunctionType(
+      const fnType = t30.tsFunctionType(
         null,
         [createRestAnyParam("args")],
-        t26.tsTypeAnnotation(t26.tsAnyKeyword())
+        t30.tsTypeAnnotation(t30.tsAnyKeyword())
       );
-      const prop = t26.tsPropertySignature(key, t26.tsTypeAnnotation(fnType));
+      const prop = t30.tsPropertySignature(key, t30.tsTypeAnnotation(fnType));
       prop.optional = true;
       members.push(prop);
     }
     if (members.length) {
-      emitTypes.push(t26.tsTypeLiteral(members));
+      emitTypes.push(t30.tsTypeLiteral(members));
     }
     return;
   }
-  if (t26.isObjectExpression(runtimeArg)) {
+  if (t30.isObjectExpression(runtimeArg)) {
     for (const prop of runtimeArg.properties) {
-      if (!t26.isObjectProperty(prop)) continue;
-      if (t26.isSpreadElement(prop)) continue;
+      if (!t30.isObjectProperty(prop)) continue;
+      if (t30.isSpreadElement(prop)) continue;
       const rawName = resolvePropName(prop.key);
       if (!rawName) continue;
       const handlerName = resolveEmitHandlerName(rawName);
       const key = buildKey(handlerName);
-      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));
+      const params = t30.isArrayExpression(prop.value) ? resolveRuntimeTupleParams(prop.value) : [createRestAnyParam("args")];
+      const fnType = t30.tsFunctionType(null, params, t30.tsTypeAnnotation(t30.tsAnyKeyword()));
+      const propSig = t30.tsPropertySignature(key, t30.tsTypeAnnotation(fnType));
       propSig.optional = true;
       members.push(propSig);
     }
     if (members.length) {
-      emitTypes.push(t26.tsTypeLiteral(members));
+      emitTypes.push(t30.tsTypeLiteral(members));
     }
   }
 }
@@ -2841,129 +3386,129 @@ function resolveEmitHandlerName(rawName) {
   return `on${name}`;
 }
 function resolvePropName(key) {
-  if (t26.isIdentifier(key)) return key.name;
-  if (t26.isStringLiteral(key)) return key.value;
-  if (t26.isNumericLiteral(key)) return String(key.value);
+  if (t30.isIdentifier(key)) return key.name;
+  if (t30.isStringLiteral(key)) return key.value;
+  if (t30.isNumericLiteral(key)) return String(key.value);
   return null;
 }
 function buildKey(name) {
-  return t26.isValidIdentifier(name) ? t26.identifier(name) : t26.stringLiteral(name);
+  return t30.isValidIdentifier(name) ? t30.identifier(name) : t30.stringLiteral(name);
 }
 function createRestAnyParam(name) {
-  const id = t26.identifier(name);
-  const rest = t26.restElement(id);
-  rest.typeAnnotation = t26.tsTypeAnnotation(t26.tsArrayType(t26.tsAnyKeyword()));
+  const id = t30.identifier(name);
+  const rest = t30.restElement(id);
+  rest.typeAnnotation = t30.tsTypeAnnotation(t30.tsArrayType(t30.tsAnyKeyword()));
   return rest;
 }
 function resolveRuntimeTupleParams(value) {
   const params = [];
   value.elements.forEach((element, index) => {
     if (!element) return;
-    if (t26.isSpreadElement(element)) {
+    if (t30.isSpreadElement(element)) {
       params.push(createRestAnyParam(`args${index}`));
       return;
     }
-    if (t26.isIdentifier(element)) {
-      const id = t26.identifier(element.name);
-      id.typeAnnotation = element.typeAnnotation || t26.tsTypeAnnotation(t26.tsAnyKeyword());
+    if (t30.isIdentifier(element)) {
+      const id = t30.identifier(element.name);
+      id.typeAnnotation = element.typeAnnotation || t30.tsTypeAnnotation(t30.tsAnyKeyword());
       params.push(id);
       return;
     }
-    if (t26.isTSAsExpression(element)) {
-      const id = t26.identifier(`arg${index}`);
-      id.typeAnnotation = t26.tsTypeAnnotation(element.typeAnnotation);
+    if (t30.isTSAsExpression(element)) {
+      const id = t30.identifier(`arg${index}`);
+      id.typeAnnotation = t30.tsTypeAnnotation(element.typeAnnotation);
       params.push(id);
       return;
     }
-    const fallback = t26.identifier(`arg${index}`);
-    fallback.typeAnnotation = t26.tsTypeAnnotation(t26.tsAnyKeyword());
+    const fallback = t30.identifier(`arg${index}`);
+    fallback.typeAnnotation = t30.tsTypeAnnotation(t30.tsAnyKeyword());
     params.push(fallback);
   });
   return params;
 }
 function resolveExplicitEmitType(tsType) {
-  if (t26.isTSParenthesizedType(tsType)) {
+  if (t30.isTSParenthesizedType(tsType)) {
     return resolveExplicitEmitType(tsType.typeAnnotation);
   }
-  if (t26.isTSTypeReference(tsType)) {
+  if (t30.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return tsType;
     }
     const params = tsType.typeParameters.params.map((param) => resolveExplicitEmitType(param)).filter(Boolean);
-    return t26.tsTypeReference(
+    return t30.tsTypeReference(
       tsType.typeName,
-      t26.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
+      t30.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
     );
   }
-  if (t26.isTSIntersectionType(tsType)) {
+  if (t30.isTSIntersectionType(tsType)) {
     const types = tsType.types.map(resolveExplicitEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t26.tsIntersectionType(types);
+    return t30.tsIntersectionType(types);
   }
-  if (t26.isTSUnionType(tsType)) {
+  if (t30.isTSUnionType(tsType)) {
     const types = tsType.types.map(resolveExplicitEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t26.tsUnionType(types);
+    return t30.tsUnionType(types);
   }
-  if (t26.isTSTypeLiteral(tsType)) {
+  if (t30.isTSTypeLiteral(tsType)) {
     const members = [];
     for (const member of tsType.members) {
-      if (t26.isTSPropertySignature(member)) {
+      if (t30.isTSPropertySignature(member)) {
         const prop = resolveEmitPropFromPropertySignature(member);
         if (prop) members.push(prop);
         continue;
       }
-      if (t26.isTSCallSignatureDeclaration(member)) {
+      if (t30.isTSCallSignatureDeclaration(member)) {
         members.push(...resolveEmitPropsFromCallSignature(member));
         continue;
       }
     }
     if (!members.length) return null;
-    return t26.tsTypeLiteral(members);
+    return t30.tsTypeLiteral(members);
   }
-  if (t26.isTSFunctionType(tsType)) {
+  if (t30.isTSFunctionType(tsType)) {
     const props = resolveEmitPropsFromCallable(tsType.parameters, tsType.typeAnnotation);
     if (!props.length) return null;
-    return t26.tsTypeLiteral(props);
+    return t30.tsTypeLiteral(props);
   }
   return tsType;
 }
 function hasEmitsSignatureInType(tsType) {
-  if (t26.isTSParenthesizedType(tsType)) {
+  if (t30.isTSParenthesizedType(tsType)) {
     return hasEmitsSignatureInType(tsType.typeAnnotation);
   }
-  if (t26.isTSTypeReference(tsType)) {
+  if (t30.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return false;
     }
     return tsType.typeParameters.params.some(hasEmitsSignatureInType);
   }
-  if (t26.isTSIntersectionType(tsType) || t26.isTSUnionType(tsType)) {
+  if (t30.isTSIntersectionType(tsType) || t30.isTSUnionType(tsType)) {
     return tsType.types.some(hasEmitsSignatureInType);
   }
-  if (t26.isTSTypeLiteral(tsType)) {
+  if (t30.isTSTypeLiteral(tsType)) {
     return tsType.members.some(hasEmitsSignatureInMember);
   }
-  if (t26.isTSFunctionType(tsType)) {
+  if (t30.isTSFunctionType(tsType)) {
     return isEmitsCallable(tsType.parameters);
   }
   return false;
 }
 function hasEmitsSignatureInMember(member) {
-  if (t26.isTSCallSignatureDeclaration(member)) {
+  if (t30.isTSCallSignatureDeclaration(member)) {
     return isEmitsCallable(member.parameters);
   }
   return false;
 }
 function isEmitsCallable(parameters) {
   const [eventParam] = parameters;
-  if (!eventParam || !t26.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
+  if (!eventParam || !t30.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
     return false;
   }
   const { typeAnnotation } = eventParam;
-  if (t26.isNoop(typeAnnotation)) return false;
+  if (t30.isNoop(typeAnnotation)) return false;
   return resolveEventNames(typeAnnotation.typeAnnotation).length > 0;
 }
 function resolveEmitPropFromPropertySignature(member) {
@@ -2973,19 +3518,19 @@ function resolveEmitPropFromPropertySignature(member) {
   const key = buildKey(handlerName);
   const typeAnnotation = member.typeAnnotation?.typeAnnotation;
   let params = [];
-  let returnType = t26.tsAnyKeyword();
-  if (typeAnnotation && t26.isTSFunctionType(typeAnnotation)) {
+  let returnType = t30.tsAnyKeyword();
+  if (typeAnnotation && t30.isTSFunctionType(typeAnnotation)) {
     params = cloneCallableParams(typeAnnotation.parameters);
     returnType = typeAnnotation.typeAnnotation?.typeAnnotation ?? returnType;
-  } else if (typeAnnotation && t26.isTSTupleType(typeAnnotation)) {
+  } else if (typeAnnotation && t30.isTSTupleType(typeAnnotation)) {
     params = resolveTupleTypeParams(typeAnnotation);
   } else if (typeAnnotation) {
-    const id = t26.identifier("value");
-    id.typeAnnotation = t26.tsTypeAnnotation(typeAnnotation);
+    const id = t30.identifier("value");
+    id.typeAnnotation = t30.tsTypeAnnotation(typeAnnotation);
     params = [id];
   }
-  const fnType = t26.tsFunctionType(null, params, t26.tsTypeAnnotation(returnType));
-  const prop = t26.tsPropertySignature(key, t26.tsTypeAnnotation(fnType));
+  const fnType = t30.tsFunctionType(null, params, t30.tsTypeAnnotation(returnType));
+  const prop = t30.tsPropertySignature(key, t30.tsTypeAnnotation(fnType));
   prop.optional = !!member.optional;
   return prop;
 }
@@ -2994,32 +3539,32 @@ function resolveEmitPropsFromCallSignature(member) {
 }
 function resolveEmitPropsFromCallable(parameters, typeAnnotation) {
   const [eventParam, ...restParams] = parameters;
-  if (!eventParam || !t26.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
+  if (!eventParam || !t30.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
     return [];
   }
   const { typeAnnotation: paramTypeAnnotation } = eventParam;
-  if (t26.isNoop(paramTypeAnnotation)) return [];
+  if (t30.isNoop(paramTypeAnnotation)) return [];
   const eventNames = resolveEventNames(paramTypeAnnotation.typeAnnotation);
   if (!eventNames.length) return [];
-  const returnType = typeAnnotation?.typeAnnotation ?? t26.tsAnyKeyword();
+  const returnType = typeAnnotation?.typeAnnotation ?? t30.tsAnyKeyword();
   return eventNames.map((eventName) => {
     const handlerName = resolveEmitHandlerName(eventName);
     const key = buildKey(handlerName);
     const params = cloneCallableParams(restParams);
-    const fnType = t26.tsFunctionType(null, params, t26.tsTypeAnnotation(returnType));
-    const prop = t26.tsPropertySignature(key, t26.tsTypeAnnotation(fnType));
+    const fnType = t30.tsFunctionType(null, params, t30.tsTypeAnnotation(returnType));
+    const prop = t30.tsPropertySignature(key, t30.tsTypeAnnotation(fnType));
     prop.optional = true;
     return prop;
   });
 }
 function resolveEventNames(type) {
-  if (t26.isTSLiteralType(type) && t26.isStringLiteral(type.literal)) {
+  if (t30.isTSLiteralType(type) && t30.isStringLiteral(type.literal)) {
     return [type.literal.value];
   }
-  if (t26.isTSUnionType(type)) {
+  if (t30.isTSUnionType(type)) {
     return type.types.flatMap(resolveEventNames);
   }
-  if (t26.isTSParenthesizedType(type)) {
+  if (t30.isTSParenthesizedType(type)) {
     return resolveEventNames(type.typeAnnotation);
   }
   return [];
@@ -3032,44 +3577,44 @@ function resolveTupleTypeParams(tuple) {
   return params;
 }
 function resolveTupleElementParam(element, index) {
-  const isNamedTuple = typeof t26.isTSNamedTupleMember === "function" && t26.isTSNamedTupleMember(element);
+  const isNamedTuple = typeof t30.isTSNamedTupleMember === "function" && t30.isTSNamedTupleMember(element);
   if (isNamedTuple) {
     const tupleMember = element;
     const name = tupleMember.label?.name || `arg${index}`;
     let innerType = tupleMember.elementType;
     let optional = tupleMember.optional;
-    if (t26.isTSOptionalType(innerType)) {
+    if (t30.isTSOptionalType(innerType)) {
       optional = true;
       innerType = innerType.typeAnnotation;
     }
-    if (t26.isTSRestType(innerType)) {
-      const rest = t26.restElement(t26.identifier(name));
-      rest.typeAnnotation = t26.tsTypeAnnotation(innerType.typeAnnotation);
+    if (t30.isTSRestType(innerType)) {
+      const rest = t30.restElement(t30.identifier(name));
+      rest.typeAnnotation = t30.tsTypeAnnotation(innerType.typeAnnotation);
       return rest;
     }
-    const id2 = t26.identifier(name);
+    const id2 = t30.identifier(name);
     id2.optional = optional;
-    id2.typeAnnotation = t26.tsTypeAnnotation(innerType);
+    id2.typeAnnotation = t30.tsTypeAnnotation(innerType);
     return id2;
   }
-  if (t26.isTSRestType(element)) {
-    const rest = t26.restElement(t26.identifier(`args${index}`));
-    rest.typeAnnotation = t26.tsTypeAnnotation(element.typeAnnotation);
+  if (t30.isTSRestType(element)) {
+    const rest = t30.restElement(t30.identifier(`args${index}`));
+    rest.typeAnnotation = t30.tsTypeAnnotation(element.typeAnnotation);
     return rest;
   }
-  if (t26.isTSOptionalType(element)) {
-    const id2 = t26.identifier(`arg${index}`);
+  if (t30.isTSOptionalType(element)) {
+    const id2 = t30.identifier(`arg${index}`);
     id2.optional = true;
-    id2.typeAnnotation = t26.tsTypeAnnotation(element.typeAnnotation);
+    id2.typeAnnotation = t30.tsTypeAnnotation(element.typeAnnotation);
     return id2;
   }
-  const id = t26.identifier(`arg${index}`);
-  id.typeAnnotation = t26.tsTypeAnnotation(element);
+  const id = t30.identifier(`arg${index}`);
+  id.typeAnnotation = t30.tsTypeAnnotation(element);
   return id;
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-props.ts
-import * as t27 from "@babel/types";
+import * as t31 from "@babel/types";
 function resolveDefinePropsIface(path9, ctx) {
   const { node } = path9;
   const [runtimeArg] = node.arguments;
@@ -3089,38 +3634,38 @@ function processInferredTypes2(ctx, runtimeArg) {
   } = scriptData;
   if (!runtimeArg) return;
   const members = [];
-  if (t27.isArrayExpression(runtimeArg)) {
+  if (t31.isArrayExpression(runtimeArg)) {
     for (const element of runtimeArg.elements) {
-      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()));
+      if (!element || !t31.isStringLiteral(element)) continue;
+      const key = t31.isValidIdentifier(element.value) ? t31.identifier(element.value) : t31.stringLiteral(element.value);
+      const prop = t31.tsPropertySignature(key, t31.tsTypeAnnotation(t31.tsAnyKeyword()));
       prop.optional = true;
       members.push(prop);
     }
     if (members.length) {
-      propsTypes.push(t27.tsTypeLiteral(members));
+      propsTypes.push(t31.tsTypeLiteral(members));
     }
     return;
   }
-  if (t27.isObjectExpression(runtimeArg)) {
+  if (t31.isObjectExpression(runtimeArg)) {
     for (const prop of runtimeArg.properties) {
-      if (!t27.isObjectProperty(prop)) continue;
-      if (t27.isSpreadElement(prop)) continue;
+      if (!t31.isObjectProperty(prop)) continue;
+      if (t31.isSpreadElement(prop)) continue;
       const key = prop.key;
       let propName = null;
-      if (t27.isIdentifier(key)) propName = key.name;
-      if (t27.isStringLiteral(key)) propName = key.value;
-      if (t27.isNumericLiteral(key)) propName = String(key.value);
+      if (t31.isIdentifier(key)) propName = key.name;
+      if (t31.isStringLiteral(key)) propName = key.value;
+      if (t31.isNumericLiteral(key)) propName = String(key.value);
       if (!propName) continue;
       const { type, required } = resolveRuntimePropMeta(prop.value);
-      const tsType = type ?? t27.tsAnyKeyword();
-      const tsKey = t27.isValidIdentifier(propName) ? t27.identifier(propName) : t27.stringLiteral(propName);
-      const tsProp = t27.tsPropertySignature(tsKey, t27.tsTypeAnnotation(tsType));
+      const tsType = type ?? t31.tsAnyKeyword();
+      const tsKey = t31.isValidIdentifier(propName) ? t31.identifier(propName) : t31.stringLiteral(propName);
+      const tsProp = t31.tsPropertySignature(tsKey, t31.tsTypeAnnotation(tsType));
       tsProp.optional = !required;
       members.push(tsProp);
     }
     if (members.length) {
-      propsTypes.push(t27.tsTypeLiteral(members));
+      propsTypes.push(t31.tsTypeLiteral(members));
     }
     return;
   }
@@ -3134,42 +3679,42 @@ function processInferredTypes2(ctx, runtimeArg) {
   );
 }
 function resolveRuntimePropMeta(value) {
-  if (t27.isIdentifier(value)) {
+  if (t31.isIdentifier(value)) {
     return {
       type: mapRuntimeTypeToTSType(value),
       required: false
     };
   }
-  if (t27.isArrayExpression(value)) {
+  if (t31.isArrayExpression(value)) {
     return {
       type: resolveRuntimeUnionType(value),
       required: false
     };
   }
-  if (!t27.isObjectExpression(value)) {
+  if (!t31.isObjectExpression(value)) {
     return { required: false };
   }
   let type;
   let required = false;
   for (const prop of value.properties) {
-    if (!t27.isObjectProperty(prop)) continue;
-    if (t27.isSpreadElement(prop)) continue;
+    if (!t31.isObjectProperty(prop)) continue;
+    if (t31.isSpreadElement(prop)) continue;
     const key = prop.key;
-    const propName = t27.isIdentifier(key) ? key.name : t27.isStringLiteral(key) ? key.value : null;
+    const propName = t31.isIdentifier(key) ? key.name : t31.isStringLiteral(key) ? key.value : null;
     if (!propName) continue;
     if (propName === "type") {
       const valueNode = prop.value;
-      if (t27.isArrayExpression(valueNode)) {
+      if (t31.isArrayExpression(valueNode)) {
         type = resolveRuntimeUnionType(valueNode);
         continue;
       }
-      if (t27.isIdentifier(valueNode)) {
+      if (t31.isIdentifier(valueNode)) {
         type = mapRuntimeTypeToTSType(valueNode);
         continue;
       }
     }
     if (propName === "required") {
-      if (t27.isBooleanLiteral(prop.value)) {
+      if (t31.isBooleanLiteral(prop.value)) {
         required = prop.value.value;
       }
     }
@@ -3179,257 +3724,403 @@ function resolveRuntimePropMeta(value) {
 function resolveRuntimeUnionType(value) {
   const types = [];
   for (const element of value.elements) {
-    if (!element || !t27.isIdentifier(element)) continue;
+    if (!element || !t31.isIdentifier(element)) continue;
     const resolved = mapRuntimeTypeToTSType(element);
     if (resolved) types.push(resolved);
   }
-  if (!types.length) return t27.tsAnyKeyword();
+  if (!types.length) return t31.tsAnyKeyword();
   if (types.length === 1) return types[0];
-  return t27.tsUnionType(types);
+  return t31.tsUnionType(types);
 }
 function mapRuntimeTypeToTSType(value) {
   switch (value.name) {
     case "String":
-      return t27.tsStringKeyword();
+      return t31.tsStringKeyword();
     case "Number":
-      return t27.tsNumberKeyword();
+      return t31.tsNumberKeyword();
     case "Boolean":
-      return t27.tsBooleanKeyword();
+      return t31.tsBooleanKeyword();
     case "Object":
-      return t27.tsTypeLiteral([]);
+      return t31.tsTypeLiteral([]);
     case "Array":
-      return t27.tsArrayType(t27.tsAnyKeyword());
+      return t31.tsArrayType(t31.tsAnyKeyword());
     case "Function":
-      return t27.tsFunctionType(null, [], t27.tsTypeAnnotation(t27.tsAnyKeyword()));
+      return t31.tsFunctionType(null, [], t31.tsTypeAnnotation(t31.tsAnyKeyword()));
     case "Symbol":
-      return t27.tsSymbolKeyword();
+      return t31.tsSymbolKeyword();
     case "BigInt":
-      return t27.tsBigIntKeyword();
+      return t31.tsBigIntKeyword();
     default:
-      return t27.tsAnyKeyword();
+      return t31.tsAnyKeyword();
   }
 }
 
-// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot.ts
-import * as t28 from "@babel/types";
+// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/type-resolver.ts
+import * as t34 from "@babel/types";
+
+// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/slot-builder.ts
+import * as t32 from "@babel/types";
 var SLOT_DEFAULT_NAME = "default";
 var SLOT_CHILDREN_NAME = "children";
 var SLOT_FN_PARAM_NAME = "props";
-function resolveSlotsTopLevelTypes(ctx) {
-  if (ctx.inputType !== "sfc") {
-    return {};
-  }
-  return {
-    "TSInterfaceDeclaration|TSTypeAliasDeclaration"(path9) {
-      if (!t28.isProgram(path9.parent)) return;
-      const { node } = path9;
-      if (t28.isTSInterfaceDeclaration(node)) {
-        const typeLiteral = t28.tsTypeLiteral(node.body.body);
-        if (!hasSlotsSignatureInType(typeLiteral)) return;
-        const resolved = resolveSlotType(typeLiteral);
-        if (resolved && t28.isTSTypeLiteral(resolved)) {
-          node.body.body = resolved.members;
-          recordReactNode(ctx);
-        }
-        return;
-      }
-      if (t28.isTSTypeAliasDeclaration(node)) {
-        if (!hasSlotsSignatureInType(node.typeAnnotation)) return;
-        const resolved = resolveSlotType(node.typeAnnotation);
-        if (resolved) {
-          node.typeAnnotation = resolved;
-          recordReactNode(ctx);
-        }
-      }
-    }
-  };
-}
-function resolveDefineSlotsIface(path9, ctx) {
-  const { node } = path9;
-  const tsParams = node.typeParameters?.params;
-  if (!tsParams?.length) return;
-  const {
-    propsTSIface: { slotTypes }
-  } = ctx.scriptData;
-  for (const tsType of tsParams) {
-    const resolved = resolveSlotType(tsType);
-    if (resolved) {
-      slotTypes.push(resolved);
-    }
-  }
-  if (slotTypes.length) {
-    recordReactNode(ctx);
+function buildSlotPropSignature(rawName, params, optional) {
+  const propName = rawName === SLOT_DEFAULT_NAME ? SLOT_CHILDREN_NAME : rawName;
+  const key = t32.isValidIdentifier(propName) ? t32.identifier(propName) : t32.stringLiteral(propName);
+  const reactNodeType = t32.tsTypeAnnotation(
+    t32.tsTypeReference(t32.identifier(REACT_API_MAP.ReactNode))
+  );
+  let typeAnnotation;
+  if (rawName === SLOT_DEFAULT_NAME && params.length === 0 || params.length === 0) {
+    typeAnnotation = reactNodeType;
+  } else {
+    const fnType = t32.tsFunctionType(null, params, reactNodeType);
+    typeAnnotation = t32.tsTypeAnnotation(fnType);
   }
+  const prop = t32.tsPropertySignature(key, typeAnnotation);
+  prop.optional = optional;
+  return prop;
 }
-function resolveTemplateSlotIface(ctx) {
-  if (ctx.inputType !== "sfc") return;
-  const {
-    propsTSIface: { slotTypes }
-  } = ctx.scriptData;
-  if (slotTypes.length) return;
-  const { slots } = ctx.templateData;
-  const tsMembers = [];
-  for (const name in slots) {
-    const slotObj = slots[name];
-    if (!slotObj) continue;
-    const params = slotObj.isScope ? [createSlotScopeParam(slotObj.props, ctx)] : [];
-    const tsNode = buildSlotPropSignature(slotObj.name, params, true);
-    tsMembers.push(tsNode);
-  }
-  if (tsMembers.length) {
-    recordReactNode(ctx);
-    slotTypes.push(t28.tsTypeLiteral(tsMembers));
-  }
+function createSlotScopeParam(props, ctx) {
+  const paramId = t32.identifier(SLOT_FN_PARAM_NAME);
+  const propsSigns = [];
+  const { reactiveBindings } = ctx.templateData;
+  props.forEach(({ prop, tsType }) => {
+    const foundBindingValue = reactiveBindings[prop]?.value;
+    const foundBindingTypes = foundBindingValue ? expressionToTSType(foundBindingValue) : null;
+    const typeAnnotation = foundBindingTypes ? t32.tsTypeAnnotation(foundBindingTypes) : tsType;
+    const key = t32.isValidIdentifier(prop) ? t32.identifier(prop) : t32.stringLiteral(prop);
+    const propSign = t32.tsPropertySignature(key, typeAnnotation);
+    propsSigns.push(propSign);
+  });
+  paramId.typeAnnotation = t32.tsTypeAnnotation(t32.tsTypeLiteral(propsSigns));
+  return paramId;
 }
+
+// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/utils.ts
+import * as t33 from "@babel/types";
 function recordReactNode(ctx) {
   if (!ctx.scriptData.lang.startsWith("ts")) {
     return;
   }
   recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.ReactNode);
 }
-function resolveSlotType(tsType) {
-  if (t28.isTSParenthesizedType(tsType)) {
-    return resolveSlotType(tsType.typeAnnotation);
-  }
-  if (t28.isTSTypeReference(tsType)) {
-    if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
-      return tsType;
+function collectLocalTypeDeclarations(path9) {
+  const declarations = /* @__PURE__ */ new Map();
+  const programPath = path9.findParent(
+    (parentPath) => parentPath.isProgram()
+  );
+  if (!programPath) {
+    return declarations;
+  }
+  for (const statement of programPath.node.body) {
+    if (t33.isTSInterfaceDeclaration(statement)) {
+      declarations.set(statement.id.name, {
+        type: t33.tsTypeLiteral(statement.body.body),
+        // 将接口体转换为类型字面量
+        hasTypeParameters: !!statement.typeParameters?.params.length
+        // 检查是否有泛型参数
+      });
+      continue;
     }
-    const params = tsType.typeParameters.params.map((param) => resolveSlotType(param)).filter(Boolean);
-    return t28.tsTypeReference(
-      tsType.typeName,
-      t28.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
-    );
-  }
-  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 t28.tsIntersectionType(types);
-  }
-  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 t28.tsUnionType(types);
-  }
-  if (t28.isTSTypeLiteral(tsType)) {
-    const members = [];
-    for (const member of tsType.members) {
-      const resolved = resolveSlotPropFromMember(member);
-      if (resolved) {
-        members.push(resolved);
-        continue;
+    if (t33.isTSTypeAliasDeclaration(statement)) {
+      declarations.set(statement.id.name, {
+        type: statement.typeAnnotation,
+        // 直接使用类型注解
+        hasTypeParameters: !!statement.typeParameters?.params.length
+        // 检查是否有泛型参数
+      });
+      continue;
+    }
+    if (t33.isExportNamedDeclaration(statement) && statement.declaration) {
+      const declaration = statement.declaration;
+      if (t33.isTSInterfaceDeclaration(declaration)) {
+        declarations.set(declaration.id.name, {
+          type: t33.tsTypeLiteral(declaration.body.body),
+          // 将接口体转换为类型字面量
+          hasTypeParameters: !!declaration.typeParameters?.params.length
+          // 检查是否有泛型参数
+        });
+      } else if (t33.isTSTypeAliasDeclaration(declaration)) {
+        declarations.set(declaration.id.name, {
+          type: declaration.typeAnnotation,
+          // 直接使用类型注解
+          hasTypeParameters: !!declaration.typeParameters?.params.length
+          // 检查是否有泛型参数
+        });
       }
-      members.push(member);
     }
-    if (!members.length) return null;
-    return t28.tsTypeLiteral(members);
   }
-  if (t28.isTSFunctionType(tsType)) {
-    const props = buildSlotPropSignature(
-      SLOT_DEFAULT_NAME,
-      cloneCallableParams(tsType.parameters),
-      false
-    );
-    return t28.tsTypeLiteral([props]);
+  return declarations;
+}
+function resolvePropName2(key) {
+  if (t33.isIdentifier(key)) {
+    return key.name;
   }
-  return tsType;
+  if (t33.isStringLiteral(key)) {
+    return key.value;
+  }
+  if (t33.isNumericLiteral(key)) {
+    return String(key.value);
+  }
+  return null;
 }
-function hasSlotsSignatureInType(tsType) {
-  if (t28.isTSParenthesizedType(tsType)) {
-    return hasSlotsSignatureInType(tsType.typeAnnotation);
+function resolveCallableType(tsType) {
+  if (t33.isTSFunctionType(tsType)) {
+    return tsType;
   }
-  if (t28.isTSTypeReference(tsType)) {
-    if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
-      return false;
+  if (t33.isTSParenthesizedType(tsType)) {
+    return resolveCallableType(tsType.typeAnnotation);
+  }
+  return null;
+}
+
+// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/type-resolver.ts
+var SLOT_DEFAULT_NAME2 = "default";
+function resolveSlotType(tsType, options) {
+  if (t34.isTSParenthesizedType(tsType)) {
+    return resolveSlotType(tsType.typeAnnotation, options);
+  }
+  if (t34.isTSTypeReference(tsType)) {
+    let shouldRecordReactNode = false;
+    if (tsType.typeParameters?.params.length) {
+      const params = [];
+      for (const param of tsType.typeParameters.params) {
+        const resolved2 = resolveSlotType(param, options);
+        shouldRecordReactNode = shouldRecordReactNode || resolved2.shouldRecordReactNode;
+        params.push(resolved2.type || param);
+      }
+      if (!shouldRecordReactNode) {
+        return {
+          type: tsType,
+          shouldRecordReactNode: false
+        };
+      }
+      return {
+        type: t34.tsTypeReference(tsType.typeName, t34.tsTypeParameterInstantiation(params)),
+        shouldRecordReactNode
+      };
+    }
+    if (!t34.isIdentifier(tsType.typeName)) {
+      return {
+        type: tsType,
+        shouldRecordReactNode: false
+      };
+    }
+    const typeName = tsType.typeName.name;
+    const localDeclaration = options.localTypeDeclarations.get(typeName);
+    if (!localDeclaration || localDeclaration.hasTypeParameters) {
+      return {
+        type: tsType,
+        shouldRecordReactNode: false
+      };
+    }
+    if (options.visitedTypeNames.has(typeName)) {
+      return {
+        type: tsType,
+        shouldRecordReactNode: false
+      };
+    }
+    options.visitedTypeNames.add(typeName);
+    const resolved = resolveSlotType(localDeclaration.type, options);
+    options.visitedTypeNames.delete(typeName);
+    if (!resolved.shouldRecordReactNode) {
+      return {
+        type: tsType,
+        shouldRecordReactNode: false
+      };
     }
-    return tsType.typeParameters.params.some(hasSlotsSignatureInType);
+    return resolved;
   }
-  if (t28.isTSIntersectionType(tsType) || t28.isTSUnionType(tsType)) {
-    return tsType.types.some(hasSlotsSignatureInType);
+  if (t34.isTSIntersectionType(tsType)) {
+    const types = [];
+    let shouldRecordReactNode = false;
+    for (const item of tsType.types) {
+      const resolved = resolveSlotType(item, options);
+      shouldRecordReactNode = shouldRecordReactNode || resolved.shouldRecordReactNode;
+      if (resolved.type) {
+        types.push(resolved.type);
+      }
+    }
+    if (!types.length) {
+      return {
+        type: null,
+        shouldRecordReactNode
+      };
+    }
+    if (types.length === 1) {
+      return {
+        type: types[0],
+        shouldRecordReactNode
+      };
+    }
+    return {
+      type: t34.tsIntersectionType(types),
+      shouldRecordReactNode
+    };
   }
-  if (t28.isTSTypeLiteral(tsType)) {
-    return tsType.members.some(hasSlotsSignatureInMember);
+  if (t34.isTSUnionType(tsType)) {
+    const types = [];
+    let shouldRecordReactNode = false;
+    for (const item of tsType.types) {
+      const resolved = resolveSlotType(item, options);
+      shouldRecordReactNode = shouldRecordReactNode || resolved.shouldRecordReactNode;
+      if (resolved.type) {
+        types.push(resolved.type);
+      }
+    }
+    if (!types.length) {
+      return {
+        type: null,
+        shouldRecordReactNode
+      };
+    }
+    if (types.length === 1) {
+      return {
+        type: types[0],
+        shouldRecordReactNode
+      };
+    }
+    return {
+      type: t34.tsUnionType(types),
+      shouldRecordReactNode
+    };
   }
-  if (t28.isTSFunctionType(tsType)) {
-    return true;
+  if (t34.isTSTypeLiteral(tsType)) {
+    const members = [];
+    let shouldRecordReactNode = false;
+    for (const item of tsType.members) {
+      const resolved = resolveSlotPropFromMember(item);
+      shouldRecordReactNode = shouldRecordReactNode || resolved.shouldRecordReactNode;
+      members.push(resolved.member || item);
+    }
+    if (!members.length) {
+      return {
+        type: null,
+        shouldRecordReactNode
+      };
+    }
+    return {
+      type: t34.tsTypeLiteral(members),
+      shouldRecordReactNode
+    };
   }
-  return false;
-}
-function hasSlotsSignatureInMember(member) {
-  if (t28.isTSMethodSignature(member)) return true;
-  if (t28.isTSCallSignatureDeclaration(member)) return true;
-  if (t28.isTSPropertySignature(member)) {
-    const typeAnnotation = member.typeAnnotation?.typeAnnotation;
-    return !!(typeAnnotation && resolveCallableType(typeAnnotation));
+  if (t34.isTSFunctionType(tsType)) {
+    const props = buildSlotPropSignature(
+      SLOT_DEFAULT_NAME2,
+      cloneCallableParams(tsType.parameters),
+      false
+      // 默认插槽不是可选的
+    );
+    return {
+      type: t34.tsTypeLiteral([props]),
+      shouldRecordReactNode: true
+      // 函数类型总是需要记录 ReactNode
+    };
   }
-  return false;
+  return {
+    type: tsType,
+    shouldRecordReactNode: false
+  };
 }
 function resolveSlotPropFromMember(member) {
-  if (t28.isTSMethodSignature(member)) {
+  if (t34.isTSMethodSignature(member)) {
     const rawName = resolvePropName2(member.key);
-    if (!rawName) return null;
+    if (!rawName) {
+      return {
+        member: null,
+        shouldRecordReactNode: false
+      };
+    }
     const params = cloneCallableParams(member.parameters);
-    return buildSlotPropSignature(rawName, params, !!member.optional);
+    return {
+      member: buildSlotPropSignature(rawName, params, !!member.optional),
+      shouldRecordReactNode: true
+      // 方法签名总是可调用，需要记录 ReactNode
+    };
   }
-  if (t28.isTSPropertySignature(member)) {
+  if (t34.isTSPropertySignature(member)) {
     const rawName = resolvePropName2(member.key);
-    if (!rawName) return null;
+    if (!rawName) {
+      return {
+        member: null,
+        shouldRecordReactNode: false
+      };
+    }
     const typeAnnotation = member.typeAnnotation?.typeAnnotation;
     const callable = typeAnnotation ? resolveCallableType(typeAnnotation) : null;
-    if (!callable) return null;
+    if (!callable) {
+      return {
+        member: null,
+        shouldRecordReactNode: false
+      };
+    }
     const params = cloneCallableParams(callable.parameters);
-    return buildSlotPropSignature(rawName, params, !!member.optional);
+    return {
+      member: buildSlotPropSignature(rawName, params, !!member.optional),
+      shouldRecordReactNode: true
+      // 可调用属性需要记录 ReactNode
+    };
   }
-  if (t28.isTSCallSignatureDeclaration(member)) {
+  if (t34.isTSCallSignatureDeclaration(member)) {
     const params = cloneCallableParams(member.parameters);
-    return buildSlotPropSignature(SLOT_DEFAULT_NAME, params, true);
+    return {
+      member: buildSlotPropSignature(SLOT_DEFAULT_NAME2, params, true),
+      shouldRecordReactNode: true
+      // 调用签名总是可调用，需要记录 ReactNode
+    };
   }
-  return null;
-}
-function resolveCallableType(tsType) {
-  if (t28.isTSFunctionType(tsType)) return tsType;
-  if (t28.isTSParenthesizedType(tsType)) return resolveCallableType(tsType.typeAnnotation);
-  return null;
+  return {
+    member: null,
+    shouldRecordReactNode: false
+  };
 }
-function buildSlotPropSignature(rawName, params, optional) {
-  const propName = rawName === SLOT_DEFAULT_NAME ? SLOT_CHILDREN_NAME : rawName;
-  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 = t28.tsFunctionType(null, params, reactNodeType);
-    typeAnnotation = t28.tsTypeAnnotation(fnType);
+
+// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/define-slots.ts
+function resolveDefineSlotsIface(path9, ctx) {
+  const { node } = path9;
+  const tsParams = node.typeParameters?.params;
+  if (!tsParams?.length) return;
+  const {
+    propsTSIface: { slotTypes }
+  } = ctx.scriptData;
+  const localTypeDeclarations = collectLocalTypeDeclarations(path9);
+  let shouldRecordReactNode = false;
+  for (const tsType of tsParams) {
+    const { type: resolved, shouldRecordReactNode: needsReactNode } = resolveSlotType(tsType, {
+      localTypeDeclarations,
+      visitedTypeNames: /* @__PURE__ */ new Set()
+    });
+    if (resolved) {
+      slotTypes.push(resolved);
+      shouldRecordReactNode = shouldRecordReactNode || needsReactNode;
+    }
+  }
+  if (shouldRecordReactNode) {
+    recordReactNode(ctx);
   }
-  const prop = t28.tsPropertySignature(key, typeAnnotation);
-  prop.optional = optional;
-  return prop;
-}
-function createSlotScopeParam(props, ctx) {
-  const paramId = t28.identifier(SLOT_FN_PARAM_NAME);
-  const propsSigns = [];
-  const { reactiveBindings } = ctx.templateData;
-  props.forEach(({ prop, tsType }) => {
-    const foundBindingValue = reactiveBindings[prop]?.value;
-    const foundBindingTypes = foundBindingValue ? expressionToTSType(foundBindingValue) : null;
-    const typeAnnotation = foundBindingTypes ? t28.tsTypeAnnotation(foundBindingTypes) : tsType;
-    const key = t28.isValidIdentifier(prop) ? t28.identifier(prop) : t28.stringLiteral(prop);
-    const propSign = t28.tsPropertySignature(key, typeAnnotation);
-    propsSigns.push(propSign);
-  });
-  paramId.typeAnnotation = t28.tsTypeAnnotation(t28.tsTypeLiteral(propsSigns));
-  return paramId;
 }
-function resolvePropName2(key) {
-  if (t28.isIdentifier(key)) return key.name;
-  if (t28.isStringLiteral(key)) return key.value;
-  if (t28.isNumericLiteral(key)) return String(key.value);
-  return null;
+
+// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/template-slots.ts
+import * as t35 from "@babel/types";
+function resolveTemplateSlotIface(ctx) {
+  if (ctx.inputType !== "sfc") return;
+  const {
+    propsTSIface: { slotTypes }
+  } = ctx.scriptData;
+  if (slotTypes.length) return;
+  const { slots } = ctx.templateData;
+  const tsMembers = [];
+  for (const name in slots) {
+    const slotObj = slots[name];
+    if (!slotObj) continue;
+    const params = slotObj.isScope ? [createSlotScopeParam(slotObj.props, ctx)] : [];
+    const tsNode = buildSlotPropSignature(slotObj.name, params, true);
+    tsMembers.push(tsNode);
+  }
+  if (tsMembers.length) {
+    recordReactNode(ctx);
+    slotTypes.push(t35.tsTypeLiteral(tsMembers));
+  }
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/index.ts
@@ -3472,35 +4163,79 @@ function resolvePropsIface(ctx) {
   };
 }
 function resolveCompIProps(ctx, ast) {
-  const { propsTSIface, lang } = ctx.scriptData;
+  const { declaredOptions, propsTSIface, lang } = ctx.scriptData;
   const { propsTypes, emitTypes, slotTypes } = propsTSIface;
   const tsTypes = [...propsTypes, ...emitTypes, ...slotTypes];
   if (ctx.inputType !== "sfc" || !lang.startsWith("ts") || !tsTypes.length) {
     return;
   }
-  const n = ctx.compName || "Comp";
+  const n = declaredOptions.name || "Comp";
   const ns = `I${camelCase(capitalize(n))}Props`;
-  const typeNode = t29.tsIntersectionType(tsTypes);
-  const typeAliasDecl = t29.tsTypeAliasDeclaration(t29.identifier(ns), null, typeNode);
-  const exportDecl = t29.exportNamedDeclaration(typeAliasDecl);
+  const typeNode = t36.tsIntersectionType(tsTypes);
+  const typeAliasDecl = t36.tsTypeAliasDeclaration(t36.identifier(ns), null, typeNode);
+  const exportDecl = t36.exportNamedDeclaration(typeAliasDecl);
   propsTSIface.name = ns;
   const scriptIR = getScriptIR(ctx);
   scriptIR.exports.push(exportDecl);
   void ast;
 }
 
+// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-use-attrs.ts
+import * as t37 from "@babel/types";
+function resolveUseAttrs(ctx) {
+  return {
+    VariableDeclarator(path9) {
+      const { init, id } = path9.node;
+      if (!init) return;
+      const initPath = path9.get("init");
+      const propsIdentifier = t37.identifier(ctx.propField);
+      if (t37.isTSAsExpression(init) && isUseAttrsCall(init.expression)) {
+        const typeAssertion = createPropsTypeAssertion(propsIdentifier, init.typeAnnotation);
+        replaceNode(initPath, typeAssertion, init);
+        return;
+      }
+      if (!isUseAttrsCall(init)) {
+        return;
+      }
+      const isTS = ctx.scriptData.lang.startsWith("ts");
+      if (isTS) {
+        let typeAnnotation = null;
+        if (t37.isIdentifier(id) && t37.isTSTypeAnnotation(id.typeAnnotation)) {
+          typeAnnotation = id.typeAnnotation.typeAnnotation;
+          id.typeAnnotation = null;
+        } else {
+          typeAnnotation = t37.tsTypeReference(
+            t37.identifier("Record"),
+            t37.tsTypeParameterInstantiation([t37.tsStringKeyword(), t37.tsUnknownKeyword()])
+          );
+        }
+        const propsTypeAssertion = createPropsTypeAssertion(propsIdentifier, typeAnnotation);
+        replaceNode(initPath, propsTypeAssertion, propsIdentifier);
+        return;
+      }
+      replaceNode(initPath, propsIdentifier, init);
+    }
+  };
+}
+function isUseAttrsCall(expr) {
+  return t37.isCallExpression(expr) && isCalleeNamed(expr, VUE_API_MAP.useAttrs);
+}
+function createPropsTypeAssertion(propsIdentifier, typeAnnotation) {
+  return t37.tsAsExpression(propsIdentifier, typeAnnotation);
+}
+
 // src/core/transform/sfc/script/syntax-processor/process/resolve-analysis-only-adapter.ts
-import * as t31 from "@babel/types";
+import * as t39 from "@babel/types";
 
 // src/core/transform/sfc/script/shared/dependency-analyzer.ts
 import { traverse as traverse2 } from "@babel/core";
-import * as t30 from "@babel/types";
+import * as t38 from "@babel/types";
 var TRACE_MAX_DEPTH = 20;
 function analyzeDeps(node, ctx, parentPath) {
   if (!parentPath) {
-    return t30.arrayExpression([]);
+    return t38.arrayExpression([]);
   }
-  const isFnExpr = t30.isArrowFunctionExpression(node) || t30.isFunctionExpression(node);
+  const isFnExpr = t38.isArrowFunctionExpression(node) || t38.isFunctionExpression(node);
   const analyzeTarget = isFnExpr ? node.body : node;
   const bindingLocalBoundary = isFnExpr ? node : analyzeTarget;
   const reactiveStateApis = getReactiveStateApis();
@@ -3511,13 +4246,13 @@ function analyzeDeps(node, ctx, parentPath) {
   }
   const analyzeTargetPath = parentPath && parentPath.node === analyzeTarget ? parentPath : null;
   if (analyzeTargetPath) {
-    if (t30.isMemberExpression(analyzeTarget) || t30.isOptionalMemberExpression(analyzeTarget)) {
+    if (t38.isMemberExpression(analyzeTarget) || t38.isOptionalMemberExpression(analyzeTarget)) {
       const rootId = findRootIdentifier(analyzeTarget);
       if (rootId) {
         tryAddDependency(analyzeTargetPath, rootId.name, analyzeTargetPath.scope);
         processedIdentifiers.add(rootId);
       }
-    } else if (t30.isIdentifier(analyzeTarget)) {
+    } else if (t38.isIdentifier(analyzeTarget)) {
       tryAddDependency(analyzeTargetPath, analyzeTarget.name, analyzeTargetPath.scope);
     }
   }
@@ -3568,55 +4303,55 @@ function analyzeDeps(node, ctx, parentPath) {
     }
   }
   function normalizeDependencyExpr(path9, rootName) {
-    if (t30.isIdentifier(path9.node)) {
-      return t30.identifier(path9.node.name);
+    if (t38.isIdentifier(path9.node)) {
+      return t38.identifier(path9.node.name);
     }
-    if (t30.isMemberExpression(path9.node) || t30.isOptionalMemberExpression(path9.node)) {
+    if (t38.isMemberExpression(path9.node) || t38.isOptionalMemberExpression(path9.node)) {
       const normalizedExp = normalizeMemberForCallSite(path9, path9.node);
-      const safeExp = t30.isMemberExpression(normalizedExp) || t30.isOptionalMemberExpression(normalizedExp) ? ensureOptionalForMemberChain(normalizedExp) : normalizedExp;
+      const safeExp = t38.isMemberExpression(normalizedExp) || t38.isOptionalMemberExpression(normalizedExp) ? ensureOptionalForMemberChain(normalizedExp) : normalizedExp;
       if (isReactValidDependencyExpr(safeExp)) {
-        return t30.cloneNode(safeExp, true);
+        return t38.cloneNode(safeExp, true);
       }
-      return t30.identifier(rootName);
+      return t38.identifier(rootName);
     }
     return null;
   }
   function normalizeSourcedDependency(exp) {
-    if (t30.isIdentifier(exp)) {
-      return t30.identifier(exp.name);
+    if (t38.isIdentifier(exp)) {
+      return t38.identifier(exp.name);
     }
-    if (t30.isMemberExpression(exp) || t30.isOptionalMemberExpression(exp)) {
+    if (t38.isMemberExpression(exp) || t38.isOptionalMemberExpression(exp)) {
       const root = findRootIdentifier(exp);
       if (!root) return null;
-      const safeExp = t30.isMemberExpression(exp) || t30.isOptionalMemberExpression(exp) ? ensureOptionalForMemberChain(exp) : exp;
+      const safeExp = t38.isMemberExpression(exp) || t38.isOptionalMemberExpression(exp) ? ensureOptionalForMemberChain(exp) : exp;
       if (isReactValidDependencyExpr(safeExp)) {
-        return t30.cloneNode(safeExp, true);
+        return t38.cloneNode(safeExp, true);
       }
-      return t30.identifier(root.name);
+      return t38.identifier(root.name);
     }
     return null;
   }
   function isReactValidDependencyExpr(node2) {
-    if (t30.isIdentifier(node2)) {
+    if (t38.isIdentifier(node2)) {
       return true;
     }
-    if (t30.isMemberExpression(node2) || t30.isOptionalMemberExpression(node2)) {
+    if (t38.isMemberExpression(node2) || t38.isOptionalMemberExpression(node2)) {
       return isStaticMemberChain(node2);
     }
     return false;
   }
   function isStaticMemberChain(node2) {
     let current = node2;
-    while (t30.isMemberExpression(current) || t30.isOptionalMemberExpression(current)) {
-      if (!current.computed && !t30.isIdentifier(current.property)) {
+    while (t38.isMemberExpression(current) || t38.isOptionalMemberExpression(current)) {
+      if (!current.computed && !t38.isIdentifier(current.property)) {
         return false;
       }
-      if (current.computed && !t30.isStringLiteral(current.property) && !t30.isNumericLiteral(current.property)) {
+      if (current.computed && !t38.isStringLiteral(current.property) && !t38.isNumericLiteral(current.property)) {
         return false;
       }
       current = current.object;
     }
-    return t30.isIdentifier(current);
+    return t38.isIdentifier(current);
   }
   function isBindingDeclaredInsideBoundary(binding, boundary) {
     let current = binding.path;
@@ -3634,7 +4369,7 @@ function analyzeDeps(node, ctx, parentPath) {
     if (!isDirectCallee) {
       return node2;
     }
-    if (!t30.isExpression(node2.object)) {
+    if (!t38.isExpression(node2.object)) {
       return node2;
     }
     return node2.object;
@@ -3643,15 +4378,15 @@ function analyzeDeps(node, ctx, parentPath) {
     if (!hasTrailingMemberAccess(node2)) {
       return node2;
     }
-    if (t30.isOptionalMemberExpression(node2) && node2.optional) {
+    if (t38.isOptionalMemberExpression(node2) && node2.optional) {
       return node2;
     }
-    const object = t30.cloneNode(node2.object, true);
-    const property = t30.cloneNode(node2.property, true);
-    return t30.optionalMemberExpression(object, property, node2.computed, true);
+    const object = t38.cloneNode(node2.object, true);
+    const property = t38.cloneNode(node2.property, true);
+    return t38.optionalMemberExpression(object, property, node2.computed, true);
   }
   function hasTrailingMemberAccess(node2) {
-    return t30.isMemberExpression(node2.object) || t30.isOptionalMemberExpression(node2.object);
+    return t38.isMemberExpression(node2.object) || t38.isOptionalMemberExpression(node2.object);
   }
   function isEligibleBindingSource(binding) {
     if (binding.kind === "param") {
@@ -3661,17 +4396,17 @@ function analyzeDeps(node, ctx, parentPath) {
     const declaratorPath = getVariableDeclaratorPath(bindingPath);
     const isReactiveVarBinding = !!declaratorPath && isReactiveBinding(declaratorPath.node);
     const nodeInit = declaratorPath?.node.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));
+    const isReactiveApiCallVarBinding = !!declaratorPath && t38.isCallExpression(nodeInit) && t38.isIdentifier(nodeInit.callee) && reactiveStateApis.has(nodeInit.callee.name);
+    const isHookCallVarBinding = !!declaratorPath && t38.isCallExpression(nodeInit) && isHookLikeCallee(nodeInit.callee);
+    const isFunctionBinding = bindingPath.isFunctionDeclaration() || !!declaratorPath && !!nodeInit && (t38.isArrowFunctionExpression(nodeInit) || t38.isFunctionExpression(nodeInit));
     const isReactiveFunctionBinding = isFunctionBinding && (isReactiveBinding(declaratorPath?.node) || isReactiveBinding(bindingPath.node));
     return isReactiveVarBinding || isReactiveApiCallVarBinding || isHookCallVarBinding || isReactiveFunctionBinding;
   }
   function isHookLikeCallee(callee) {
-    if (t30.isIdentifier(callee)) {
+    if (t38.isIdentifier(callee)) {
       return callee.name.startsWith("use");
     }
-    if (t30.isMemberExpression(callee) && !callee.computed && t30.isIdentifier(callee.property)) {
+    if (t38.isMemberExpression(callee) && !callee.computed && t38.isIdentifier(callee.property)) {
       return callee.property.name.startsWith("use");
     }
     return false;
@@ -3687,7 +4422,7 @@ function analyzeDeps(node, ctx, parentPath) {
   }
   function isExpressionSourcedFromEligibleBinding(exp, scope, seen, depth) {
     if (depth <= 0) return null;
-    if (t30.isIdentifier(exp)) {
+    if (t38.isIdentifier(exp)) {
       const sourceBinding = scope.getBinding(exp.name);
       if (!sourceBinding) return null;
       if (isEligibleBindingSource(sourceBinding)) {
@@ -3695,13 +4430,13 @@ function analyzeDeps(node, ctx, parentPath) {
       }
       return traceBindingSource(sourceBinding, seen, depth - 1);
     }
-    if (t30.isMemberExpression(exp) || t30.isOptionalMemberExpression(exp)) {
+    if (t38.isMemberExpression(exp) || t38.isOptionalMemberExpression(exp)) {
       const root = findRootIdentifier(exp);
       if (!root) return null;
       const sourceBinding = scope.getBinding(root.name);
       if (!sourceBinding) return null;
       if (isEligibleBindingSource(sourceBinding)) {
-        return t30.cloneNode(exp);
+        return t38.cloneNode(exp);
       }
       const sourcedRoot = traceBindingSource(sourceBinding, seen, depth - 1);
       if (sourcedRoot) {
@@ -3709,17 +4444,17 @@ function analyzeDeps(node, ctx, parentPath) {
         if (rebuilt) {
           return rebuilt;
         }
-        return t30.cloneNode(sourcedRoot, true);
+        return t38.cloneNode(sourcedRoot, true);
       }
     }
     return null;
   }
   function rebuildMemberWithNewRoot(node2, nextRoot) {
     const replacedObject = (() => {
-      if (t30.isIdentifier(node2.object)) {
-        return t30.cloneNode(nextRoot, true);
+      if (t38.isIdentifier(node2.object)) {
+        return t38.cloneNode(nextRoot, true);
       }
-      if (t30.isMemberExpression(node2.object) || t30.isOptionalMemberExpression(node2.object)) {
+      if (t38.isMemberExpression(node2.object) || t38.isOptionalMemberExpression(node2.object)) {
         return rebuildMemberWithNewRoot(node2.object, nextRoot);
       }
       return null;
@@ -3727,34 +4462,34 @@ function analyzeDeps(node, ctx, parentPath) {
     if (!replacedObject) {
       return null;
     }
-    const property = t30.cloneNode(node2.property, true);
-    if (t30.isMemberExpression(node2)) {
-      return t30.memberExpression(
+    const property = t38.cloneNode(node2.property, true);
+    if (t38.isMemberExpression(node2)) {
+      return t38.memberExpression(
         replacedObject,
         property,
         node2.computed
       );
     }
-    return t30.optionalMemberExpression(
+    return t38.optionalMemberExpression(
       replacedObject,
       property,
       node2.computed,
       node2.optional
     );
   }
-  return t30.arrayExpression(Array.from(deps.values()));
+  return t38.arrayExpression(Array.from(deps.values()));
 }
 function getDependencyKey(exp) {
-  if (t30.isIdentifier(exp)) {
+  if (t38.isIdentifier(exp)) {
     return exp.name;
   }
-  if (t30.isMemberExpression(exp) || t30.isOptionalMemberExpression(exp)) {
+  if (t38.isMemberExpression(exp) || t38.isOptionalMemberExpression(exp)) {
     const objectKey = getDependencyKey(exp.object);
     const opt = exp.optional ? "?" : "";
-    if (!exp.computed && t30.isIdentifier(exp.property)) {
+    if (!exp.computed && t38.isIdentifier(exp.property)) {
       return `${objectKey}${opt}.${exp.property.name}`;
     }
-    if (t30.isStringLiteral(exp.property) || t30.isNumericLiteral(exp.property)) {
+    if (t38.isStringLiteral(exp.property) || t38.isNumericLiteral(exp.property)) {
       return `${objectKey}${opt}[${JSON.stringify(exp.property.value)}]`;
     }
     return `${objectKey}${opt}[*]`;
@@ -3787,7 +4522,7 @@ function resolveAnalysisOnlyAdapter(ctx) {
       if (!isVueApiReference(path9, apiName)) {
         return;
       }
-      if (t31.isCallExpression(node)) {
+      if (t39.isCallExpression(node)) {
         resolveCallNode(path9, adapter, ctx);
       } else {
         replaceIdName(node, adapter.target);
@@ -3797,11 +4532,11 @@ function resolveAnalysisOnlyAdapter(ctx) {
   };
 }
 function getApiName(node) {
-  const isCallNode = t31.isCallExpression(node);
+  const isCallNode = t39.isCallExpression(node);
   let apiName = "";
-  if (t31.isIdentifier(node)) {
+  if (t39.isIdentifier(node)) {
     apiName = node.name;
-  } else if (isCallNode && t31.isIdentifier(node.callee)) {
+  } else if (isCallNode && t39.isIdentifier(node.callee)) {
     apiName = node.callee.name;
   }
   return apiName;
@@ -3811,7 +4546,7 @@ function resolveCallNode(path9, adapter, ctx) {
   const { arguments: args } = node;
   if (!args.length) return;
   const fn = args[0];
-  if (!t31.isArrowFunctionExpression(fn) && !t31.isFunctionExpression(fn)) {
+  if (!t39.isArrowFunctionExpression(fn) && !t39.isFunctionExpression(fn)) {
     return;
   }
   const fnPath = path9.get("arguments")[0];
@@ -3843,7 +4578,7 @@ function isVueImportBinding(binding) {
     return false;
   }
   const parent = bindingPath.parentPath?.node;
-  if (!parent || !t31.isImportDeclaration(parent)) {
+  if (!parent || !t39.isImportDeclaration(parent)) {
     return false;
   }
   const source = parent.source.value.toLowerCase();
@@ -3870,7 +4605,7 @@ function resolveArrowFnDeps(ctx, ast) {
       const declaratorPath = getVariableDeclaratorPath(path9);
       recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.useCallback);
       setScriptNodeMeta(declaratorPath?.node, { is_reactive: true, reactive_type: "indirect" });
-      path9.replaceWith(newNode);
+      replaceNode(path9, newNode, node);
     }
   };
 }
@@ -3911,7 +4646,7 @@ function isSkip(path9) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-element-ref.ts
-import * as t32 from "@babel/types";
+import * as t40 from "@babel/types";
 function resolveElementRef(ctx) {
   return {
     CallExpression(path9) {
@@ -3929,14 +4664,14 @@ function resolveElementRef(ctx) {
       }
       if (isCompRefBindings) {
         const varDeclaratorPath = getVariableDeclaratorPath(path9)?.node;
-        if (!t32.isIdentifier(varDeclaratorPath?.id)) {
+        if (!t40.isIdentifier(varDeclaratorPath?.id)) {
           return;
         }
         const varName = varDeclaratorPath.id.name;
         const compRef = refBindings.componentRefs[varName];
         if (!compRef) return;
       }
-      node.arguments[0] = t32.identifier("null");
+      node.arguments[0] = t40.identifier("null");
       resolveTypeParameters(ctx, path9);
       replaceCallName(node, REACT_API_MAP.useRef);
       recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.useRef);
@@ -3961,27 +4696,27 @@ function resolveTypeParameters(ctx, path9) {
   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))]);
+    node.typeParameters = t40.tsTypeParameterInstantiation([t40.tsTypeReference(t40.identifier(type))]);
   }
 }
 function resolveRefValueToCurrent(path9) {
   const { node } = path9;
-  if (node.computed || !t32.isIdentifier(node.property) || node.property.name !== "value") {
+  if (node.computed || !t40.isIdentifier(node.property) || node.property.name !== "value") {
     return;
   }
   const rootPath = findRootVariablePath(path9);
-  if (!rootPath?.node || !t32.isCallExpression(rootPath.node.init) || !isCalleeNamed(rootPath.node.init, REACT_API_MAP.useRef)) {
+  if (!rootPath?.node || !t40.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 !== rootId?.name) {
+  if (!t40.isIdentifier(node.object) || node.object.name !== rootId?.name) {
     return;
   }
   node.property.name = "current";
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-expression-memo.ts
-import * as t33 from "@babel/types";
+import * as t41 from "@babel/types";
 function resolveExprMemo(ctx, ast) {
   const isScriptFile = ctx.inputType !== "sfc";
   return {
@@ -3993,11 +4728,11 @@ function resolveExprMemo(ctx, ast) {
         if (!atComponentOrHookRoot(path9, ast.program, isScriptFile)) {
           return false;
         }
-        if (!t33.isVariableDeclaration(path9.parent) || path9.parent.kind !== "const") {
+        if (!t41.isVariableDeclaration(path9.parent) || path9.parent.kind !== "const") {
           return false;
         }
-        if (t33.isFunction(init)) return false;
-        if (t33.isCallExpression(init) && t33.isIdentifier(init.callee) && init.callee.name.startsWith("use")) {
+        if (t41.isFunction(init)) return false;
+        if (t41.isCallExpression(init) && t41.isIdentifier(init.callee) && init.callee.name.startsWith("use")) {
           return false;
         }
         return true;
@@ -4015,16 +4750,16 @@ function resolveExprMemo(ctx, ast) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-lint-rules.ts
-import * as t34 from "@babel/types";
+import * as t42 from "@babel/types";
 function resolveLintRules(ctx, ast) {
   const inScriptFile = ctx.inputType !== "sfc";
   return {
     CallExpression(path9) {
       const { node, parentPath } = path9;
-      if (!t34.isIdentifier(node.callee)) return;
+      if (!t42.isIdentifier(node.callee)) return;
       const { name: callName } = node.callee;
-      const addLog = (t40) => {
-        logger.error(t40, {
+      const addLog = (t48) => {
+        logger.error(t48, {
           file: ctx.filename,
           source: ctx.scriptData.source,
           loc: node.loc
@@ -4069,7 +4804,7 @@ function resolveLintRules(ctx, ast) {
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-provide.ts
 import { generate as generate2 } from "@babel/generator";
-import * as t35 from "@babel/types";
+import * as t43 from "@babel/types";
 function resolveProvide(ctx) {
   if (ctx.inputType === "style") return {};
   return {
@@ -4101,13 +4836,13 @@ function findOrCreateCtxProvider(root) {
 function assignProviderValue(target, key, value) {
   const getRawExp = (exp) => {
     if (!exp) return "''";
-    if (t35.isStringLiteral(exp)) {
+    if (t43.isStringLiteral(exp)) {
       return JSON.stringify(exp.value);
     }
-    if (t35.isNumericLiteral(exp)) {
+    if (t43.isNumericLiteral(exp)) {
       return exp.value.toString();
     }
-    if (t35.isIdentifier(exp)) {
+    if (t43.isIdentifier(exp)) {
       return exp.name;
     }
     try {
@@ -4123,16 +4858,16 @@ function assignProviderValue(target, key, value) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-rename-adapter.ts
-import * as t36 from "@babel/types";
+import * as t44 from "@babel/types";
 function resolveRenameAdapter(ctx) {
   return {
     "CallExpression|Identifier"(path9) {
       const node = path9.node;
-      const isCallNode = t36.isCallExpression(node);
+      const isCallNode = t44.isCallExpression(node);
       let apiName = "";
-      if (t36.isIdentifier(node)) {
+      if (t44.isIdentifier(node)) {
         apiName = node.name;
-      } else if (isCallNode && t36.isIdentifier(node.callee)) {
+      } else if (isCallNode && t44.isIdentifier(node.callee)) {
         apiName = node.callee.name;
       }
       if (!apiName) {
@@ -4190,7 +4925,7 @@ function isVueImportBinding2(binding) {
     return false;
   }
   const parent = bindingPath.parentPath?.node;
-  if (!parent || !t36.isImportDeclaration(parent)) {
+  if (!parent || !t44.isImportDeclaration(parent)) {
     return false;
   }
   const source = parent.source.value.toLowerCase();
@@ -4210,11 +4945,12 @@ function processVueSyntax2(ast, ctx) {
       applyBabel: [
         resolvePropsIface,
         resolveEmitsTopLevelTypes,
-        resolveSlotsTopLevelTypes,
         resolveDefineOptions,
         resolveDefineExpose,
         resolveDefineAsyncComponent,
-        resolveEmitCalls
+        resolveEmitCalls,
+        // feature: https://github.com/vureact-js/core/issues/6
+        resolveUseAttrs
       ]
     },
     process: {
@@ -4326,15 +5062,15 @@ function isRouterLinkBooleanCustomProp(prop) {
 }
 
 // src/core/transform/sfc/template/shared/prop-ir-utils.ts
-import * as t38 from "@babel/types";
+import * as t46 from "@babel/types";
 
 // src/shared/string-code-types.ts
 import { parseExpression as parseExpression3 } from "@babel/parser";
-import * as t37 from "@babel/types";
+import * as t45 from "@babel/types";
 var strCodeTypes = {
-  isIdentifier: isIdentifier19,
+  isIdentifier: isIdentifier24,
   isSimpleExpression,
-  isStringLiteral: isStringLiteral11
+  isStringLiteral: isStringLiteral13
 };
 function isSimpleExpression(code, excludeVar = false) {
   let node;
@@ -4343,38 +5079,38 @@ function isSimpleExpression(code, excludeVar = false) {
   } catch {
     return false;
   }
-  if (t37.isLiteral(node)) {
+  if (t45.isLiteral(node)) {
     return true;
   }
-  if (!excludeVar && t37.isIdentifier(node)) {
+  if (!excludeVar && t45.isIdentifier(node)) {
     return true;
   }
-  if (t37.isMemberExpression(node)) {
-    return isSimpleExpression(node.object) && t37.isIdentifier(node.property);
+  if (t45.isMemberExpression(node)) {
+    return isSimpleExpression(node.object) && t45.isIdentifier(node.property);
   }
-  if (t37.isObjectExpression(node) || t37.isArrayExpression(node)) {
+  if (t45.isObjectExpression(node) || t45.isArrayExpression(node)) {
     return false;
   }
-  if (t37.isCallExpression(node) || t37.isAssignmentExpression(node)) {
+  if (t45.isCallExpression(node) || t45.isAssignmentExpression(node)) {
     return false;
   }
-  if (t37.isBinaryExpression(node) || t37.isUnaryExpression(node)) {
+  if (t45.isBinaryExpression(node) || t45.isUnaryExpression(node)) {
     return true;
   }
   return false;
 }
-function isIdentifier19(code) {
+function isIdentifier24(code) {
   try {
     const node = parseExpression3(code);
-    return t37.isIdentifier(node);
+    return t45.isIdentifier(node);
   } catch {
     return false;
   }
 }
-function isStringLiteral11(code) {
+function isStringLiteral13(code) {
   try {
     const node = parseExpression3(code);
-    return t37.isStringLiteral(node);
+    return t45.isStringLiteral(node);
   } catch {
     return false;
   }
@@ -4516,23 +5252,23 @@ function resolvePropAsBabelExp(ir, ctx) {
   const mergedItems = value.merge;
   const setNameIdentifier = (target, valueName) => {
     target.content = valueName;
-    target.ast = t38.jsxIdentifier(valueName);
+    target.ast = t46.jsxIdentifier(valueName);
   };
-  const setValueExpression = (target, content, isStringLiteral12) => {
+  const setValueExpression = (target, content, isStringLiteral14) => {
     target.content = content;
-    target.ast = resolveStringExpr(content, ctx, isStringLiteral12);
+    target.ast = resolveStringExpr(content, ctx, isStringLiteral14);
   };
   const createRuntimeCall = (fnName, args) => {
     const fnArgs = args.filter(Boolean).join(",");
     return `${fnName}(${fnArgs})`;
   };
-  const applyRuntimeExpression = (expression, setName = false, nameIdentifier, isStringLiteral12) => {
+  const applyRuntimeExpression = (expression, setName = false, nameIdentifier, isStringLiteral14) => {
     if (setName && nameIdentifier) {
       setNameIdentifier(nameExp, nameIdentifier);
     }
     const dir = ADAPTER_RULES.runtime.dir;
     recordImport(ctx, dir.package, dir.target);
-    setValueExpression(value.babelExp, expression, isStringLiteral12);
+    setValueExpression(value.babelExp, expression, isStringLiteral14);
   };
   if (ir.isKeyLessVBind) {
     const dirKeyless = ADAPTER_RULES.runtime.dirKeyless;
@@ -4568,7 +5304,7 @@ function resolvePropAsBabelExp(ir, ctx) {
     return;
   }
   setNameIdentifier(nameExp, name);
-  const normalizedValue = resolveSpecialExpressions(valueContent, ctx);
+  const normalizedValue = resolveSpecialExpression(valueContent, ctx);
   setValueExpression(value.babelExp, normalizedValue, value.isStringLiteral);
 }
 
@@ -4806,22 +5542,22 @@ function warnUnsupportedVueDollarVar(ctx, node) {
 }
 
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-is-prop.ts
-function resolveStaticIsProp(node, ir, ctx, nodeIR) {
-  if (!node) {
+function resolveStaticIsProp(content, ir, ctx, nodeIR) {
+  if (!content) {
     return;
   }
-  if (node.startsWith("vue:")) {
-    const name = node.split("vue:")[1];
+  if (content.startsWith("vue:")) {
+    const name = content.split("vue:")[1];
     nodeIR.tag = camelCase(name);
     return;
   }
-  const propIR = createPropsIR("is", "is", node);
+  const propIR = createPropsIR("is", "is", content);
   propIR.value.isStringLiteral = true;
   resolvePropAsBabelExp(propIR, ctx);
   nodeIR.props.push(propIR);
 }
-function resolveDynamicIsProp(node, ir, ctx, nodeIR) {
-  const exp = node.exp;
+function resolveDynamicIsProp(directive, ir, ctx, nodeIR) {
+  const exp = directive.exp;
   const content = exp.content;
   if (strCodeTypes.isStringLiteral(content)) {
     resolveStaticIsProp(content, ir, ctx, nodeIR);
@@ -4837,20 +5573,20 @@ function resolveDynamicIsProp(node, ir, ctx, nodeIR) {
 
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-ref-prop.ts
 import { NodeTypes as NodeTypes5 } from "@vue/compiler-core";
-function resolveRefProp(node, ctx, nodeIR) {
+function resolveRefProp(prop, ctx, nodeIR) {
   const {
     templateData: { refBindings }
   } = ctx;
   let propIR;
-  if (node.type === NodeTypes5.ATTRIBUTE) {
-    const tag = node.value?.content;
+  if (prop.type === NodeTypes5.ATTRIBUTE) {
+    const tag = prop.value?.content;
     if (!tag) return;
     collectComponentRef(tag, ctx);
     const domRefBinding = Object.values(refBindings.domRefs).find((r) => r.tag === tag);
     const refVar = domRefBinding?.name || refBindings.componentRefs[tag]?.name;
     propIR = createPropsIR("ref", "ref", refVar || "null");
   } else {
-    const exp = node.exp;
+    const exp = prop.exp;
     for (const name in refBindings.domRefs) {
       const newName = `${name}.current`;
       const regex = new RegExp(`${name}(?!\\.current)`, "g");
@@ -4878,50 +5614,92 @@ function collectComponentRef(tag, ctx) {
   }
 }
 
+// src/core/transform/sfc/template/syntax-processor/process/props/resolve-template-key.ts
+import {
+  ConstantTypes,
+  NodeTypes as NodeTypes6
+} from "@vue/compiler-core";
+function resolveTemplateNodeKey(vueNode, keyContent) {
+  const firstNode = vueNode.children[0];
+  if (!firstNode) return;
+  const hasKeyProp = firstNode.props.some(
+    (p) => p.type === NodeTypes6.DIRECTIVE && p.name === "key"
+  );
+  if (hasKeyProp) return;
+  firstNode.props.push(createSimpleVueBind("key", keyContent));
+}
+function createSimpleVueBind(name, value) {
+  return {
+    type: NodeTypes6.DIRECTIVE,
+    name: "bind",
+    rawName: `:${name}`,
+    exp: {
+      type: NodeTypes6.SIMPLE_EXPRESSION,
+      content: value,
+      isStatic: false,
+      constType: ConstantTypes.NOT_CONSTANT,
+      loc: {}
+    },
+    arg: {
+      type: NodeTypes6.SIMPLE_EXPRESSION,
+      content: name,
+      isStatic: true,
+      constType: ConstantTypes.CAN_STRINGIFY,
+      loc: {}
+    },
+    modifiers: [],
+    loc: {}
+  };
+}
+
 // 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;
+function resolveDynamicAttributeProp(directive, ir, ctx, vueNode, nodeIR) {
+  const arg = directive.arg;
+  const exp = directive.exp;
   const name = arg?.content ?? "";
   const content = exp?.content ?? "true";
-  warnUnsupportedVueDollarVar(ctx, node);
+  warnUnsupportedVueDollarVar(ctx, directive);
   if (name === "is") {
-    resolveDynamicIsProp(node, ir, ctx, nodeIR);
+    resolveDynamicIsProp(directive, ir, ctx, nodeIR);
     return;
   }
   if (name === "ref") {
-    resolveRefProp(node, ctx, nodeIR);
+    resolveRefProp(directive, ctx, nodeIR);
+    return;
+  }
+  if (vueNode.tag === "template" && name === "key") {
+    resolveTemplateNodeKey(vueNode, content);
     return;
   }
-  const dynamicPropIR = createPropsIR(node.rawName, name, content);
-  dynamicPropIR.isStatic = arg?.isStatic ?? true;
-  checkPropIsDynamicKey(ctx, node);
-  resolvePropertyIR(dynamicPropIR, ir, ctx, nodeIR, true);
+  const propIR = createPropsIR(directive.rawName, name, content);
+  propIR.isStatic = arg?.isStatic ?? true;
+  checkPropIsDynamicKey(ctx, directive);
+  resolvePropertyIR(propIR, ir, ctx, nodeIR, true);
 }
-function resolvePropertyIR(node, ir, ctx, nodeIR, isDynamic = false) {
-  let content = node.value.content;
-  if (isVBind(node.rawName) && !node.name) {
-    node.isKeyLessVBind = true;
+function resolvePropertyIR(propsIR, ir, ctx, nodeIR, isDynamic = false) {
+  let content = propsIR.value.content;
+  if (isVBind(propsIR.rawName) && !propsIR.name) {
+    propsIR.isKeyLessVBind = true;
   }
-  if (isStyleAttr(node.name)) {
-    node.value.isStringLiteral = false;
-    content = node.value.content = parseStyleString(content);
+  if (isStyleAttr(propsIR.name)) {
+    propsIR.value.isStringLiteral = false;
+    content = propsIR.value.content = parseStyleString(content);
   }
   if (isDynamic) {
-    const isStringLiteral12 = strCodeTypes.isStringLiteral(content);
-    if (isStringLiteral12) {
+    const isStringLiteral14 = strCodeTypes.isStringLiteral(content);
+    if (isStringLiteral14) {
       content = normalizeString(content);
-      node.value.content = content;
+      propsIR.value.content = content;
     }
-    node.value.isStringLiteral = isStringLiteral12;
+    propsIR.value.isStringLiteral = isStringLiteral14;
   }
-  const existing = findSameProp(nodeIR.props, node);
+  const existing = findSameProp(nodeIR.props, propsIR);
   if (existing) {
-    mergePropsIR(ctx, existing, node);
+    mergePropsIR(ctx, existing, propsIR);
   } else {
-    nodeIR.props.push(node);
+    nodeIR.props.push(propsIR);
   }
-  resolvePropAsBabelExp(existing ?? node, ctx);
+  resolvePropAsBabelExp(existing ?? propsIR, ctx);
 }
 function normalizeString(s) {
   if (s.startsWith("'") && s.endsWith("'")) {
@@ -4931,15 +5709,15 @@ function normalizeString(s) {
 }
 
 // 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 = node.value?.content ?? "true";
+function resolveAttributeProp(attribute, ir, ctx, nodeIR) {
+  const name = attribute.name;
+  const content = attribute.value?.content ?? "true";
   if (name === "is") {
     resolveStaticIsProp(content, ir, ctx, nodeIR);
     return;
   }
   if (name === "ref") {
-    resolveRefProp(node, ctx, nodeIR);
+    resolveRefProp(attribute, ctx, nodeIR);
     return;
   }
   const attrIR = createPropsIR(name, name, content);
@@ -4948,15 +5726,86 @@ function resolveAttributeProp(node, ir, ctx, nodeIR) {
   resolvePropertyIR(attrIR, ir, ctx, nodeIR);
 }
 
+// src/core/transform/sfc/template/syntax-processor/process/props/resolve-directive-prop.ts
+function resolveDirectiveProp(directive, ir, ctx, vueNode, nodeIR, siblingNodesIR) {
+  const { name, rawName } = directive;
+  if (!SUPPORTED_DIRECTIVES.has(name)) {
+    warnUnsupportedDirective(ctx, directive.loc, rawName);
+    return;
+  }
+  warnUnsupportedVueDollarVar(ctx, directive);
+  if (isVConditional(rawName)) {
+    return resolveVIf(directive, ir, ctx, nodeIR, siblingNodesIR);
+  }
+  function processExactDirectives() {
+    switch (directive.rawName) {
+      case "v-html":
+        resolveVHtml(directive, ir, ctx, nodeIR);
+        return true;
+      case "v-text":
+        resolveVText(directive, ir, ctx, nodeIR);
+        return true;
+      case "v-once":
+      case "v-memo":
+        return resolveVMemo(directive, ir, ctx, nodeIR);
+      case "v-show":
+        return resolveVShow(directive, ir, ctx, nodeIR);
+      case "v-for":
+        return resolveVFor(directive, ir, ctx, nodeIR);
+    }
+  }
+  function processRangeDirectives() {
+    const { rawName: rawName2 } = directive;
+    if (isVModel(rawName2)) {
+      return resolveVModel(directive, ir, ctx, vueNode, nodeIR);
+    }
+    if (isVBind(rawName2)) {
+      return resolveDynamicAttributeProp(directive, ir, ctx, vueNode, nodeIR);
+    }
+    if (isVOn(rawName2)) {
+      return resolveVOn(directive, ir, ctx, nodeIR);
+    }
+    if (isVSlot(rawName2)) {
+      if (nodeIR.tag === VUE_API_MAP.RouterLink) {
+        resolveRouterLinkVSlotProp(directive, nodeIR, ctx);
+      }
+      return true;
+    }
+  }
+  return processExactDirectives() || processRangeDirectives();
+}
+
+// src/core/transform/sfc/template/syntax-processor/process/props/resolve-props.ts
+import { NodeTypes as NodeTypes7 } from "@vue/compiler-core";
+function resolveProps(vueNode, ir, ctx, nodeIR, siblingNodesIR) {
+  for (const prop of vueNode.props) {
+    if (prop.type === NodeTypes7.ATTRIBUTE) {
+      resolveAttributeProp(prop, ir, ctx, nodeIR);
+      continue;
+    }
+    if (prop.type === NodeTypes7.DIRECTIVE) {
+      const stop = resolveDirectiveProp(
+        prop,
+        ir,
+        ctx,
+        vueNode,
+        nodeIR,
+        siblingNodesIR
+      );
+      if (stop) break;
+    }
+  }
+}
+
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-router-link-v-slot-prop.ts
-function resolveRouterLinkVSlotProp(node, nodeIR, ctx) {
-  const arg = node.arg;
-  const exp = node.exp;
-  checkPropIsDynamicKey(ctx, node);
+function resolveRouterLinkVSlotProp(directive, nodeIR, ctx) {
+  const arg = directive.arg;
+  const exp = directive.exp;
+  checkPropIsDynamicKey(ctx, directive);
   const propIR = {
     type: 2 /* SLOT */,
     name: "customRender",
-    rawName: node.rawName ?? "v-slot",
+    rawName: directive.rawName ?? "v-slot",
     isStatic: arg?.isStatic ?? true,
     isScoped: true,
     callback: {
@@ -4968,11 +5817,11 @@ function resolveRouterLinkVSlotProp(node, nodeIR, ctx) {
 }
 
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-for.ts
-function resolveVFor(node, _ir, _ctx, nodeIR) {
+function resolveVFor(directive, ir, ctx, nodeIR) {
   nodeIR.meta.loop = {
     isLoop: true,
     isHandled: false,
-    value: resolveForResult(node.forParseResult)
+    value: resolveForResult(directive.forParseResult)
   };
 }
 function resolveForResult(forParseResult) {
@@ -4989,17 +5838,17 @@ function resolveForResult(forParseResult) {
 }
 
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-html.ts
-function resolveVHtml(node, ir, ctx, nodeIR) {
-  const exp = node.exp;
+function resolveVHtml(directive, ir, ctx, nodeIR) {
+  const exp = directive.exp;
   const propIR = createPropsIR("v-html", "v-html", `{__html: ${exp.content}}`);
   resolvePropAsBabelExp(propIR, ctx);
   nodeIR.props.push(propIR);
 }
 
 // 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 = node.exp?.content ?? "true";
+function resolveVIf(directive, ir, ctx, nodeIR, siblingNodesIR) {
+  const name = directive.name === "else-if" ? "elseIf" : directive.name;
+  const value = directive.exp?.content ?? "true";
   const prevNode = siblingNodesIR[siblingNodesIR.length - 1];
   const isElseBranch = name === "else" || name === "elseIf";
   let hasError = false;
@@ -5020,7 +5869,7 @@ function resolveVIf(node, _ir, ctx, nodeIR, siblingNodesIR) {
     logger.error("v-else/v-else-if has no adjacent v-if or v-else-if.", {
       source,
       file: filename,
-      loc: node.loc
+      loc: directive.loc
     });
     return hasError;
   }
@@ -5036,8 +5885,8 @@ 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;
+function resolveVMemo(directive, _ir, ctx, nodeIR) {
+  const exp = directive.exp;
   let value = exp?.content;
   if (value !== void 0) {
     if (!value.trim() || !value.startsWith("[") && !value.endsWith("]")) {
@@ -5045,7 +5894,7 @@ function resolveVMemo(node, _ir, ctx, nodeIR) {
       logger.warn(
         "The expected value of v-memo is an array; otherwise, memoization will be skipped.",
         {
-          loc: node.loc,
+          loc: directive.loc,
           source,
           file: filename
         }
@@ -5069,15 +5918,15 @@ function resolveVMemo(node, _ir, ctx, nodeIR) {
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-model.ts
 import {
   ElementTypes,
-  NodeTypes as NodeTypes6
+  NodeTypes as NodeTypes8
 } from "@vue/compiler-core";
-function resolveVModel(node, _ir, ctx, elementNode, nodeIR) {
-  const arg = node.arg;
-  const exp = node.exp;
-  const modifiers = node.modifiers.map((item) => item.content);
+function resolveVModel(directive, ir, ctx, vueNode, nodeIR) {
+  const arg = directive.arg;
+  const exp = directive.exp;
+  const modifiers = directive.modifiers.map((item) => item.content);
   const getterName = exp.content;
-  const isComponent = elementNode.tagType === ElementTypes.COMPONENT;
-  const inputType = resolveHtmlInput(elementNode, isComponent);
+  const isComponent = vueNode.tagType === ElementTypes.COMPONENT;
+  const inputType = resolveHtmlInput(vueNode, isComponent);
   const propName = arg?.content ?? resolveModelPropName(inputType, isComponent);
   let valuePropIR;
   let eventPropIR;
@@ -5093,7 +5942,7 @@ function resolveVModel(node, _ir, ctx, elementNode, nodeIR) {
     eventPropIR.type = 3 /* EVENT */;
   } else {
     if (inputType === "radio") {
-      const radioValue = getRadioValue(elementNode);
+      const radioValue = getRadioValue(vueNode);
       valuePropIR = createPropsIR("v-model", "checked", `${getterName} === ${radioValue}`);
       const processedValue = applyValueModifiers(radioValue, modifiers);
       const handlerBody = `() => { ${getterName} = ${processedValue} }`;
@@ -5119,9 +5968,9 @@ function resolveModelPropName(inputType, isComponent = false) {
   }
   return !isComponent ? "value" : "modelValue";
 }
-function getRadioValue(elementNode) {
-  const valueAttr = elementNode.props.find(
-    (prop) => prop.type === NodeTypes6.ATTRIBUTE && prop.name === "value"
+function getRadioValue(vueNode) {
+  const valueAttr = vueNode.props.find(
+    (prop) => prop.type === NodeTypes8.ATTRIBUTE && prop.name === "value"
   );
   if (!valueAttr?.value?.content) return '""';
   const content = valueAttr.value.content;
@@ -5131,7 +5980,7 @@ function resolveHtmlInput(node, isComponent) {
   if (isComponent) return;
   if (node.tag !== "input") return node.tag;
   const typeProp = node.props.find(
-    (prop) => prop.type === NodeTypes6.ATTRIBUTE && prop.name === "type"
+    (prop) => prop.type === NodeTypes8.ATTRIBUTE && prop.name === "type"
   );
   return typeProp?.value?.content?.toLowerCase();
 }
@@ -5147,14 +5996,14 @@ function applyValueModifiers(valueExp, modifiers) {
 }
 
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-on.ts
-import * as t39 from "@babel/types";
-function resolveVOn(node, _ir, ctx, nodeIR) {
-  const arg = node.arg;
-  const exp = node.exp;
-  const modifiers = node.modifiers.map((item) => item.content);
+import * as t47 from "@babel/types";
+function resolveVOn(directive, ir, ctx, nodeIR) {
+  const arg = directive.arg;
+  const exp = directive.exp;
+  const modifiers = directive.modifiers.map((item) => item.content);
   const captureIndex = modifiers.findIndex((modifier) => modifier === "capture");
   let eventName = normalizeVOnEventName(arg.content);
-  let handler = resolveSpecialExpressions(exp.content.trim(), ctx);
+  let handler = resolveSpecialExpression(exp.content.trim(), ctx);
   if (captureIndex > -1) {
     eventName = modifiers[captureIndex] ? `${eventName}Capture` : eventName;
     modifiers.splice(captureIndex, 1);
@@ -5164,11 +6013,11 @@ function resolveVOn(node, _ir, ctx, nodeIR) {
     originalVueEventName = `${arg.content}.${modifiers.join(".")}`;
   } else {
     const expr = stringToExpr(handler);
-    if (!t39.isFunctionExpression(expr) && !t39.isArrowFunctionExpression(expr) && !t39.isIdentifier(expr)) {
+    if (!t47.isFunctionExpression(expr) && !t47.isArrowFunctionExpression(expr) && !t47.isIdentifier(expr)) {
       handler = `() => {${handler}}`;
     }
   }
-  const eventIR = createPropsIR(node.rawName, eventName, handler);
+  const eventIR = createPropsIR(directive.rawName, eventName, handler);
   eventIR.type = 3 /* EVENT */;
   eventIR.isStatic = arg.isStatic;
   eventIR.modifiers = modifiers;
@@ -5189,8 +6038,8 @@ function normalizeVOnEventName(rawEventName) {
 }
 
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-show.ts
-function resolveVShow(node, _ir, ctx, nodeIR) {
-  const exp = node.exp;
+function resolveVShow(directive, ir, ctx, nodeIR) {
+  const exp = directive.exp;
   const test = exp.content;
   const showIR = createPropsIR("v-show", "style", `{display: ${test} ? '' : 'none'}`);
   resolvePropAsBabelExp(showIR, ctx);
@@ -5210,6 +6059,29 @@ function resolveVShow(node, _ir, ctx, nodeIR) {
   nodeIR.props.push(showIR);
 }
 
+// src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-slot-prop.ts
+function resolveVSlotProp(directive, ir, ctx) {
+  const arg = directive.arg;
+  const exp = directive.exp;
+  const isScoped = exp !== void 0;
+  const name = !arg || arg.content === "default" ? "children" : arg.content;
+  const content = !isScoped ? [] : void 0;
+  const callback = isScoped ? {
+    arg: exp?.content?.trim() ?? "",
+    exp: []
+  } : void 0;
+  checkPropIsDynamicKey(ctx, directive);
+  return {
+    type: 2 /* SLOT */,
+    name,
+    rawName: directive.rawName ?? "default",
+    isStatic: arg?.isStatic ?? true,
+    isScoped,
+    content,
+    callback
+  };
+}
+
 // src/core/transform/sfc/template/shared/node-ir-utils.ts
 import { isVSlot as isCompilerVSlot } from "@vue/compiler-core";
 function createInterpolationNodeIR(content) {
@@ -5232,126 +6104,13 @@ function isTemplateVSlotNode(node) {
 }
 
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-text.ts
-function resolveVText(node, _ir, ctx, nodeIR) {
-  const exp = node.exp;
+function resolveVText(directive, ir, ctx, nodeIR) {
+  const exp = directive.exp;
   const interpolationIR = createInterpolationNodeIR(exp.content);
   interpolationIR.babelExp = resolveStringExpr(exp.content, ctx);
   nodeIR.children = [interpolationIR];
 }
 
-// src/core/transform/sfc/template/syntax-processor/process/props/resolve-directive-prop.ts
-var SUPPORTED_DIRECTIVES = /* @__PURE__ */ new Set([
-  "text",
-  "html",
-  "show",
-  "if",
-  "else",
-  "else-if",
-  "for",
-  "on",
-  "once",
-  "bind",
-  "model",
-  "cloak",
-  "slot",
-  "memo",
-  "is"
-]);
-function resolveDirectiveProp(node, ir, ctx, elementNode, nodeIR, siblingNodesIR) {
-  const { name, rawName } = node;
-  if (!SUPPORTED_DIRECTIVES.has(name)) {
-    warnUnsupportedDirective(ctx, node.loc, rawName);
-    return;
-  }
-  warnUnsupportedVueDollarVar(ctx, node);
-  if (isVConditional(rawName)) {
-    return resolveVIf(node, ir, ctx, nodeIR, siblingNodesIR);
-  }
-  function processExactDirectives() {
-    switch (node.rawName) {
-      case "v-html":
-        resolveVHtml(node, ir, ctx, nodeIR);
-        return true;
-      case "v-text":
-        resolveVText(node, ir, ctx, nodeIR);
-        return true;
-      case "v-once":
-      case "v-memo":
-        return resolveVMemo(node, ir, ctx, nodeIR);
-      case "v-show":
-        return resolveVShow(node, ir, ctx, nodeIR);
-      case "v-for":
-        return resolveVFor(node, ir, ctx, nodeIR);
-    }
-  }
-  function processRangeDirectives() {
-    const { rawName: rawName2 } = node;
-    if (isVModel(rawName2)) {
-      return resolveVModel(node, ir, ctx, elementNode, nodeIR);
-    }
-    if (isVBind(rawName2)) {
-      return resolveDynamicAttributeProp(node, ir, ctx, nodeIR);
-    }
-    if (isVOn(rawName2)) {
-      return resolveVOn(node, ir, ctx, nodeIR);
-    }
-    if (isVSlot(rawName2)) {
-      if (nodeIR.tag === VUE_API_MAP.RouterLink) {
-        resolveRouterLinkVSlotProp(node, nodeIR, ctx);
-      }
-      return true;
-    }
-  }
-  return processExactDirectives() || processRangeDirectives();
-}
-
-// src/core/transform/sfc/template/syntax-processor/process/props/resolve-props.ts
-import { NodeTypes as NodeTypes7 } from "@vue/compiler-core";
-function resolveProps(node, ir, ctx, nodeIR, siblingNodesIR) {
-  for (const prop of node.props) {
-    if (prop.type === NodeTypes7.ATTRIBUTE) {
-      resolveAttributeProp(prop, ir, ctx, nodeIR);
-      continue;
-    }
-    if (prop.type === NodeTypes7.DIRECTIVE) {
-      const stop = resolveDirectiveProp(
-        prop,
-        ir,
-        ctx,
-        node,
-        nodeIR,
-        siblingNodesIR
-      );
-      if (stop) {
-        break;
-      }
-    }
-  }
-}
-
-// src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-slot-prop.ts
-function resolveVSlotProp(node, _ir, ctx) {
-  const arg = node.arg;
-  const exp = node.exp;
-  const isScoped = exp !== void 0;
-  const name = !arg || arg.content === "default" ? "children" : arg.content;
-  const content = !isScoped ? [] : void 0;
-  const callback = isScoped ? {
-    arg: exp?.content?.trim() ?? "",
-    exp: []
-  } : void 0;
-  checkPropIsDynamicKey(ctx, node);
-  return {
-    type: 2 /* SLOT */,
-    name,
-    rawName: node.rawName ?? "default",
-    isStatic: arg?.isStatic ?? true,
-    isScoped,
-    content,
-    callback
-  };
-}
-
 // src/core/transform/sfc/template/syntax-processor/process/resolve-comment-node.ts
 function resolveCommentNode(node, _ir, ctx, childrenIR) {
   const nodeIR = createTextNodeIR(node.content, true);
@@ -5411,7 +6170,7 @@ function resolveInterpolationNode(node, _ir, ctx, childrenIR) {
 }
 
 // src/core/transform/sfc/template/syntax-processor/process/resolve-slot-outlet-node.ts
-import { NodeTypes as NodeTypes9 } from "@vue/compiler-core";
+import { NodeTypes as NodeTypes10 } from "@vue/compiler-core";
 
 // src/core/transform/sfc/template/syntax-processor/process/resolve-template-children.ts
 import {
@@ -5420,11 +6179,11 @@ import {
 } from "@vue/compiler-core";
 
 // src/core/transform/sfc/template/syntax-processor/process/resolve-template-v-slot-node.ts
-import { NodeTypes as NodeTypes8 } from "@vue/compiler-core";
+import { NodeTypes as NodeTypes9 } from "@vue/compiler-core";
 function resolveTemplateVSlotNode(node, ir, ctx, nodeIR) {
   let slotIR = {};
   for (const prop of node.props) {
-    if (prop.type === NodeTypes8.DIRECTIVE) {
+    if (prop.type === NodeTypes9.DIRECTIVE) {
       slotIR = resolveVSlotProp(prop, ir, ctx);
     }
   }
@@ -5445,7 +6204,11 @@ function resolveTextNode(node, _ir, _ctx, childrenIR) {
 }
 
 // src/core/transform/sfc/template/syntax-processor/process/resolve-template-children.ts
+var isRootMarked = false;
 function resolveTemplateChildren(node, nodeIR, ctx) {
+  if (!isRootMarked) {
+    isRootMarked = true;
+  }
   resolveChildNodes(node, nodeIR, ctx, null, nodeIR.children);
 }
 function resolveChildNodes(node, nodeIR, ctx, parentIR, childrenIR) {
@@ -5462,6 +6225,7 @@ function resolveChildNodes(node, nodeIR, ctx, parentIR, childrenIR) {
         continue;
       }
       const elementIR = resolveElementNode(child, nodeIR, ctx, childrenIR);
+      markRootNode(elementIR);
       childrenIR.push(elementIR);
       if (child.children.length) {
         resolveChildNodes(child, nodeIR, ctx, elementIR, elementIR.children);
@@ -5482,6 +6246,12 @@ function resolveChildNodes(node, nodeIR, ctx, parentIR, childrenIR) {
   }
   return nodeIR;
 }
+function markRootNode(nodeIR) {
+  if (isRootMarked) {
+    nodeIR.isRoot = isRootMarked;
+    isRootMarked = void 0;
+  }
+}
 
 // src/core/transform/sfc/template/syntax-processor/process/resolve-slot-outlet-node.ts
 function resolveSlotOutletNode(node, nodeIR, ctx, parentIR, childrenIR) {
@@ -5513,7 +6283,7 @@ function resolveSlotProps(node, ctx) {
     });
   };
   for (const prop of node.props) {
-    if (prop.type === NodeTypes9.ATTRIBUTE) {
+    if (prop.type === NodeTypes10.ATTRIBUTE) {
       const attr = prop.name;
       const value = prop.value?.content.trim();
       if (attr === "name" && value) {
@@ -5523,7 +6293,7 @@ function resolveSlotProps(node, ctx) {
       }
       continue;
     }
-    if (prop.type === NodeTypes9.DIRECTIVE) {
+    if (prop.type === NodeTypes10.DIRECTIVE) {
       const arg = prop.arg;
       const exp = prop.exp;
       warnUnsupportedVueDollarVar(ctx, prop);
@@ -5555,7 +6325,7 @@ function resolveSlotNode(parentIR, node, nodeIR, slotContext, ctx) {
   }
   if (fallback.length === 1) {
     const child = fallback[0];
-    if (child.type === NodeTypes9.TEXT) {
+    if (child.type === NodeTypes10.TEXT) {
       fallbackResolved = true;
       expression += ` ?? ${JSON.stringify(child.content.trim())}`;
     }
@@ -5617,7 +6387,7 @@ function transform(ast, ctx, options) {
 }
 
 // package.json
-var version = "1.5.2";
+var version = "1.6.0";
 var bin = {
   vureact: "./bin/vureact.js"
 };
@@ -6234,18 +7004,19 @@ var CompilationContext = class {
       fileId: "",
       source: "",
       filename: "",
-      compName: "",
       imports: /* @__PURE__ */ new Map(),
       cssVars: [],
       inputType: "sfc",
-      propField: "$props",
+      propField: "props",
       templateData: {
         slots: {},
         refBindings: {
           domRefs: {},
           componentRefs: {}
         },
-        reactiveBindings: {}
+        reactiveBindings: {},
+        declaredProps: /* @__PURE__ */ new Set(),
+        declaredEmits: /* @__PURE__ */ new Set()
       },
       scriptData: {
         lang: "js",
@@ -6265,6 +7036,7 @@ var CompilationContext = class {
           enabled: false,
           refField: "expose"
         },
+        declaredOptions: {},
         source: ""
       },
       styleData: {