@vureact/compiler-core 1.6.0 → 1.6.2

package/lib/{chunk-ZZVHHUP3.js → chunk-FLZ5AUPG.js}

@@ -1,5 +1,5 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } function _optionalChainDelete(ops) { const result = _optionalChain(ops); return result == null ? true : result; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13;/**
- * @vureact/compiler-core v1.6.0
+ * @vureact/compiler-core v1.6.2
  * (c) 2025-present Ruihong Zhong (Ryan John)
  * @license MIT
  */
@@ -39,7 +39,7 @@ var RUNTIME_PACKAGES = {
   },
   runtime: {
     name: PACKAGE_NAME.runtime,
-    version: "^1.0.1"
+    version: "^1.1.0"
   }
 };
 var STYLE_MODULE_NAME = "$style";
@@ -324,6 +324,11 @@ var ADAPTER_RULES = {
       target: "nextTick",
       package: PACKAGE_NAME.runtime,
       type: "rename"
+    },
+    defineAsyncComponent: {
+      target: "defineAsyncComponent",
+      package: PACKAGE_NAME.runtime,
+      type: "rename"
     }
   },
   // =================== [VuReact Router] ===================
@@ -1053,7 +1058,7 @@ function buildStandardProp(nodeIR) {
     babelExp: { ast: keyAST },
     value: {
       content,
-      isStringLiteral: isStringLiteral14,
+      isStringLiteral: isStringLiteral13,
       babelExp: { ast: valueAST }
     }
   } = nodeIR;
@@ -1062,7 +1067,7 @@ function buildStandardProp(nodeIR) {
   }
   let value;
   if (content !== "true") {
-    value = isStringLiteral14 ? t9.stringLiteral(content) : buildJsxExpressionNode(valueAST);
+    value = isStringLiteral13 ? t9.stringLiteral(content) : buildJsxExpressionNode(valueAST);
   }
   return t9.jsxAttribute(keyAST, value);
 }
@@ -2991,98 +2996,22 @@ function resolveDefineAsyncComponent(ctx) {
         return;
       }
       const [arg] = node.arguments;
-      checkIsUnsupported(ctx, arg);
-      pushToGlobalScope(path9, ctx);
-      recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.lazy);
-    }
-  };
-}
-function checkIsUnsupported(ctx, arg) {
-  if (t25.isFunction(arg)) {
-    checkIsDynamicImport(ctx, arg);
-  } else if (t25.isObjectExpression(arg)) {
-    const { value } = arg.properties.find(
-      (p) => t25.isObjectProperty(p) && t25.isIdentifier(p.key) && p.key.name === "loader"
-    );
-    checkIsDynamicImport(ctx, value);
-    if (arg.properties.length > 1) {
-      warnMultipleOptionsUsed(ctx, arg);
-    }
-  }
-}
-function checkIsDynamicImport(ctx, node) {
-  const { scriptData, filename } = ctx;
-  const warnIsNotImport = (target) => {
-    if (!target || !t25.isImport(target)) {
-      logger.error(
-        `Only ES module dynamic imports are supported. You must use and return import('...').`,
-        {
-          source: scriptData.source,
-          file: filename,
-          loc: _optionalChain([target, 'optionalAccess', _83 => _83.loc]) || {}
+      if (!t25.isObjectExpression(arg)) {
+        return;
+      }
+      for (const prop of arg.properties) {
+        if (!t25.isObjectProperty(prop) || !t25.isIdentifier(prop.key) || prop.key.name !== "hydrate") {
+          continue;
         }
-      );
+        logger.warn('Unsupported option "hydrate"', {
+          file: ctx.filename,
+          source: ctx.scriptData.source,
+          loc: prop.key.loc
+        });
+        break;
+      }
     }
   };
-  if (t25.isFunction(node)) {
-    checkIsDynamicImport(ctx, node.body);
-    return;
-  }
-  if (t25.isBlockStatement(node)) {
-    const [returnSmt] = node.body;
-    if (t25.isReturnStatement(returnSmt)) {
-      warnIsNotImport(returnSmt.argument);
-    }
-    return;
-  }
-  if (t25.isCallExpression(node)) {
-    warnIsNotImport(node.callee);
-    if (t25.isStringLiteral(node.arguments[0])) {
-      replaceVueSuffix(node.arguments[0]);
-    }
-    return;
-  }
-  warnIsNotImport(node);
-}
-function warnMultipleOptionsUsed(ctx, node) {
-  const { scriptData, filename } = ctx;
-  logger.warn(
-    "Only the loader option is supported. Other options may be implemented manually based on your needs.",
-    {
-      source: scriptData.source,
-      file: filename,
-      loc: node.loc
-    }
-  );
-}
-function pushToGlobalScope(path9, ctx) {
-  const { node } = path9;
-  const callee = node.callee;
-  callee.name = REACT_API_MAP.lazy;
-  callee.loc.identifierName = REACT_API_MAP.lazy;
-  if (node.typeParameters) {
-    node.typeParameters = void 0;
-  }
-  let declarationPath = path9.parentPath;
-  while (declarationPath) {
-    if (declarationPath.isVariableDeclaration()) {
-      break;
-    }
-    declarationPath = declarationPath.parentPath;
-  }
-  let fullNode;
-  if (_optionalChain([declarationPath, 'optionalAccess', _84 => _84.isVariableDeclaration, 'call', _85 => _85()])) {
-    fullNode = declarationPath.node;
-    declarationPath.remove();
-  } else if (path9.parentPath.isVariableDeclarator()) {
-    fullNode = path9.parent;
-    path9.parentPath.remove();
-  } else {
-    fullNode = path9.node;
-    path9.remove();
-  }
-  const scriptIR = getScriptIR(ctx);
-  scriptIR.statement.global.push(fullNode);
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-expose.ts
@@ -3191,10 +3120,10 @@ function resolveEmitCalls(ctx) {
       const [callee, ...args] = node.arguments;
       const eventName = t28.isStringLiteral(callee) ? formatEmitEventName(callee.value) : void 0;
       if (!eventName) {
-        logger.warn(`Expected String type but got ${_optionalChain([callee, 'optionalAccess', _86 => _86.type])}, expression will be removed`, {
+        logger.warn(`Expected String type but got ${_optionalChain([callee, 'optionalAccess', _83 => _83.type])}, expression will be removed`, {
           file: filename,
           source: scriptData.source,
-          loc: _optionalChain([callee, 'optionalAccess', _87 => _87.loc])
+          loc: _optionalChain([callee, 'optionalAccess', _84 => _84.loc])
         });
         path9.remove();
         return;
@@ -3317,8 +3246,8 @@ function resolveTopLevelEmitType(tsType) {
 function resolveDefineEmitsIface(path9, ctx) {
   const { node } = path9;
   const [runtimeArg] = node.arguments;
-  const tsParams = _optionalChain([node, 'access', _88 => _88.typeParameters, 'optionalAccess', _89 => _89.params]);
-  if (_optionalChain([tsParams, 'optionalAccess', _90 => _90.length])) {
+  const tsParams = _optionalChain([node, 'access', _85 => _85.typeParameters, 'optionalAccess', _86 => _86.params]);
+  if (_optionalChain([tsParams, 'optionalAccess', _87 => _87.length])) {
     processExplicitType(ctx, tsParams);
     return;
   }
@@ -3516,12 +3445,12 @@ function resolveEmitPropFromPropertySignature(member) {
   if (!rawName) return null;
   const handlerName = resolveEmitHandlerName(rawName);
   const key = buildKey(handlerName);
-  const typeAnnotation = _optionalChain([member, 'access', _91 => _91.typeAnnotation, 'optionalAccess', _92 => _92.typeAnnotation]);
+  const typeAnnotation = _optionalChain([member, 'access', _88 => _88.typeAnnotation, 'optionalAccess', _89 => _89.typeAnnotation]);
   let params = [];
   let returnType = t30.tsAnyKeyword();
   if (typeAnnotation && t30.isTSFunctionType(typeAnnotation)) {
     params = cloneCallableParams(typeAnnotation.parameters);
-    returnType = _nullishCoalesce(_optionalChain([typeAnnotation, 'access', _93 => _93.typeAnnotation, 'optionalAccess', _94 => _94.typeAnnotation]), () => ( returnType));
+    returnType = _nullishCoalesce(_optionalChain([typeAnnotation, 'access', _90 => _90.typeAnnotation, 'optionalAccess', _91 => _91.typeAnnotation]), () => ( returnType));
   } else if (typeAnnotation && t30.isTSTupleType(typeAnnotation)) {
     params = resolveTupleTypeParams(typeAnnotation);
   } else if (typeAnnotation) {
@@ -3546,7 +3475,7 @@ function resolveEmitPropsFromCallable(parameters, typeAnnotation) {
   if (t30.isNoop(paramTypeAnnotation)) return [];
   const eventNames = resolveEventNames(paramTypeAnnotation.typeAnnotation);
   if (!eventNames.length) return [];
-  const returnType = _nullishCoalesce(_optionalChain([typeAnnotation, 'optionalAccess', _95 => _95.typeAnnotation]), () => ( t30.tsAnyKeyword()));
+  const returnType = _nullishCoalesce(_optionalChain([typeAnnotation, 'optionalAccess', _92 => _92.typeAnnotation]), () => ( t30.tsAnyKeyword()));
   return eventNames.map((eventName) => {
     const handlerName = resolveEmitHandlerName(eventName);
     const key = buildKey(handlerName);
@@ -3580,7 +3509,7 @@ function resolveTupleElementParam(element, index) {
   const isNamedTuple = typeof t30.isTSNamedTupleMember === "function" && t30.isTSNamedTupleMember(element);
   if (isNamedTuple) {
     const tupleMember = element;
-    const name = _optionalChain([tupleMember, 'access', _96 => _96.label, 'optionalAccess', _97 => _97.name]) || `arg${index}`;
+    const name = _optionalChain([tupleMember, 'access', _93 => _93.label, 'optionalAccess', _94 => _94.name]) || `arg${index}`;
     let innerType = tupleMember.elementType;
     let optional = tupleMember.optional;
     if (t30.isTSOptionalType(innerType)) {
@@ -3618,8 +3547,8 @@ function resolveTupleElementParam(element, index) {
 function resolveDefinePropsIface(path9, ctx) {
   const { node } = path9;
   const [runtimeArg] = node.arguments;
-  const tsParams = _optionalChain([node, 'access', _98 => _98.typeParameters, 'optionalAccess', _99 => _99.params]);
-  if (_optionalChain([tsParams, 'optionalAccess', _100 => _100.length])) {
+  const tsParams = _optionalChain([node, 'access', _95 => _95.typeParameters, 'optionalAccess', _96 => _96.params]);
+  if (_optionalChain([tsParams, 'optionalAccess', _97 => _97.length])) {
     const { propsTSIface } = ctx.scriptData;
     propsTSIface.propsTypes = tsParams;
     return;
@@ -3674,7 +3603,7 @@ function processInferredTypes2(ctx, runtimeArg) {
     {
       source,
       file: filename,
-      loc: _optionalChain([runtimeArg, 'optionalAccess', _101 => _101.loc])
+      loc: _optionalChain([runtimeArg, 'optionalAccess', _98 => _98.loc])
     }
   );
 }
@@ -3785,7 +3714,7 @@ function createSlotScopeParam(props, ctx) {
   const propsSigns = [];
   const { reactiveBindings } = ctx.templateData;
   props.forEach(({ prop, tsType }) => {
-    const foundBindingValue = _optionalChain([reactiveBindings, 'access', _102 => _102[prop], 'optionalAccess', _103 => _103.value]);
+    const foundBindingValue = _optionalChain([reactiveBindings, 'access', _99 => _99[prop], 'optionalAccess', _100 => _100.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);
@@ -3817,7 +3746,7 @@ function collectLocalTypeDeclarations(path9) {
       declarations.set(statement.id.name, {
         type: t33.tsTypeLiteral(statement.body.body),
         // 将接口体转换为类型字面量
-        hasTypeParameters: !!_optionalChain([statement, 'access', _104 => _104.typeParameters, 'optionalAccess', _105 => _105.params, 'access', _106 => _106.length])
+        hasTypeParameters: !!_optionalChain([statement, 'access', _101 => _101.typeParameters, 'optionalAccess', _102 => _102.params, 'access', _103 => _103.length])
         // 检查是否有泛型参数
       });
       continue;
@@ -3826,7 +3755,7 @@ function collectLocalTypeDeclarations(path9) {
       declarations.set(statement.id.name, {
         type: statement.typeAnnotation,
         // 直接使用类型注解
-        hasTypeParameters: !!_optionalChain([statement, 'access', _107 => _107.typeParameters, 'optionalAccess', _108 => _108.params, 'access', _109 => _109.length])
+        hasTypeParameters: !!_optionalChain([statement, 'access', _104 => _104.typeParameters, 'optionalAccess', _105 => _105.params, 'access', _106 => _106.length])
         // 检查是否有泛型参数
       });
       continue;
@@ -3837,14 +3766,14 @@ function collectLocalTypeDeclarations(path9) {
         declarations.set(declaration.id.name, {
           type: t33.tsTypeLiteral(declaration.body.body),
           // 将接口体转换为类型字面量
-          hasTypeParameters: !!_optionalChain([declaration, 'access', _110 => _110.typeParameters, 'optionalAccess', _111 => _111.params, 'access', _112 => _112.length])
+          hasTypeParameters: !!_optionalChain([declaration, 'access', _107 => _107.typeParameters, 'optionalAccess', _108 => _108.params, 'access', _109 => _109.length])
           // 检查是否有泛型参数
         });
       } else if (t33.isTSTypeAliasDeclaration(declaration)) {
         declarations.set(declaration.id.name, {
           type: declaration.typeAnnotation,
           // 直接使用类型注解
-          hasTypeParameters: !!_optionalChain([declaration, 'access', _113 => _113.typeParameters, 'optionalAccess', _114 => _114.params, 'access', _115 => _115.length])
+          hasTypeParameters: !!_optionalChain([declaration, 'access', _110 => _110.typeParameters, 'optionalAccess', _111 => _111.params, 'access', _112 => _112.length])
           // 检查是否有泛型参数
         });
       }
@@ -3882,7 +3811,7 @@ function resolveSlotType(tsType, options) {
   }
   if (t34.isTSTypeReference(tsType)) {
     let shouldRecordReactNode = false;
-    if (_optionalChain([tsType, 'access', _116 => _116.typeParameters, 'optionalAccess', _117 => _117.params, 'access', _118 => _118.length])) {
+    if (_optionalChain([tsType, 'access', _113 => _113.typeParameters, 'optionalAccess', _114 => _114.params, 'access', _115 => _115.length])) {
       const params = [];
       for (const param of tsType.typeParameters.params) {
         const resolved2 = resolveSlotType(param, options);
@@ -4046,7 +3975,7 @@ function resolveSlotPropFromMember(member) {
         shouldRecordReactNode: false
       };
     }
-    const typeAnnotation = _optionalChain([member, 'access', _119 => _119.typeAnnotation, 'optionalAccess', _120 => _120.typeAnnotation]);
+    const typeAnnotation = _optionalChain([member, 'access', _116 => _116.typeAnnotation, 'optionalAccess', _117 => _117.typeAnnotation]);
     const callable = typeAnnotation ? resolveCallableType(typeAnnotation) : null;
     if (!callable) {
       return {
@@ -4078,8 +4007,8 @@ function resolveSlotPropFromMember(member) {
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/define-slots.ts
 function resolveDefineSlotsIface(path9, ctx) {
   const { node } = path9;
-  const tsParams = _optionalChain([node, 'access', _121 => _121.typeParameters, 'optionalAccess', _122 => _122.params]);
-  if (!_optionalChain([tsParams, 'optionalAccess', _123 => _123.length])) return;
+  const tsParams = _optionalChain([node, 'access', _118 => _118.typeParameters, 'optionalAccess', _119 => _119.params]);
+  if (!_optionalChain([tsParams, 'optionalAccess', _120 => _120.length])) return;
   const {
     propsTSIface: { slotTypes }
   } = ctx.scriptData;
@@ -4395,11 +4324,11 @@ function analyzeDeps(node, ctx, parentPath) {
     const bindingPath = binding.path;
     const declaratorPath = getVariableDeclaratorPath(bindingPath);
     const isReactiveVarBinding = !!declaratorPath && isReactiveBinding(declaratorPath.node);
-    const nodeInit = _optionalChain([declaratorPath, 'optionalAccess', _124 => _124.node, 'access', _125 => _125.init]);
+    const nodeInit = _optionalChain([declaratorPath, 'optionalAccess', _121 => _121.node, 'access', _122 => _122.init]);
     const isReactiveApiCallVarBinding = !!declaratorPath && t38.isCallExpression(nodeInit) && t38.isIdentifier(nodeInit.callee) && reactiveStateApis.has(nodeInit.callee.name);
     const isHookCallVarBinding = !!declaratorPath && t38.isCallExpression(nodeInit) && isHookLikeCallee(nodeInit.callee);
     const isFunctionBinding = bindingPath.isFunctionDeclaration() || !!declaratorPath && !!nodeInit && (t38.isArrowFunctionExpression(nodeInit) || t38.isFunctionExpression(nodeInit));
-    const isReactiveFunctionBinding = isFunctionBinding && (isReactiveBinding(_optionalChain([declaratorPath, 'optionalAccess', _126 => _126.node])) || isReactiveBinding(bindingPath.node));
+    const isReactiveFunctionBinding = isFunctionBinding && (isReactiveBinding(_optionalChain([declaratorPath, 'optionalAccess', _123 => _123.node])) || isReactiveBinding(bindingPath.node));
     return isReactiveVarBinding || isReactiveApiCallVarBinding || isHookCallVarBinding || isReactiveFunctionBinding;
   }
   function isHookLikeCallee(callee) {
@@ -4506,7 +4435,7 @@ function isNestedMemberObject(path9) {
 }
 function isReactiveBinding(node) {
   if (!node) return false;
-  return !!_optionalChain([getScriptNodeMeta, 'call', _127 => _127(node), 'optionalAccess', _128 => _128.is_reactive]);
+  return !!_optionalChain([getScriptNodeMeta, 'call', _124 => _124(node), 'optionalAccess', _125 => _125.is_reactive]);
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-analysis-only-adapter.ts
@@ -4577,7 +4506,7 @@ function isVueImportBinding(binding) {
   if (!bindingPath.isImportSpecifier() && !bindingPath.isImportDefaultSpecifier() && !bindingPath.isImportNamespaceSpecifier()) {
     return false;
   }
-  const parent = _optionalChain([bindingPath, 'access', _129 => _129.parentPath, 'optionalAccess', _130 => _130.node]);
+  const parent = _optionalChain([bindingPath, 'access', _126 => _126.parentPath, 'optionalAccess', _127 => _127.node]);
   if (!parent || !t39.isImportDeclaration(parent)) {
     return false;
   }
@@ -4604,7 +4533,7 @@ function resolveArrowFnDeps(ctx, ast) {
       const newNode = createUseCallback(node, deps);
       const declaratorPath = getVariableDeclaratorPath(path9);
       recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.useCallback);
-      setScriptNodeMeta(_optionalChain([declaratorPath, 'optionalAccess', _131 => _131.node]), { is_reactive: true, reactive_type: "indirect" });
+      setScriptNodeMeta(_optionalChain([declaratorPath, 'optionalAccess', _128 => _128.node]), { is_reactive: true, reactive_type: "indirect" });
       replaceNode(path9, newNode, node);
     }
   };
@@ -4663,8 +4592,8 @@ function resolveElementRef(ctx) {
         return;
       }
       if (isCompRefBindings) {
-        const varDeclaratorPath = _optionalChain([getVariableDeclaratorPath, 'call', _132 => _132(path9), 'optionalAccess', _133 => _133.node]);
-        if (!t40.isIdentifier(_optionalChain([varDeclaratorPath, 'optionalAccess', _134 => _134.id]))) {
+        const varDeclaratorPath = _optionalChain([getVariableDeclaratorPath, 'call', _129 => _129(path9), 'optionalAccess', _130 => _130.node]);
+        if (!t40.isIdentifier(_optionalChain([varDeclaratorPath, 'optionalAccess', _131 => _131.id]))) {
           return;
         }
         const varName = varDeclaratorPath.id.name;
@@ -4687,7 +4616,7 @@ function resolveTypeParameters(ctx, path9) {
     scriptData
   } = ctx;
   const { node } = path9;
-  const varDeclaratorNode = _optionalChain([getVariableDeclaratorPath, 'call', _135 => _135(path9), 'optionalAccess', _136 => _136.node]);
+  const varDeclaratorNode = _optionalChain([getVariableDeclaratorPath, 'call', _132 => _132(path9), 'optionalAccess', _133 => _133.node]);
   if (!scriptData.lang.startsWith("ts") || !varDeclaratorNode) {
     return;
   }
@@ -4705,11 +4634,11 @@ function resolveRefValueToCurrent(path9) {
     return;
   }
   const rootPath = findRootVariablePath(path9);
-  if (!_optionalChain([rootPath, 'optionalAccess', _137 => _137.node]) || !t40.isCallExpression(rootPath.node.init) || !isCalleeNamed(rootPath.node.init, REACT_API_MAP.useRef)) {
+  if (!_optionalChain([rootPath, 'optionalAccess', _134 => _134.node]) || !t40.isCallExpression(rootPath.node.init) || !isCalleeNamed(rootPath.node.init, REACT_API_MAP.useRef)) {
     return;
   }
   const rootId = findRootIdentifier(node);
-  if (!t40.isIdentifier(node.object) || node.object.name !== _optionalChain([rootId, 'optionalAccess', _138 => _138.name])) {
+  if (!t40.isIdentifier(node.object) || node.object.name !== _optionalChain([rootId, 'optionalAccess', _135 => _135.name])) {
     return;
   }
   node.property.name = "current";
@@ -4810,7 +4739,7 @@ function resolveProvide(ctx) {
   return {
     CallExpression(path9) {
       const { node } = path9;
-      const providerTarget = _optionalChain([ADAPTER_RULES, 'access', _139 => _139.runtime, 'access', _140 => _140[VUE_API_MAP.provide], 'optionalAccess', _141 => _141.target]);
+      const providerTarget = _optionalChain([ADAPTER_RULES, 'access', _136 => _136.runtime, 'access', _137 => _137[VUE_API_MAP.provide], 'optionalAccess', _138 => _138.target]);
       const isProvideCall = isCalleeNamed(node, VUE_API_MAP.provide) || providerTarget && isCalleeNamed(node, providerTarget);
       if (!isProvideCall) return;
       const { provide } = ctx.scriptData;
@@ -4828,7 +4757,7 @@ function findOrCreateCtxProvider(root) {
     return root;
   }
   let cur = root.provide;
-  while (_optionalChain([cur, 'optionalAccess', _142 => _142.isOccupied])) {
+  while (_optionalChain([cur, 'optionalAccess', _139 => _139.isOccupied])) {
     cur = _nullishCoalesce(cur.provide, () => ( {}));
   }
   return cur || (root.provide = {});
@@ -4885,7 +4814,7 @@ function resolveRenameAdapter(ctx) {
       if (adapter.isTrackable) {
         const reactiveType = getReactiveType(apiName);
         const declaratorPath = getVariableDeclaratorPath(path9);
-        setScriptNodeMeta(_optionalChain([declaratorPath, 'optionalAccess', _143 => _143.node]), {
+        setScriptNodeMeta(_optionalChain([declaratorPath, 'optionalAccess', _140 => _140.node]), {
           is_reactive: true,
           reactive_type: reactiveType
         });
@@ -4903,6 +4832,10 @@ function resolveRenameAdapter(ctx) {
   };
 }
 function isVueApiReference2(path9, apiName) {
+  const whitelist = [VUE_API_MAP.defineAsyncComponent];
+  if (whitelist.includes(apiName)) {
+    return true;
+  }
   if (path9.isIdentifier()) {
     if (path9.parentPath.isCallExpression() && path9.parentPath.node.callee === path9.node) {
       return false;
@@ -4924,7 +4857,7 @@ function isVueImportBinding2(binding) {
   if (!bindingPath.isImportSpecifier() && !bindingPath.isImportDefaultSpecifier() && !bindingPath.isImportNamespaceSpecifier()) {
     return false;
   }
-  const parent = _optionalChain([bindingPath, 'access', _144 => _144.parentPath, 'optionalAccess', _145 => _145.node]);
+  const parent = _optionalChain([bindingPath, 'access', _141 => _141.parentPath, 'optionalAccess', _142 => _142.node]);
   if (!parent || !t44.isImportDeclaration(parent)) {
     return false;
   }
@@ -4976,12 +4909,12 @@ function processVueSyntax2(ast, ctx) {
 }
 function vueSyntaxProcessor2(ast, ctx, options) {
   const runExcludeThenApply = (cfg) => {
-    _optionalChain([cfg, 'access', _146 => _146.excludeBabel, 'optionalAccess', _147 => _147.forEach, 'call', _148 => _148((fn) => fn(ctx, ast))]);
-    _optionalChain([cfg, 'access', _149 => _149.applyBabel, 'optionalAccess', _150 => _150.forEach, 'call', _151 => _151((fn) => _core.traverse.call(void 0, ast, fn(ctx, ast)))]);
+    _optionalChain([cfg, 'access', _143 => _143.excludeBabel, 'optionalAccess', _144 => _144.forEach, 'call', _145 => _145((fn) => fn(ctx, ast))]);
+    _optionalChain([cfg, 'access', _146 => _146.applyBabel, 'optionalAccess', _147 => _147.forEach, 'call', _148 => _148((fn) => _core.traverse.call(void 0, ast, fn(ctx, ast)))]);
   };
   const runApplyThenExclude = (cfg) => {
-    _optionalChain([cfg, 'access', _152 => _152.applyBabel, 'optionalAccess', _153 => _153.forEach, 'call', _154 => _154((fn) => _core.traverse.call(void 0, ast, fn(ctx, ast)))]);
-    _optionalChain([cfg, 'access', _155 => _155.excludeBabel, 'optionalAccess', _156 => _156.forEach, 'call', _157 => _157((fn) => fn(ctx, ast))]);
+    _optionalChain([cfg, 'access', _149 => _149.applyBabel, 'optionalAccess', _150 => _150.forEach, 'call', _151 => _151((fn) => _core.traverse.call(void 0, ast, fn(ctx, ast)))]);
+    _optionalChain([cfg, 'access', _152 => _152.excludeBabel, 'optionalAccess', _153 => _153.forEach, 'call', _154 => _154((fn) => fn(ctx, ast))]);
   };
   runExcludeThenApply(options.preprocess);
   runExcludeThenApply(options.process);
@@ -5070,7 +5003,7 @@ function isRouterLinkBooleanCustomProp(prop) {
 var strCodeTypes = {
   isIdentifier: isIdentifier24,
   isSimpleExpression,
-  isStringLiteral: isStringLiteral13
+  isStringLiteral: isStringLiteral12
 };
 function isSimpleExpression(code, excludeVar = false) {
   let node;
@@ -5107,7 +5040,7 @@ function isIdentifier24(code) {
     return false;
   }
 }
-function isStringLiteral13(code) {
+function isStringLiteral12(code) {
   try {
     const node = _parser.parseExpression.call(void 0, code);
     return t45.isStringLiteral(node);
@@ -5220,12 +5153,12 @@ function wrapSingleQuotes(content, condition) {
   return condition || strCodeTypes.isStringLiteral(content) ? `'${content}'` : content;
 }
 function checkPropIsDynamicKey(ctx, node) {
-  const isKeyStatic = _optionalChain([node, 'access', _158 => _158.arg, 'optionalAccess', _159 => _159.isStatic]);
+  const isKeyStatic = _optionalChain([node, 'access', _155 => _155.arg, 'optionalAccess', _156 => _156.isStatic]);
   const { source, filename } = ctx;
   if (node.rawName === "v-bind" && !node.name) {
     logger.warn("Keyless v-bind will overwrite all previously declared props at runtime.", {
       source,
-      loc: _optionalChain([node, 'access', _160 => _160.arg, 'optionalAccess', _161 => _161.loc]),
+      loc: _optionalChain([node, 'access', _157 => _157.arg, 'optionalAccess', _158 => _158.loc]),
       file: filename
     });
     return;
@@ -5233,7 +5166,7 @@ function checkPropIsDynamicKey(ctx, node) {
   if (isKeyStatic === false) {
     logger.warn("Avoid using dynamic slot names, as they generate complex JSX prop expressions.", {
       source,
-      loc: _optionalChain([node, 'access', _162 => _162.arg, 'optionalAccess', _163 => _163.loc]),
+      loc: _optionalChain([node, 'access', _159 => _159.arg, 'optionalAccess', _160 => _160.loc]),
       file: filename
     });
   }
@@ -5254,21 +5187,21 @@ function resolvePropAsBabelExp(ir, ctx) {
     target.content = valueName;
     target.ast = t46.jsxIdentifier(valueName);
   };
-  const setValueExpression = (target, content, isStringLiteral14) => {
+  const setValueExpression = (target, content, isStringLiteral13) => {
     target.content = content;
-    target.ast = resolveStringExpr(content, ctx, isStringLiteral14);
+    target.ast = resolveStringExpr(content, ctx, isStringLiteral13);
   };
   const createRuntimeCall = (fnName, args) => {
     const fnArgs = args.filter(Boolean).join(",");
     return `${fnName}(${fnArgs})`;
   };
-  const applyRuntimeExpression = (expression, setName = false, nameIdentifier, isStringLiteral14) => {
+  const applyRuntimeExpression = (expression, setName = false, nameIdentifier, isStringLiteral13) => {
     if (setName && nameIdentifier) {
       setNameIdentifier(nameExp, nameIdentifier);
     }
     const dir = ADAPTER_RULES.runtime.dir;
     recordImport(ctx, dir.package, dir.target);
-    setValueExpression(value.babelExp, expression, isStringLiteral14);
+    setValueExpression(value.babelExp, expression, isStringLiteral13);
   };
   if (ir.isKeyLessVBind) {
     const dirKeyless = ADAPTER_RULES.runtime.dirKeyless;
@@ -5278,19 +5211,19 @@ function resolvePropAsBabelExp(ir, ctx) {
   }
   if (isClassAttr(name) && !value.isStringLiteral && !valueContent.startsWith(STYLE_MODULE_NAME)) {
     const dirCls = ADAPTER_RULES.runtime.dirCls;
-    const arg = _optionalChain([mergedItems, 'optionalAccess', _164 => _164.join, 'call', _165 => _165(",")]) || wrapSingleQuotes(valueContent);
+    const arg = _optionalChain([mergedItems, 'optionalAccess', _161 => _161.join, 'call', _162 => _162(",")]) || wrapSingleQuotes(valueContent);
     const expression = createRuntimeCall(dirCls.target, [arg]);
     applyRuntimeExpression(expression, true, name);
     return;
   }
-  if (isStyleAttr(name) && (!isSimpleStyle(valueContent) || _optionalChain([mergedItems, 'optionalAccess', _166 => _166.some, 'call', _167 => _167((item) => !isSimpleStyle(item))]))) {
+  if (isStyleAttr(name) && (!isSimpleStyle(valueContent) || _optionalChain([mergedItems, 'optionalAccess', _163 => _163.some, 'call', _164 => _164((item) => !isSimpleStyle(item))]))) {
     const dirStyle = ADAPTER_RULES.runtime.dirStyle;
-    const arg = _optionalChain([mergedItems, 'optionalAccess', _168 => _168.join, 'call', _169 => _169(",")]) || valueContent;
+    const arg = _optionalChain([mergedItems, 'optionalAccess', _165 => _165.join, 'call', _166 => _166(",")]) || valueContent;
     const expression = createRuntimeCall(dirStyle.target, [arg]);
     applyRuntimeExpression(expression, true, name);
     return;
   }
-  if (ir.type === 3 /* EVENT */ && _optionalChain([ir, 'access', _170 => _170.modifiers, 'optionalAccess', _171 => _171.length])) {
+  if (ir.type === 3 /* EVENT */ && _optionalChain([ir, 'access', _167 => _167.modifiers, 'optionalAccess', _168 => _168.length])) {
     const dirOn = ADAPTER_RULES.runtime.dirOn;
     const eventName = wrapSingleQuotes(ir.__vOnEvName || name, ir.isStatic);
     const expression = createRuntimeCall(dirOn.target, [eventName, valueContent]);
@@ -5345,7 +5278,7 @@ function resolveElementChildrenRules(children, ctx, parentIR, ir) {
       continue;
     }
     const nodeIR = child;
-    if (_optionalChain([parentIR, 'optionalAccess', _172 => _172.isBuiltIn])) {
+    if (_optionalChain([parentIR, 'optionalAccess', _169 => _169.isBuiltIn])) {
       if (parentIR.tag == VUE_API_MAP.Transition) {
         resolveTransitionRules(nodeIR, parentIR, ir, ctx);
       }
@@ -5386,7 +5319,7 @@ function walkElementNodes(node, onElement) {
 }
 function resolveDefaultStyleModuleName(node) {
   const { exp } = node;
-  if (_optionalChain([exp, 'optionalAccess', _173 => _173.type]) !== _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
+  if (_optionalChain([exp, 'optionalAccess', _170 => _170.type]) !== _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
     return;
   }
   if (exp.content.includes("$style")) {
@@ -5435,7 +5368,7 @@ function injectStyleScopeAttribute(node, ctx) {
         break;
       }
     }
-    if (prop.type === _compilercore.NodeTypes.DIRECTIVE && _optionalChain([prop, 'access', _174 => _174.arg, 'optionalAccess', _175 => _175.type]) === _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
+    if (prop.type === _compilercore.NodeTypes.DIRECTIVE && _optionalChain([prop, 'access', _171 => _171.arg, 'optionalAccess', _172 => _172.type]) === _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
       if (getHasClassOrId(prop.arg.content)) {
         hasClassOrId = true;
         break;
@@ -5495,7 +5428,7 @@ function mergeStyleProps(oldAttr, newAttr) {
   const oldStyle = oldAttr.value.content;
   const newStyle = parseStyleString(newAttr.value.content);
   let merged = oldAttr.value.merge;
-  if (!_optionalChain([merged, 'optionalAccess', _176 => _176.length])) {
+  if (!_optionalChain([merged, 'optionalAccess', _173 => _173.length])) {
     merged = oldAttr.value.merge = [oldStyle, newStyle];
   } else {
     merged.push(newStyle);
@@ -5525,7 +5458,7 @@ function warnUnsupportedVueDollarVar(ctx, node) {
   const { source, filename } = ctx;
   let value = "";
   let loc;
-  if (node.type === _compilercore.NodeTypes.DIRECTIVE && _optionalChain([node, 'access', _177 => _177.exp, 'optionalAccess', _178 => _178.type]) === _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
+  if (node.type === _compilercore.NodeTypes.DIRECTIVE && _optionalChain([node, 'access', _174 => _174.exp, 'optionalAccess', _175 => _175.type]) === _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
     value = node.exp.content;
     loc = node.exp.loc;
   } else if (node.type === _compilercore.NodeTypes.INTERPOLATION && node.content.type === _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
@@ -5579,11 +5512,11 @@ function resolveRefProp(prop, ctx, nodeIR) {
   } = ctx;
   let propIR;
   if (prop.type === _compilercore.NodeTypes.ATTRIBUTE) {
-    const tag = _optionalChain([prop, 'access', _179 => _179.value, 'optionalAccess', _180 => _180.content]);
+    const tag = _optionalChain([prop, 'access', _176 => _176.value, 'optionalAccess', _177 => _177.content]);
     if (!tag) return;
     collectComponentRef(tag, ctx);
     const domRefBinding = Object.values(refBindings.domRefs).find((r) => r.tag === tag);
-    const refVar = _optionalChain([domRefBinding, 'optionalAccess', _181 => _181.name]) || _optionalChain([refBindings, 'access', _182 => _182.componentRefs, 'access', _183 => _183[tag], 'optionalAccess', _184 => _184.name]);
+    const refVar = _optionalChain([domRefBinding, 'optionalAccess', _178 => _178.name]) || _optionalChain([refBindings, 'access', _179 => _179.componentRefs, 'access', _180 => _180[tag], 'optionalAccess', _181 => _181.name]);
     propIR = createPropsIR("ref", "ref", refVar || "null");
   } else {
     const exp = prop.exp;
@@ -5619,14 +5552,30 @@ function collectComponentRef(tag, ctx) {
 
 
 
-function resolveTemplateNodeKey(vueNode, keyContent) {
-  const firstNode = vueNode.children[0];
-  if (!firstNode) return;
-  const hasKeyProp = firstNode.props.some(
+
+function resolveTemplateNodeKey(templNode, keyContent, ctx) {
+  const { filename, source } = ctx;
+  const { children, loc } = templNode;
+  if (children.length > 1) {
+    logger.warn(
+      "Expected <template> with `:key` to have a single parent element; otherwise, the key cannot be transferred to the first child.",
+      {
+        file: filename,
+        source,
+        loc
+      }
+    );
+    return;
+  }
+  const [firstChild] = children;
+  if (_optionalChain([firstChild, 'optionalAccess', _182 => _182.type]) !== _compilercore.NodeTypes.ELEMENT || firstChild.tagType === _compilercore.ElementTypes.TEMPLATE || firstChild.tagType === _compilercore.ElementTypes.SLOT) {
+    return;
+  }
+  const hasKeyProp = firstChild.props.some(
     (p) => p.type === _compilercore.NodeTypes.DIRECTIVE && p.name === "key"
   );
   if (hasKeyProp) return;
-  firstNode.props.push(createSimpleVueBind("key", keyContent));
+  firstChild.props.push(createSimpleVueBind("key", keyContent));
 }
 function createSimpleVueBind(name, value) {
   return {
@@ -5656,8 +5605,8 @@ function createSimpleVueBind(name, value) {
 function resolveDynamicAttributeProp(directive, ir, ctx, vueNode, nodeIR) {
   const arg = directive.arg;
   const exp = directive.exp;
-  const name = _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _185 => _185.content]), () => ( ""));
-  const content = _nullishCoalesce(_optionalChain([exp, 'optionalAccess', _186 => _186.content]), () => ( "true"));
+  const name = _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _183 => _183.content]), () => ( ""));
+  const content = _nullishCoalesce(_optionalChain([exp, 'optionalAccess', _184 => _184.content]), () => ( "true"));
   warnUnsupportedVueDollarVar(ctx, directive);
   if (name === "is") {
     resolveDynamicIsProp(directive, ir, ctx, nodeIR);
@@ -5668,11 +5617,11 @@ function resolveDynamicAttributeProp(directive, ir, ctx, vueNode, nodeIR) {
     return;
   }
   if (vueNode.tag === "template" && name === "key") {
-    resolveTemplateNodeKey(vueNode, content);
+    resolveTemplateNodeKey(vueNode, content, ctx);
     return;
   }
   const propIR = createPropsIR(directive.rawName, name, content);
-  propIR.isStatic = _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _187 => _187.isStatic]), () => ( true));
+  propIR.isStatic = _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _185 => _185.isStatic]), () => ( true));
   checkPropIsDynamicKey(ctx, directive);
   resolvePropertyIR(propIR, ir, ctx, nodeIR, true);
 }
@@ -5686,12 +5635,12 @@ function resolvePropertyIR(propsIR, ir, ctx, nodeIR, isDynamic = false) {
     content = propsIR.value.content = parseStyleString(content);
   }
   if (isDynamic) {
-    const isStringLiteral14 = strCodeTypes.isStringLiteral(content);
-    if (isStringLiteral14) {
+    const isStringLiteral13 = strCodeTypes.isStringLiteral(content);
+    if (isStringLiteral13) {
       content = normalizeString(content);
       propsIR.value.content = content;
     }
-    propsIR.value.isStringLiteral = isStringLiteral14;
+    propsIR.value.isStringLiteral = isStringLiteral13;
   }
   const existing = findSameProp(nodeIR.props, propsIR);
   if (existing) {
@@ -5711,7 +5660,7 @@ function normalizeString(s) {
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-attribute-prop.ts
 function resolveAttributeProp(attribute, ir, ctx, nodeIR) {
   const name = attribute.name;
-  const content = _nullishCoalesce(_optionalChain([attribute, 'access', _188 => _188.value, 'optionalAccess', _189 => _189.content]), () => ( "true"));
+  const content = _nullishCoalesce(_optionalChain([attribute, 'access', _186 => _186.value, 'optionalAccess', _187 => _187.content]), () => ( "true"));
   if (name === "is") {
     resolveStaticIsProp(content, ir, ctx, nodeIR);
     return;
@@ -5806,10 +5755,10 @@ function resolveRouterLinkVSlotProp(directive, nodeIR, ctx) {
     type: 2 /* SLOT */,
     name: "customRender",
     rawName: _nullishCoalesce(directive.rawName, () => ( "v-slot")),
-    isStatic: _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _190 => _190.isStatic]), () => ( true)),
+    isStatic: _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _188 => _188.isStatic]), () => ( true)),
     isScoped: true,
     callback: {
-      arg: _nullishCoalesce(_optionalChain([exp, 'optionalAccess', _191 => _191.content, 'optionalAccess', _192 => _192.trim, 'call', _193 => _193()]), () => ( "")),
+      arg: _nullishCoalesce(_optionalChain([exp, 'optionalAccess', _189 => _189.content, 'optionalAccess', _190 => _190.trim, 'call', _191 => _191()]), () => ( "")),
       exp: []
     }
   };
@@ -5825,10 +5774,10 @@ function resolveVFor(directive, ir, ctx, nodeIR) {
   };
 }
 function resolveForResult(forParseResult) {
-  const source = _optionalChain([forParseResult, 'access', _194 => _194.source, 'optionalAccess', _195 => _195.content]);
-  const value = _optionalChain([forParseResult, 'access', _196 => _196.value, 'optionalAccess', _197 => _197.content]);
-  const index = _optionalChain([forParseResult, 'access', _198 => _198.index, 'optionalAccess', _199 => _199.content]);
-  const key = _optionalChain([forParseResult, 'access', _200 => _200.key, 'optionalAccess', _201 => _201.content]);
+  const source = _optionalChain([forParseResult, 'access', _192 => _192.source, 'optionalAccess', _193 => _193.content]);
+  const value = _optionalChain([forParseResult, 'access', _194 => _194.value, 'optionalAccess', _195 => _195.content]);
+  const index = _optionalChain([forParseResult, 'access', _196 => _196.index, 'optionalAccess', _197 => _197.content]);
+  const key = _optionalChain([forParseResult, 'access', _198 => _198.key, 'optionalAccess', _199 => _199.content]);
   return {
     source,
     value,
@@ -5848,7 +5797,7 @@ function resolveVHtml(directive, ir, ctx, nodeIR) {
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-if.ts
 function resolveVIf(directive, ir, ctx, nodeIR, siblingNodesIR) {
   const name = directive.name === "else-if" ? "elseIf" : directive.name;
-  const value = _nullishCoalesce(_optionalChain([directive, 'access', _202 => _202.exp, 'optionalAccess', _203 => _203.content]), () => ( "true"));
+  const value = _nullishCoalesce(_optionalChain([directive, 'access', _200 => _200.exp, 'optionalAccess', _201 => _201.content]), () => ( "true"));
   const prevNode = siblingNodesIR[siblingNodesIR.length - 1];
   const isElseBranch = name === "else" || name === "elseIf";
   let hasError = false;
@@ -5887,7 +5836,7 @@ function resolveVIf(directive, ir, ctx, nodeIR, siblingNodesIR) {
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-memo.ts
 function resolveVMemo(directive, _ir, ctx, nodeIR) {
   const exp = directive.exp;
-  let value = _optionalChain([exp, 'optionalAccess', _204 => _204.content]);
+  let value = _optionalChain([exp, 'optionalAccess', _202 => _202.content]);
   if (value !== void 0) {
     if (!value.trim() || !value.startsWith("[") && !value.endsWith("]")) {
       const { source, filename } = ctx;
@@ -5927,14 +5876,14 @@ function resolveVModel(directive, ir, ctx, vueNode, nodeIR) {
   const getterName = exp.content;
   const isComponent = vueNode.tagType === _compilercore.ElementTypes.COMPONENT;
   const inputType = resolveHtmlInput(vueNode, isComponent);
-  const propName = _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _205 => _205.content]), () => ( resolveModelPropName(inputType, isComponent)));
+  const propName = _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _203 => _203.content]), () => ( resolveModelPropName(inputType, isComponent)));
   let valuePropIR;
   let eventPropIR;
   if (isComponent) {
     valuePropIR = createPropsIR("v-model", propName, getterName);
     const eventReactName = `onUpdate${capitalize(camelCase(propName))}`;
     const eventVueName = `update:${propName}`;
-    const isTS = _optionalChain([ctx, 'access', _206 => _206.scriptData, 'optionalAccess', _207 => _207.lang, 'optionalAccess', _208 => _208.startsWith, 'call', _209 => _209("ts")]);
+    const isTS = _optionalChain([ctx, 'access', _204 => _204.scriptData, 'optionalAccess', _205 => _205.lang, 'optionalAccess', _206 => _206.startsWith, 'call', _207 => _207("ts")]);
     const valueArg = isTS ? "value: any" : "value";
     const processedValue = applyValueModifiers("value", modifiers);
     const handlerBody = `(${valueArg}) => { ${getterName} = ${processedValue} }`;
@@ -5972,7 +5921,7 @@ function getRadioValue(vueNode) {
   const valueAttr = vueNode.props.find(
     (prop) => prop.type === _compilercore.NodeTypes.ATTRIBUTE && prop.name === "value"
   );
-  if (!_optionalChain([valueAttr, 'optionalAccess', _210 => _210.value, 'optionalAccess', _211 => _211.content])) return '""';
+  if (!_optionalChain([valueAttr, 'optionalAccess', _208 => _208.value, 'optionalAccess', _209 => _209.content])) return '""';
   const content = valueAttr.value.content;
   return /^['"]/.test(content) ? content : `"${content}"`;
 }
@@ -5982,7 +5931,7 @@ function resolveHtmlInput(node, isComponent) {
   const typeProp = node.props.find(
     (prop) => prop.type === _compilercore.NodeTypes.ATTRIBUTE && prop.name === "type"
   );
-  return _optionalChain([typeProp, 'optionalAccess', _212 => _212.value, 'optionalAccess', _213 => _213.content, 'optionalAccess', _214 => _214.toLowerCase, 'call', _215 => _215()]);
+  return _optionalChain([typeProp, 'optionalAccess', _210 => _210.value, 'optionalAccess', _211 => _211.content, 'optionalAccess', _212 => _212.toLowerCase, 'call', _213 => _213()]);
 }
 function applyValueModifiers(valueExp, modifiers) {
   let result = valueExp;
@@ -6067,7 +6016,7 @@ function resolveVSlotProp(directive, ir, ctx) {
   const name = !arg || arg.content === "default" ? "children" : arg.content;
   const content = !isScoped ? [] : void 0;
   const callback = isScoped ? {
-    arg: _nullishCoalesce(_optionalChain([exp, 'optionalAccess', _216 => _216.content, 'optionalAccess', _217 => _217.trim, 'call', _218 => _218()]), () => ( "")),
+    arg: _nullishCoalesce(_optionalChain([exp, 'optionalAccess', _214 => _214.content, 'optionalAccess', _215 => _215.trim, 'call', _216 => _216()]), () => ( "")),
     exp: []
   } : void 0;
   checkPropIsDynamicKey(ctx, directive);
@@ -6075,7 +6024,7 @@ function resolveVSlotProp(directive, ir, ctx) {
     type: 2 /* SLOT */,
     name,
     rawName: _nullishCoalesce(directive.rawName, () => ( "default")),
-    isStatic: _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _219 => _219.isStatic]), () => ( true)),
+    isStatic: _nullishCoalesce(_optionalChain([arg, 'optionalAccess', _217 => _217.isStatic]), () => ( true)),
     isScoped,
     content,
     callback
@@ -6138,7 +6087,7 @@ function resolveElementNode(node, ir, ctx, siblingNodesIR) {
   if (routerAdapter) {
     if (!ctx.route) ctx.route = true;
     nodeIR.isRoute = true;
-    recordImport(ctx, _optionalChain([routerAdapter, 'optionalAccess', _220 => _220.package]), routerAdapter.target);
+    recordImport(ctx, _optionalChain([routerAdapter, 'optionalAccess', _218 => _218.package]), routerAdapter.target);
   }
   resolveProps(node, ir, ctx, nodeIR, siblingNodesIR);
   return nodeIR;
@@ -6285,7 +6234,7 @@ function resolveSlotProps(node, ctx) {
   for (const prop of node.props) {
     if (prop.type === _compilercore.NodeTypes.ATTRIBUTE) {
       const attr = prop.name;
-      const value = _optionalChain([prop, 'access', _221 => _221.value, 'optionalAccess', _222 => _222.content, 'access', _223 => _223.trim, 'call', _224 => _224()]);
+      const value = _optionalChain([prop, 'access', _219 => _219.value, 'optionalAccess', _220 => _220.content, 'access', _221 => _221.trim, 'call', _222 => _222()]);
       if (attr === "name" && value) {
         result.name = camelCase(value);
       } else {
@@ -6375,19 +6324,19 @@ function resolveTemplate2(root, ctx) {
 // src/core/transform/sfc/index.ts
 function transform(ast, ctx, options) {
   const { template, script, style } = ast;
-  const templateIR = resolveTemplate2(_optionalChain([template, 'optionalAccess', _225 => _225.ast]), ctx);
-  const scriptIR = resolveScript2(_optionalChain([script, 'optionalAccess', _226 => _226.ast]), ctx);
+  const templateIR = resolveTemplate2(_optionalChain([template, 'optionalAccess', _223 => _223.ast]), ctx);
+  const scriptIR = resolveScript2(_optionalChain([script, 'optionalAccess', _224 => _224.ast]), ctx);
   const result = {
     template: templateIR,
     script: scriptIR,
-    style: _optionalChain([style, 'optionalAccess', _227 => _227.source, 'optionalAccess', _228 => _228.content])
+    style: _optionalChain([style, 'optionalAccess', _225 => _225.source, 'optionalAccess', _226 => _226.content])
   };
-  executePlugins(_optionalChain([options, 'optionalAccess', _229 => _229.plugins]), result, ctx);
+  executePlugins(_optionalChain([options, 'optionalAccess', _227 => _227.plugins]), result, ctx);
   return result;
 }
 
 // package.json
-var version = "1.6.0";
+var version = "1.6.2";
 var bin = {
   vureact: "./bin/vureact.js"
 };
@@ -6581,7 +6530,7 @@ var Helper = (_class5 = class {
   __init8() {this.outDir = "react-app"}
   constructor(opts) {;_class5.prototype.__init7.call(this);_class5.prototype.__init8.call(this);
     this.compilerOpts = opts;
-    if (_optionalChain([opts, 'access', _230 => _230.output, 'optionalAccess', _231 => _231.workspace])) {
+    if (_optionalChain([opts, 'access', _228 => _228.output, 'optionalAccess', _229 => _229.workspace])) {
       this.workspaceDir = opts.output.workspace;
     }
     const excludePatterns = PathFilter.withDefaults(opts.exclude || []);
@@ -6618,7 +6567,7 @@ var Helper = (_class5 = class {
   }
   getOutDirName() {
     const { output } = this.compilerOpts;
-    return _optionalChain([output, 'optionalAccess', _232 => _232.outDir]) || this.outDir;
+    return _optionalChain([output, 'optionalAccess', _230 => _230.outDir]) || this.outDir;
   }
   getWorkspaceDir() {
     return _path2.default.resolve(this.getProjectRoot(), this.workspaceDir);
@@ -6632,7 +6581,7 @@ var Helper = (_class5 = class {
   }
   getIgnoreAssets() {
     const { output } = this.compilerOpts;
-    if (_optionalChain([output, 'optionalAccess', _233 => _233.ignoreAssets])) {
+    if (_optionalChain([output, 'optionalAccess', _231 => _231.ignoreAssets])) {
       return new Set(output.ignoreAssets.map(normalizePath));
     }
     return /* @__PURE__ */ new Set([
@@ -6715,12 +6664,12 @@ var Helper = (_class5 = class {
    */
   async formatCode({ code, fileInfo }) {
     const { format } = this.compilerOpts;
-    if (!_optionalChain([format, 'optionalAccess', _234 => _234.enabled])) return code;
-    if (_optionalChain([format, 'optionalAccess', _235 => _235.formatter]) === "builtin") {
+    if (!_optionalChain([format, 'optionalAccess', _232 => _232.enabled])) return code;
+    if (_optionalChain([format, 'optionalAccess', _233 => _233.formatter]) === "builtin") {
       return simpleFormat(code);
     }
-    const { lang } = _nullishCoalesce(_optionalChain([fileInfo, 'optionalAccess', _236 => _236.jsx]), () => ( _optionalChain([fileInfo, 'optionalAccess', _237 => _237.script])));
-    return await formatWithPrettier(code, lang, _optionalChain([format, 'optionalAccess', _238 => _238.prettierOptions]));
+    const { lang } = _nullishCoalesce(_optionalChain([fileInfo, 'optionalAccess', _234 => _234.jsx]), () => ( _optionalChain([fileInfo, 'optionalAccess', _235 => _235.script])));
+    return await formatWithPrettier(code, lang, _optionalChain([format, 'optionalAccess', _236 => _236.prettierOptions]));
   }
   /**
    * 通用的缓存校验工具函数
@@ -6754,7 +6703,7 @@ var Helper = (_class5 = class {
    * @param options.lock - 是否启用文件锁（默认false）
    */
   async writeFileWithDir(filePath, content, options) {
-    if (_optionalChain([options, 'optionalAccess', _239 => _239.lock])) {
+    if (_optionalChain([options, 'optionalAccess', _237 => _237.lock])) {
       await fileLock.updateFile(filePath, async () => content, options);
     } else {
       await _fs2.default.promises.mkdir(_path2.default.dirname(filePath), { recursive: true });
@@ -6879,7 +6828,7 @@ var Helper = (_class5 = class {
    * 获取需要排除编译的文件
    */
   getExcludes() {
-    if (!_optionalChain([this, 'access', _240 => _240.compilerOpts, 'access', _241 => _241.exclude, 'optionalAccess', _242 => _242.length])) {
+    if (!_optionalChain([this, 'access', _238 => _238.compilerOpts, 'access', _239 => _239.exclude, 'optionalAccess', _240 => _240.length])) {
       return PathFilter.withDefaults();
     }
     return this.compilerOpts.exclude;
@@ -6977,7 +6926,7 @@ function parseOnlyStyle(source, ctx, options) {
       ast: void 0
     }
   };
-  executePlugins(_optionalChain([options, 'optionalAccess', _243 => _243.plugins]), result, ctx);
+  executePlugins(_optionalChain([options, 'optionalAccess', _241 => _241.plugins]), result, ctx);
   return result;
 }
 
@@ -7111,16 +7060,16 @@ var BaseCompiler = (_class7 = class extends Helper {
     });
     const genOptions = this.prepareGenerateOptions(filename);
     const resolveSFCAndScriptFile = () => {
-      const ast = parse(source, ctx.data, { plugins: _optionalChain([plugins, 'optionalAccess', _244 => _244.parser]) });
-      const ir = transform(ast, ctx.data, { plugins: _optionalChain([plugins, 'optionalAccess', _245 => _245.transformer]) });
+      const ast = parse(source, ctx.data, { plugins: _optionalChain([plugins, 'optionalAccess', _242 => _242.parser]) });
+      const ir = transform(ast, ctx.data, { plugins: _optionalChain([plugins, 'optionalAccess', _243 => _243.transformer]) });
       const gen = generate(ir, ctx.data, {
         ...genOptions,
-        plugins: _optionalChain([plugins, 'optionalAccess', _246 => _246.codegen])
+        plugins: _optionalChain([plugins, 'optionalAccess', _244 => _244.codegen])
       });
       return this.resolveMainResult(ir, gen, ctx.data);
     };
     const resolveStyleFile = () => {
-      const result = parseOnlyStyle(source, ctx.data, { plugins: _optionalChain([plugins, 'optionalAccess', _247 => _247.parser]) });
+      const result = parseOnlyStyle(source, ctx.data, { plugins: _optionalChain([plugins, 'optionalAccess', _245 => _245.parser]) });
       return this.resolveStyleResult(result, ctx.data);
     };
     try {
@@ -7159,9 +7108,9 @@ var BaseCompiler = (_class7 = class extends Helper {
             lang
           },
           css: {
-            file: _optionalChain([styleData, 'optionalAccess', _248 => _248.filePath]),
-            hash: _optionalChain([styleData, 'optionalAccess', _249 => _249.scopeId]),
-            code: _optionalChain([ir, 'optionalAccess', _250 => _250.style])
+            file: _optionalChain([styleData, 'optionalAccess', _246 => _246.filePath]),
+            hash: _optionalChain([styleData, 'optionalAccess', _247 => _247.scopeId]),
+            code: _optionalChain([ir, 'optionalAccess', _248 => _248.style])
           }
         },
         ...base
@@ -7231,7 +7180,7 @@ var AssetManager = (_class8 = class {
       const relativeToRoot = normalizePath(this.fileCompiler.relativePath(p));
       const filename = _path2.default.basename(p).toLowerCase();
       const ext = _path2.default.extname(p).toLowerCase();
-      if (!_optionalChain([options, 'access', _251 => _251.output, 'optionalAccess', _252 => _252.ignoreAssets])) {
+      if (!_optionalChain([options, 'access', _249 => _249.output, 'optionalAccess', _250 => _250.ignoreAssets])) {
         const shouldExclude = Array.from(exclusions).some((pattern) => {
           if (pattern.endsWith(".")) {
             return filename.startsWith(pattern);
@@ -7328,12 +7277,12 @@ var CacheManager = (_class9 = class {
     const meta = { ...unit };
     delete meta.source;
     if (key === "sfc" /* SFC */) {
-       _optionalChainDelete([meta, 'access', _253 => _253.output, 'optionalAccess', _254 => _254.jsx, 'access', _255 => delete _255.code]);
-       _optionalChainDelete([meta, 'access', _256 => _256.output, 'optionalAccess', _257 => _257.css, 'access', _258 => delete _258.code]);
+       _optionalChainDelete([meta, 'access', _251 => _251.output, 'optionalAccess', _252 => _252.jsx, 'access', _253 => delete _253.code]);
+       _optionalChainDelete([meta, 'access', _254 => _254.output, 'optionalAccess', _255 => _255.css, 'access', _256 => delete _256.code]);
     } else if (key === "script" /* SCRIPT */) {
-       _optionalChainDelete([meta, 'access', _259 => _259.output, 'optionalAccess', _260 => _260.script, 'access', _261 => delete _261.code]);
+       _optionalChainDelete([meta, 'access', _257 => _257.output, 'optionalAccess', _258 => _258.script, 'access', _259 => delete _259.code]);
     } else if (key === "style" /* STYLE */) {
-       _optionalChainDelete([meta, 'access', _262 => _262.output, 'optionalAccess', _263 => _263.style, 'access', _264 => delete _264.code]);
+       _optionalChainDelete([meta, 'access', _260 => _260.output, 'optionalAccess', _261 => _261.style, 'access', _262 => delete _262.code]);
     }
     if (!this.pendingUpdates.has(key)) {
       this.pendingUpdates.set(key, []);
@@ -7403,7 +7352,7 @@ var CleanupManager = class {
           meta = m;
           const { jsx, css } = meta.output;
           await this.fileCompiler.removeOutputFile(jsx.file);
-          if (_optionalChain([css, 'optionalAccess', _265 => _265.file])) {
+          if (_optionalChain([css, 'optionalAccess', _263 => _263.file])) {
             await this.fileCompiler.removeOutputFile(css.file);
           }
           break;
@@ -7464,7 +7413,7 @@ var CompilationUnitProcessor = class {
     const isScriptFile = key === "script" /* SCRIPT */;
     const isStyleFile = key === "style" /* STYLE */;
     if (isSFC || isScriptFile) {
-      unit.hasRoute = _optionalChain([result, 'optionalAccess', _266 => _266.hasRoute]);
+      unit.hasRoute = _optionalChain([result, 'optionalAccess', _264 => _264.hasRoute]);
     }
     const resolveFileInfo = () => {
       if (isSFC) {
@@ -7484,7 +7433,7 @@ var CompilationUnitProcessor = class {
         const { script } = result.fileInfo;
         unit.output = {
           script: {
-            file: _optionalChain([script, 'optionalAccess', _267 => _267.file]),
+            file: _optionalChain([script, 'optionalAccess', _265 => _265.file]),
             code
           }
         };
@@ -7561,7 +7510,7 @@ var FileProcessor = (_class10 = class {
     const absPath = this.fileCompiler.getAbsPath(filePath);
     const fileMeta = await this.fileCompiler.getFileMeta(absPath);
     const cache = (this.fileCompiler.getIsCache() ? existingCache : void 0) || await this.fileCompiler.loadCache(key);
-    const record = _optionalChain([cache, 'optionalAccess', _268 => _268.target, 'access', _269 => _269.find, 'call', _270 => _270((c) => c.file === absPath)]);
+    const record = _optionalChain([cache, 'optionalAccess', _266 => _266.target, 'access', _267 => _267.find, 'call', _268 => _268((c) => c.file === absPath)]);
     const { shouldCompile, hash } = await this.fileCompiler.checkCacheStatus(
       fileMeta,
       record,
@@ -7583,10 +7532,10 @@ var FileProcessor = (_class10 = class {
       hash: hash || this.fileCompiler.genHash(source)
     };
     const processed = await this.compilationUnitProcessor.resolve(initUnit, key);
-    if (_optionalChain([processed, 'optionalAccess', _271 => _271.output])) {
+    if (_optionalChain([processed, 'optionalAccess', _269 => _269.output])) {
       await this.compilationUnitProcessor.saveCompiledFiles(processed, key);
       if (key === "sfc" /* SFC */ || key === "script" /* SCRIPT */) {
-        if (_optionalChain([processed, 'optionalAccess', _272 => _272.hasRoute])) {
+        if (_optionalChain([processed, 'optionalAccess', _270 => _270.hasRoute])) {
           await this.addRouterToPackageJson();
           await this.updateEntryWithRouterProvider();
         }
@@ -7600,13 +7549,13 @@ var FileProcessor = (_class10 = class {
    */
   async addRouterToPackageJson() {
     const { output } = this.fileCompiler.options;
-    if (_optionalChain([output, 'optionalAccess', _273 => _273.bootstrapVite]) === false) {
+    if (_optionalChain([output, 'optionalAccess', _271 => _271.bootstrapVite]) === false) {
       return;
     }
     const { router } = RUNTIME_PACKAGES;
     const filePath = this.fileCompiler.getOutputPkgPath();
     const packageJson = await this.fileCompiler.resolvePackageFile(filePath);
-    if (_optionalChain([packageJson, 'optionalAccess', _274 => _274.dependencies, 'optionalAccess', _275 => _275[router.name]])) {
+    if (_optionalChain([packageJson, 'optionalAccess', _272 => _272.dependencies, 'optionalAccess', _273 => _273[router.name]])) {
       return;
     }
     if (!packageJson.dependencies) {
@@ -7625,7 +7574,7 @@ var FileProcessor = (_class10 = class {
     const { exclude, output, router } = this.fileCompiler.options;
     const inputPath = this.fileCompiler.getInputPath();
     const outputPath = this.fileCompiler.getOuputPath(true);
-    if (_optionalChain([output, 'optionalAccess', _276 => _276.bootstrapVite]) === false || _optionalChain([router, 'optionalAccess', _277 => _277.autoUpdateEntry]) === false || !_optionalChain([router, 'optionalAccess', _278 => _278.configFile])) {
+    if (_optionalChain([output, 'optionalAccess', _274 => _274.bootstrapVite]) === false || _optionalChain([router, 'optionalAccess', _275 => _275.autoUpdateEntry]) === false || !_optionalChain([router, 'optionalAccess', _276 => _276.configFile])) {
       return;
     }
     const getMainFile = async (filename) => {
@@ -7646,7 +7595,7 @@ var FileProcessor = (_class10 = class {
     const prepareRouterEntry = () => {
       const importPath = this.fileCompiler.resolveRelativePath(inputPath, router.configFile);
       let content = fileData.content;
-      if (_optionalChain([exclude, 'optionalAccess', _279 => _279.includes, 'call', _280 => _280(router.configFile)]) || _optionalChain([exclude, 'optionalAccess', _281 => _281.includes, 'call', _282 => _282(importPath)])) {
+      if (_optionalChain([exclude, 'optionalAccess', _277 => _277.includes, 'call', _278 => _278(router.configFile)]) || _optionalChain([exclude, 'optionalAccess', _279 => _279.includes, 'call', _280 => _280(importPath)])) {
         return content;
       }
       const routerModule = "RouterInstance";
@@ -7792,7 +7741,7 @@ var ViteBootstrapper = (_class12 = class {
     const { output } = this.options;
     const workspaceDir = this.fileCompiler.getWorkspaceDir();
     await _fs2.default.promises.mkdir(workspaceDir, { recursive: true });
-    if (_optionalChain([output, 'optionalAccess', _283 => _283.bootstrapVite]) === false) {
+    if (_optionalChain([output, 'optionalAccess', _281 => _281.bootstrapVite]) === false) {
       return false;
     }
     if (this.isSingleFile()) {
@@ -7842,7 +7791,7 @@ var ViteBootstrapper = (_class12 = class {
     const newDevDeps = resolveDeps(sourcePkg.devDependencies, newPkg.devDependencies, true);
     newPkg.dependencies = newDeps;
     newPkg.devDependencies = newDevDeps;
-    newPkg = _optionalChain([output, 'optionalAccess', _284 => _284.packageJson, 'optionalCall', _285 => _285(newPkg)]) || newPkg;
+    newPkg = _optionalChain([output, 'optionalAccess', _282 => _282.packageJson, 'optionalCall', _283 => _283(newPkg)]) || newPkg;
     await this.fileCompiler.writeFileWithDir(outputPkgPath, JSON.stringify(newPkg, null, 2));
     this.spinner.succeed("Standard Vite React environment initialized");
     return true;
@@ -7853,12 +7802,12 @@ var ViteBootstrapper = (_class12 = class {
   async resolveViteCreateApp() {
     const { output } = this.options;
     const { viteVersion, template: tmpl } = this.defaultConfig;
-    const bootstrapVite = _optionalChain([output, 'optionalAccess', _286 => _286.bootstrapVite]);
+    const bootstrapVite = _optionalChain([output, 'optionalAccess', _284 => _284.bootstrapVite]);
     const outDirName = this.fileCompiler.getOutDirName();
     const configObject = typeof bootstrapVite === "object" ? bootstrapVite : null;
-    const viteVer = _optionalChain([configObject, 'optionalAccess', _287 => _287.vite]) || viteVersion;
-    const reactVer = _optionalChain([configObject, 'optionalAccess', _288 => _288.react]);
-    const template = _optionalChain([configObject, 'optionalAccess', _289 => _289.template]) || tmpl;
+    const viteVer = _optionalChain([configObject, 'optionalAccess', _285 => _285.vite]) || viteVersion;
+    const reactVer = _optionalChain([configObject, 'optionalAccess', _286 => _286.react]);
+    const template = _optionalChain([configObject, 'optionalAccess', _287 => _287.template]) || tmpl;
     const cmd = `npm create vite${viteVer} ${outDirName} -- --template ${template}`;
     _child_process.execSync.call(void 0, cmd, {
       cwd: this.fileCompiler.getWorkspaceDir(),
@@ -7962,7 +7911,7 @@ var FileCompiler = (_class13 = class extends BaseCompiler {
       const scriptCount = await this.runPipelineWithSpinner("script" /* SCRIPT */);
       const styleCount = await this.runPipelineWithSpinner("style" /* STYLE */);
       const assetCount = await this.runPipelineWithSpinner("copied" /* ASSET */);
-      await _optionalChain([this, 'access', _290 => _290.options, 'access', _291 => _291.onSuccess, 'optionalCall', _292 => _292()]);
+      await _optionalChain([this, 'access', _288 => _288.options, 'access', _289 => _289.onSuccess, 'optionalCall', _290 => _290()]);
       const endTime = calcElapsedTime(startTime);
       this.printCoreLogs();
       this.showCompileStats(endTime, sfcCount, scriptCount, styleCount, assetCount);