@vue/runtime-core 3.6.0-alpha.1 → 3.6.0-alpha.3

package/dist/runtime-core.cjs.js

@@ -1,5 +1,5 @@
 /**
-* @vue/runtime-core v3.6.0-alpha.1
+* @vue/runtime-core v3.6.0-alpha.3
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -531,8 +531,10 @@ function rerender(id, newRender) {
       instance.hmrRerender();
     } else {
       const i = instance;
-      i.renderCache = [];
-      i.effect.run();
+      if (!(i.effect.flags & 1024)) {
+        i.renderCache = [];
+        i.effect.run();
+      }
     }
     nextTick(() => {
       isHmrUpdating = false;
@@ -545,7 +547,7 @@ function reload(id, newComp) {
   newComp = normalizeClassComponent(newComp);
   updateComponentDef(record.initialDef, newComp);
   const instances = [...record.instances];
-  if (newComp.vapor) {
+  if (newComp.__vapor) {
     for (const instance of instances) {
       instance.hmrReload(newComp);
     }
@@ -574,7 +576,10 @@ function reload(id, newComp) {
           if (parent.vapor) {
             parent.hmrRerender();
           } else {
-            parent.effect.run();
+            if (!(parent.effect.flags & 1024)) {
+              parent.renderCache = [];
+              parent.effect.run();
+            }
           }
           nextTick(() => {
             isHmrUpdating = false;
@@ -684,7 +689,6 @@ const devtoolsComponentRemoved = (component) => {
     _devtoolsComponentRemoved(component);
   }
 };
-/*! #__NO_SIDE_EFFECTS__ */
 // @__NO_SIDE_EFFECTS__
 function createDevtoolsComponentHook(hook) {
   return (component) => {
@@ -870,9 +874,6 @@ const TeleportImpl = {
       insert(mainAnchor, container, anchor);
       const mount = (container2, anchor2) => {
         if (shapeFlag & 16) {
-          if (parentComponent && parentComponent.isCE) {
-            parentComponent.ce._teleportTarget = container2;
-          }
           mountChildren(
             children,
             container2,
@@ -894,6 +895,9 @@ const TeleportImpl = {
           } else if (namespace !== "mathml" && isTargetMathML(target)) {
             namespace = "mathml";
           }
+          if (parentComponent && parentComponent.isCE) {
+            (parentComponent.ce._teleportTargets || (parentComponent.ce._teleportTargets = /* @__PURE__ */ new Set())).add(target);
+          }
           if (!disabled) {
             mount(target, targetAnchor);
             updateCssVars(n2, false);
@@ -1094,26 +1098,34 @@ function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }
 function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, {
   o: { nextSibling, parentNode, querySelector, insert, createText }
 }, hydrateChildren) {
+  function hydrateDisabledTeleport(node2, vnode2, targetStart, targetAnchor) {
+    vnode2.anchor = hydrateChildren(
+      nextSibling(node2),
+      vnode2,
+      parentNode(node2),
+      parentComponent,
+      parentSuspense,
+      slotScopeIds,
+      optimized
+    );
+    vnode2.targetStart = targetStart;
+    vnode2.targetAnchor = targetAnchor;
+  }
   const target = vnode.target = resolveTarget(
     vnode.props,
     querySelector
   );
+  const disabled = isTeleportDisabled(vnode.props);
   if (target) {
-    const disabled = isTeleportDisabled(vnode.props);
     const targetNode = target._lpa || target.firstChild;
     if (vnode.shapeFlag & 16) {
       if (disabled) {
-        vnode.anchor = hydrateChildren(
-          nextSibling(node),
+        hydrateDisabledTeleport(
+          node,
           vnode,
-          parentNode(node),
-          parentComponent,
-          parentSuspense,
-          slotScopeIds,
-          optimized
+          targetNode,
+          targetNode && nextSibling(targetNode)
         );
-        vnode.targetStart = targetNode;
-        vnode.targetAnchor = targetNode && nextSibling(targetNode);
       } else {
         vnode.anchor = nextSibling(node);
         let targetAnchor = targetNode;
@@ -1144,6 +1156,10 @@ function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScope
       }
     }
     updateCssVars(vnode, disabled);
+  } else if (disabled) {
+    if (vnode.shapeFlag & 16) {
+      hydrateDisabledTeleport(node, vnode, node, nextSibling(node));
+    }
   }
   return vnode.anchor && nextSibling(vnode.anchor);
 }
@@ -1184,7 +1200,7 @@ function useTransitionState() {
     isMounted: false,
     isLeaving: false,
     isUnmounting: false,
-    leavingVNodes: /* @__PURE__ */ new Map()
+    leavingNodes: /* @__PURE__ */ new Map()
   };
   onMounted(() => {
     state.isMounted = true;
@@ -1216,7 +1232,7 @@ const BaseTransitionPropsValidators = {
   onAppearCancelled: TransitionHookValidator
 };
 const recursiveGetSubtree = (instance) => {
-  const subTree = instance.subTree;
+  const subTree = instance.type.__vapor ? instance.block : instance.subTree;
   return subTree.component ? recursiveGetSubtree(subTree.component) : subTree;
 };
 const BaseTransitionImpl = {
@@ -1233,9 +1249,7 @@ const BaseTransitionImpl = {
       const child = findNonCommentChild(children);
       const rawProps = reactivity.toRaw(props);
       const { mode } = rawProps;
-      if (mode && mode !== "in-out" && mode !== "out-in" && mode !== "default") {
-        warn$1(`invalid <transition> mode: ${mode}`);
-      }
+      checkTransitionMode(mode);
       if (state.isLeaving) {
         return emptyPlaceholder(child);
       }
@@ -1255,7 +1269,7 @@ const BaseTransitionImpl = {
         setTransitionHooks(innerChild, enterHooks);
       }
       let oldInnerChild = instance.subTree && getInnerChild$1(instance.subTree);
-      if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(innerChild, oldInnerChild) && recursiveGetSubtree(instance).type !== Comment) {
+      if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(oldInnerChild, innerChild) && recursiveGetSubtree(instance).type !== Comment) {
         let leavingHooks = resolveTransitionHooks(
           oldInnerChild,
           rawProps,
@@ -1324,15 +1338,53 @@ function findNonCommentChild(children) {
 }
 const BaseTransition = BaseTransitionImpl;
 function getLeavingNodesForType(state, vnode) {
-  const { leavingVNodes } = state;
-  let leavingVNodesCache = leavingVNodes.get(vnode.type);
+  const { leavingNodes } = state;
+  let leavingVNodesCache = leavingNodes.get(vnode.type);
   if (!leavingVNodesCache) {
     leavingVNodesCache = /* @__PURE__ */ Object.create(null);
-    leavingVNodes.set(vnode.type, leavingVNodesCache);
+    leavingNodes.set(vnode.type, leavingVNodesCache);
   }
   return leavingVNodesCache;
 }
 function resolveTransitionHooks(vnode, props, state, instance, postClone) {
+  const key = String(vnode.key);
+  const leavingVNodesCache = getLeavingNodesForType(state, vnode);
+  const context = {
+    setLeavingNodeCache: () => {
+      leavingVNodesCache[key] = vnode;
+    },
+    unsetLeavingNodeCache: () => {
+      if (leavingVNodesCache[key] === vnode) {
+        delete leavingVNodesCache[key];
+      }
+    },
+    earlyRemove: () => {
+      const leavingVNode = leavingVNodesCache[key];
+      if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) {
+        leavingVNode.el[leaveCbKey]();
+      }
+    },
+    cloneHooks: (vnode2) => {
+      const hooks = resolveTransitionHooks(
+        vnode2,
+        props,
+        state,
+        instance,
+        postClone
+      );
+      if (postClone) postClone(hooks);
+      return hooks;
+    }
+  };
+  return baseResolveTransitionHooks(context, props, state, instance);
+}
+function baseResolveTransitionHooks(context, props, state, instance) {
+  const {
+    setLeavingNodeCache,
+    unsetLeavingNodeCache,
+    earlyRemove,
+    cloneHooks
+  } = context;
   const {
     appear,
     mode,
@@ -1350,8 +1402,6 @@ function resolveTransitionHooks(vnode, props, state, instance, postClone) {
     onAfterAppear,
     onAppearCancelled
   } = props;
-  const key = String(vnode.key);
-  const leavingVNodesCache = getLeavingNodesForType(state, vnode);
   const callHook = (hook, args) => {
     hook && callWithAsyncErrorHandling(
       hook,
@@ -1387,10 +1437,7 @@ function resolveTransitionHooks(vnode, props, state, instance, postClone) {
           /* cancelled */
         );
       }
-      const leavingVNode = leavingVNodesCache[key];
-      if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) {
-        leavingVNode.el[leaveCbKey]();
-      }
+      earlyRemove();
       callHook(hook, [el]);
     },
     enter(el) {
@@ -1427,7 +1474,6 @@ function resolveTransitionHooks(vnode, props, state, instance, postClone) {
       }
     },
     leave(el, remove) {
-      const key2 = String(vnode.key);
       if (el[enterCbKey]) {
         el[enterCbKey](
           true
@@ -1449,27 +1495,17 @@ function resolveTransitionHooks(vnode, props, state, instance, postClone) {
           callHook(onAfterLeave, [el]);
         }
         el[leaveCbKey] = void 0;
-        if (leavingVNodesCache[key2] === vnode) {
-          delete leavingVNodesCache[key2];
-        }
+        unsetLeavingNodeCache(el);
       };
-      leavingVNodesCache[key2] = vnode;
+      setLeavingNodeCache(el);
       if (onLeave) {
         callAsyncHook(onLeave, [el, done]);
       } else {
         done();
       }
     },
-    clone(vnode2) {
-      const hooks2 = resolveTransitionHooks(
-        vnode2,
-        props,
-        state,
-        instance,
-        postClone
-      );
-      if (postClone) postClone(hooks2);
-      return hooks2;
+    clone(node) {
+      return cloneHooks(node);
     }
   };
   return hooks;
@@ -1503,8 +1539,15 @@ function getInnerChild$1(vnode) {
 }
 function setTransitionHooks(vnode, hooks) {
   if (vnode.shapeFlag & 6 && vnode.component) {
-    vnode.transition = hooks;
-    setTransitionHooks(vnode.component.subTree, hooks);
+    if (vnode.type.__vapor) {
+      getVaporInterface(vnode.component, vnode).setTransitionHooks(
+        vnode.component,
+        hooks
+      );
+    } else {
+      vnode.transition = hooks;
+      setTransitionHooks(vnode.component.subTree, hooks);
+    }
   } else if (vnode.shapeFlag & 128) {
     vnode.ssContent.transition = hooks.clone(vnode.ssContent);
     vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
@@ -1534,8 +1577,12 @@ function getTransitionRawChildren(children, keepComment = false, parentKey) {
   }
   return ret;
 }
+function checkTransitionMode(mode) {
+  if (mode && mode !== "in-out" && mode !== "out-in" && mode !== "default") {
+    warn$1(`invalid <transition> mode: ${mode}`);
+  }
+}
 
-/*! #__NO_SIDE_EFFECTS__ */
 // @__NO_SIDE_EFFECTS__
 function defineComponent(options, extraOptions) {
   return shared.isFunction(options) ? (
@@ -1588,6 +1635,7 @@ function useTemplateRef(key) {
   return ret;
 }
 
+const pendingSetRefMap = /* @__PURE__ */ new WeakMap();
 function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
   if (shared.isArray(rawRef)) {
     rawRef.forEach(
@@ -1619,28 +1667,23 @@ function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
   const oldRef = oldRawRef && oldRawRef.r;
   const refs = owner.refs === shared.EMPTY_OBJ ? owner.refs = {} : owner.refs;
   const setupState = owner.setupState;
-  const rawSetupState = reactivity.toRaw(setupState);
-  const canSetSetupRef = setupState === shared.EMPTY_OBJ ? () => false : (key) => {
-    {
-      if (shared.hasOwn(rawSetupState, key) && !reactivity.isRef(rawSetupState[key])) {
-        warn$1(
-          `Template ref "${key}" used on a non-ref value. It will not work in the production build.`
-        );
-      }
-      if (knownTemplateRefs.has(rawSetupState[key])) {
-        return false;
-      }
-    }
-    return shared.hasOwn(rawSetupState, key);
+  const canSetSetupRef = createCanSetSetupRefChecker(setupState);
+  const canSetRef = (ref2) => {
+    return !knownTemplateRefs.has(ref2);
   };
   if (oldRef != null && oldRef !== ref) {
+    invalidatePendingSetRef(oldRawRef);
     if (shared.isString(oldRef)) {
       refs[oldRef] = null;
       if (canSetSetupRef(oldRef)) {
         setupState[oldRef] = null;
       }
     } else if (reactivity.isRef(oldRef)) {
-      oldRef.value = null;
+      if (canSetRef(oldRef)) {
+        oldRef.value = null;
+      }
+      const oldRawRefAtom = oldRawRef;
+      if (oldRawRefAtom.k) refs[oldRawRefAtom.k] = null;
     }
   }
   if (shared.isFunction(ref)) {
@@ -1651,7 +1694,7 @@ function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
     if (_isString || _isRef) {
       const doSet = () => {
         if (rawRef.f) {
-          const existing = _isString ? canSetSetupRef(ref) ? setupState[ref] : refs[ref] : ref.value;
+          const existing = _isString ? canSetSetupRef(ref) ? setupState[ref] : refs[ref] : canSetRef(ref) || !rawRef.k ? ref.value : refs[rawRef.k];
           if (isUnmount) {
             shared.isArray(existing) && shared.remove(existing, refValue);
           } else {
@@ -1662,8 +1705,11 @@ function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
                   setupState[ref] = refs[ref];
                 }
               } else {
-                ref.value = [refValue];
-                if (rawRef.k) refs[rawRef.k] = ref.value;
+                const newVal = [refValue];
+                if (canSetRef(ref)) {
+                  ref.value = newVal;
+                }
+                if (rawRef.k) refs[rawRef.k] = newVal;
               }
             } else if (!existing.includes(refValue)) {
               existing.push(refValue);
@@ -1675,15 +1721,23 @@ function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
             setupState[ref] = value;
           }
         } else if (_isRef) {
-          ref.value = value;
+          if (canSetRef(ref)) {
+            ref.value = value;
+          }
           if (rawRef.k) refs[rawRef.k] = value;
         } else {
           warn$1("Invalid template ref type:", ref, `(${typeof ref})`);
         }
       };
       if (value) {
-        queuePostRenderEffect(doSet, -1, parentSuspense);
+        const job = () => {
+          doSet();
+          pendingSetRefMap.delete(rawRef);
+        };
+        pendingSetRefMap.set(rawRef, job);
+        queuePostRenderEffect(job, -1, parentSuspense);
       } else {
+        invalidatePendingSetRef(rawRef);
         doSet();
       }
     } else {
@@ -1691,6 +1745,29 @@ function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
     }
   }
 }
+function createCanSetSetupRefChecker(setupState) {
+  const rawSetupState = reactivity.toRaw(setupState);
+  return setupState === void 0 || setupState === shared.EMPTY_OBJ ? shared.NO : (key) => {
+    {
+      if (shared.hasOwn(rawSetupState, key) && !reactivity.isRef(rawSetupState[key])) {
+        warn$1(
+          `Template ref "${key}" used on a non-ref value. It will not work in the production build.`
+        );
+      }
+      if (knownTemplateRefs.has(rawSetupState[key])) {
+        return false;
+      }
+    }
+    return shared.hasOwn(rawSetupState, key);
+  };
+}
+function invalidatePendingSetRef(rawRef) {
+  const pendingSetRef = pendingSetRefMap.get(rawRef);
+  if (pendingSetRef) {
+    pendingSetRef.flags |= 4;
+    pendingSetRefMap.delete(rawRef);
+  }
+}
 
 let hasLoggedMismatchError = false;
 const logMismatchError = () => {
@@ -1835,6 +1912,12 @@ function createHydrationFunctions(rendererInternals) {
           );
         }
         break;
+      case VaporSlot:
+        nextNode = getVaporInterface(parentComponent, vnode).hydrateSlot(
+          vnode,
+          node
+        );
+        break;
       default:
         if (shapeFlag & 1) {
           if ((domType !== 1 || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) && !isTemplateNode(node)) {
@@ -1850,9 +1933,6 @@ function createHydrationFunctions(rendererInternals) {
             );
           }
         } else if (shapeFlag & 6) {
-          if (vnode.type.__vapor) {
-            throw new Error("Vapor component hydration is not supported yet.");
-          }
           vnode.slotScopeIds = slotScopeIds;
           const container = parentNode(node);
           if (isFragmentStart) {
@@ -1862,15 +1942,25 @@ function createHydrationFunctions(rendererInternals) {
           } else {
             nextNode = nextSibling(node);
           }
-          mountComponent(
-            vnode,
-            container,
-            null,
-            parentComponent,
-            parentSuspense,
-            getContainerType(container),
-            optimized
-          );
+          if (vnode.type.__vapor) {
+            getVaporInterface(parentComponent, vnode).hydrate(
+              vnode,
+              node,
+              container,
+              null,
+              parentComponent
+            );
+          } else {
+            mountComponent(
+              vnode,
+              container,
+              null,
+              parentComponent,
+              parentSuspense,
+              getContainerType(container),
+              optimized
+            );
+          }
           if (isAsyncWrapper(vnode) && !vnode.type.__asyncResolved) {
             let subTree;
             if (isFragmentStart) {
@@ -1955,7 +2045,7 @@ function createHydrationFunctions(rendererInternals) {
         );
         let hasWarned = false;
         while (next) {
-          if (!isMismatchAllowed(el, 1 /* CHILDREN */)) {
+          if (!isMismatchAllowed(el, 1)) {
             if (!hasWarned) {
               warn$1(
                 `Hydration children mismatch on`,
@@ -1976,14 +2066,16 @@ Server rendered element contains more child nodes than client vdom.`
         if (clientText[0] === "\n" && (el.tagName === "PRE" || el.tagName === "TEXTAREA")) {
           clientText = clientText.slice(1);
         }
-        if (el.textContent !== clientText) {
-          if (!isMismatchAllowed(el, 0 /* TEXT */)) {
+        const { textContent } = el;
+        if (textContent !== clientText && // innerHTML normalize \r\n or \r into a single \n in the DOM
+        textContent !== clientText.replace(/\r\n|\r/g, "\n")) {
+          if (!isMismatchAllowed(el, 0)) {
             warn$1(
               `Hydration text content mismatch on`,
               el,
               `
-  - rendered on server: ${el.textContent}
-  - expected on client: ${vnode.children}`
+  - rendered on server: ${textContent}
+  - expected on client: ${clientText}`
             );
             logMismatchError();
           }
@@ -2059,7 +2151,7 @@ Server rendered element contains more child nodes than client vdom.`
       } else if (isText && !vnode.children) {
         insert(vnode.el = createText(""), container);
       } else {
-        if (!isMismatchAllowed(container, 1 /* CHILDREN */)) {
+        if (!isMismatchAllowed(container, 1)) {
           if (!hasWarned) {
             warn$1(
               `Hydration children mismatch on`,
@@ -2109,7 +2201,7 @@ Server rendered element contains fewer child nodes than client vdom.`
     }
   };
   const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => {
-    if (!isMismatchAllowed(node.parentElement, 1 /* CHILDREN */)) {
+    if (!isMismatchAllowed(node.parentElement, 1)) {
       warn$1(
         `Hydration node mismatch:
 - rendered on server:`,
@@ -2182,11 +2274,11 @@ Server rendered element contains fewer child nodes than client vdom.`
       parent = parent.parent;
     }
   };
-  const isTemplateNode = (node) => {
-    return node.nodeType === 1 && node.tagName === "TEMPLATE";
-  };
   return [hydrate, hydrateNode];
 }
+const isTemplateNode = (node) => {
+  return node.nodeType === 1 && node.tagName === "TEMPLATE";
+};
 function propHasMismatch(el, key, clientValue, vnode, instance) {
   let mismatchType;
   let mismatchKey;
@@ -2201,7 +2293,7 @@ function propHasMismatch(el, key, clientValue, vnode, instance) {
     }
     expected = shared.normalizeClass(clientValue);
     if (!isSetEqual(toClassSet(actual || ""), toClassSet(expected))) {
-      mismatchType = 2 /* CLASS */;
+      mismatchType = 2;
       mismatchKey = `class`;
     }
   } else if (key === "style") {
@@ -2220,31 +2312,43 @@ function propHasMismatch(el, key, clientValue, vnode, instance) {
       resolveCssVars(instance, vnode, expectedMap);
     }
     if (!isMapEqual(actualMap, expectedMap)) {
-      mismatchType = 3 /* STYLE */;
+      mismatchType = 3;
       mismatchKey = "style";
     }
-  } else if (el instanceof SVGElement && shared.isKnownSvgAttr(key) || el instanceof HTMLElement && (shared.isBooleanAttr(key) || shared.isKnownHtmlAttr(key))) {
-    if (shared.isBooleanAttr(key)) {
-      actual = el.hasAttribute(key);
-      expected = shared.includeBooleanAttr(clientValue);
-    } else if (clientValue == null) {
-      actual = el.hasAttribute(key);
-      expected = false;
-    } else {
-      if (el.hasAttribute(key)) {
-        actual = el.getAttribute(key);
-      } else if (key === "value" && el.tagName === "TEXTAREA") {
-        actual = el.value;
-      } else {
-        actual = false;
-      }
-      expected = shared.isRenderableAttrValue(clientValue) ? String(clientValue) : false;
-    }
+  } else if (isValidHtmlOrSvgAttribute(el, key)) {
+    ({ actual, expected } = getAttributeMismatch(el, key, clientValue));
     if (actual !== expected) {
-      mismatchType = 4 /* ATTRIBUTE */;
+      mismatchType = 4;
       mismatchKey = key;
     }
   }
+  return warnPropMismatch(el, mismatchKey, mismatchType, actual, expected);
+}
+function getAttributeMismatch(el, key, clientValue) {
+  let actual;
+  let expected;
+  if (shared.isBooleanAttr(key)) {
+    actual = el.hasAttribute(key);
+    expected = shared.includeBooleanAttr(clientValue);
+  } else if (clientValue == null) {
+    actual = el.hasAttribute(key);
+    expected = false;
+  } else {
+    if (el.hasAttribute(key)) {
+      actual = el.getAttribute(key);
+    } else if (key === "value" && el.tagName === "TEXTAREA") {
+      actual = el.value;
+    } else {
+      actual = false;
+    }
+    expected = shared.isRenderableAttrValue(clientValue) ? String(clientValue) : false;
+  }
+  return { actual, expected };
+}
+function isValidHtmlOrSvgAttribute(el, key) {
+  return el instanceof SVGElement && shared.isKnownSvgAttr(key) || el instanceof HTMLElement && (shared.isBooleanAttr(key) || shared.isKnownHtmlAttr(key));
+}
+function warnPropMismatch(el, mismatchKey, mismatchType, actual, expected) {
   if (mismatchType != null && !isMismatchAllowed(el, mismatchType)) {
     const format = (v) => v === false ? `(not rendered)` : `${mismatchKey}="${v}"`;
     const preSegment = `Hydration ${MismatchTypeString[mismatchType]} mismatch on`;
@@ -2316,14 +2420,14 @@ function resolveCssVars(instance, vnode, expectedMap) {
 }
 const allowMismatchAttr = "data-allow-mismatch";
 const MismatchTypeString = {
-  [0 /* TEXT */]: "text",
-  [1 /* CHILDREN */]: "children",
-  [2 /* CLASS */]: "class",
-  [3 /* STYLE */]: "style",
-  [4 /* ATTRIBUTE */]: "attribute"
+  [0]: "text",
+  [1]: "children",
+  [2]: "class",
+  [3]: "style",
+  [4]: "attribute"
 };
 function isMismatchAllowed(el, allowedType) {
-  if (allowedType === 0 /* TEXT */ || allowedType === 1 /* CHILDREN */) {
+  if (allowedType === 0 || allowedType === 1) {
     while (el && !el.hasAttribute(allowMismatchAttr)) {
       el = el.parentElement;
     }
@@ -2335,7 +2439,7 @@ function isMismatchAllowed(el, allowedType) {
     return true;
   } else {
     const list = allowedAttr.split(",");
-    if (allowedType === 0 /* TEXT */ && list.includes("children")) {
+    if (allowedType === 0 && list.includes("children")) {
       return true;
     }
     return list.includes(MismatchTypeString[allowedType]);
@@ -2392,7 +2496,9 @@ const hydrateOnInteraction = (interactions = []) => (hydrate, forEach) => {
       hasHydrated = true;
       teardown();
       hydrate();
-      e.target.dispatchEvent(new e.constructor(e.type, e));
+      if (!(`$evt${e.type}` in e.target)) {
+        e.target.dispatchEvent(new e.constructor(e.type, e));
+      }
     }
   };
   const teardown = () => {
@@ -2434,104 +2540,46 @@ function forEachElement(node, cb) {
 }
 
 const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
-/*! #__NO_SIDE_EFFECTS__ */
 // @__NO_SIDE_EFFECTS__
 function defineAsyncComponent(source) {
-  if (shared.isFunction(source)) {
-    source = { loader: source };
-  }
   const {
-    loader,
-    loadingComponent,
-    errorComponent,
-    delay = 200,
-    hydrate: hydrateStrategy,
-    timeout,
-    // undefined = never times out
-    suspensible = true,
-    onError: userOnError
-  } = source;
-  let pendingRequest = null;
-  let resolvedComp;
-  let retries = 0;
-  const retry = () => {
-    retries++;
-    pendingRequest = null;
-    return load();
-  };
-  const load = () => {
-    let thisRequest;
-    return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => {
-      err = err instanceof Error ? err : new Error(String(err));
-      if (userOnError) {
-        return new Promise((resolve, reject) => {
-          const userRetry = () => resolve(retry());
-          const userFail = () => reject(err);
-          userOnError(err, userRetry, userFail, retries + 1);
-        });
-      } else {
-        throw err;
-      }
-    }).then((comp) => {
-      if (thisRequest !== pendingRequest && pendingRequest) {
-        return pendingRequest;
-      }
-      if (!comp) {
-        warn$1(
-          `Async component loader resolved to undefined. If you are using retry(), make sure to return its return value.`
-        );
-      }
-      if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
-        comp = comp.default;
-      }
-      if (comp && !shared.isObject(comp) && !shared.isFunction(comp)) {
-        throw new Error(`Invalid async component load result: ${comp}`);
-      }
-      resolvedComp = comp;
-      return comp;
-    }));
-  };
+    load,
+    getResolvedComp,
+    setPendingRequest,
+    source: {
+      loadingComponent,
+      errorComponent,
+      delay,
+      hydrate: hydrateStrategy,
+      timeout,
+      suspensible = true
+    }
+  } = createAsyncComponentContext(source);
   return defineComponent({
     name: "AsyncComponentWrapper",
     __asyncLoader: load,
     __asyncHydrate(el, instance, hydrate) {
-      let patched = false;
-      const doHydrate = hydrateStrategy ? () => {
-        const performHydrate = () => {
-          if (patched) {
-            warn$1(
-              `Skipping lazy hydration for component '${getComponentName(resolvedComp)}': it was updated before lazy hydration performed.`
-            );
-            return;
-          }
-          hydrate();
-        };
-        const teardown = hydrateStrategy(
-          performHydrate,
-          (cb) => forEachElement(el, cb)
-        );
-        if (teardown) {
-          (instance.bum || (instance.bum = [])).push(teardown);
-        }
-        (instance.u || (instance.u = [])).push(() => patched = true);
-      } : hydrate;
-      if (resolvedComp) {
-        doHydrate();
-      } else {
-        load().then(() => !instance.isUnmounted && doHydrate());
-      }
+      performAsyncHydrate(
+        el,
+        instance,
+        hydrate,
+        getResolvedComp,
+        load,
+        hydrateStrategy
+      );
     },
     get __asyncResolved() {
-      return resolvedComp;
+      return getResolvedComp();
     },
     setup() {
       const instance = currentInstance;
       markAsyncBoundary(instance);
+      let resolvedComp = getResolvedComp();
       if (resolvedComp) {
         return () => createInnerComp(resolvedComp, instance);
       }
       const onError = (err) => {
-        pendingRequest = null;
+        setPendingRequest(null);
         handleError(
           err,
           instance,
@@ -2549,25 +2597,11 @@ function defineAsyncComponent(source) {
           }) : null;
         });
       }
-      const loaded = reactivity.ref(false);
-      const error = reactivity.ref();
-      const delayed = reactivity.ref(!!delay);
-      if (delay) {
-        setTimeout(() => {
-          delayed.value = false;
-        }, delay);
-      }
-      if (timeout != null) {
-        setTimeout(() => {
-          if (!loaded.value && !error.value) {
-            const err = new Error(
-              `Async component timed out after ${timeout}ms.`
-            );
-            onError(err);
-            error.value = err;
-          }
-        }, timeout);
-      }
+      const { loaded, error, delayed } = useAsyncComponentState(
+        delay,
+        timeout,
+        onError
+      );
       load().then(() => {
         loaded.value = true;
         if (instance.parent && instance.parent.vnode && isKeepAlive(instance.parent.vnode)) {
@@ -2578,6 +2612,7 @@ function defineAsyncComponent(source) {
         error.value = err;
       });
       return () => {
+        resolvedComp = getResolvedComp();
         if (loaded.value && resolvedComp) {
           return createInnerComp(resolvedComp, instance);
         } else if (error.value && errorComponent) {
@@ -2585,7 +2620,10 @@ function defineAsyncComponent(source) {
             error: error.value
           });
         } else if (loadingComponent && !delayed.value) {
-          return createVNode(loadingComponent);
+          return createInnerComp(
+            loadingComponent,
+            instance
+          );
         }
       };
     }
@@ -2599,6 +2637,108 @@ function createInnerComp(comp, parent) {
   delete parent.vnode.ce;
   return vnode;
 }
+function createAsyncComponentContext(source) {
+  if (shared.isFunction(source)) {
+    source = { loader: source };
+  }
+  const { loader, onError: userOnError } = source;
+  let pendingRequest = null;
+  let resolvedComp;
+  let retries = 0;
+  const retry = () => {
+    retries++;
+    pendingRequest = null;
+    return load();
+  };
+  const load = () => {
+    let thisRequest;
+    return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => {
+      err = err instanceof Error ? err : new Error(String(err));
+      if (userOnError) {
+        return new Promise((resolve, reject) => {
+          const userRetry = () => resolve(retry());
+          const userFail = () => reject(err);
+          userOnError(err, userRetry, userFail, retries + 1);
+        });
+      } else {
+        throw err;
+      }
+    }).then((comp) => {
+      if (thisRequest !== pendingRequest && pendingRequest) {
+        return pendingRequest;
+      }
+      if (!comp) {
+        warn$1(
+          `Async component loader resolved to undefined. If you are using retry(), make sure to return its return value.`
+        );
+      }
+      if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
+        comp = comp.default;
+      }
+      if (comp && !shared.isObject(comp) && !shared.isFunction(comp)) {
+        throw new Error(`Invalid async component load result: ${comp}`);
+      }
+      resolvedComp = comp;
+      return comp;
+    }));
+  };
+  return {
+    load,
+    source,
+    getResolvedComp: () => resolvedComp,
+    setPendingRequest: (request) => pendingRequest = request
+  };
+}
+const useAsyncComponentState = (delay, timeout, onError) => {
+  const loaded = reactivity.ref(false);
+  const error = reactivity.ref();
+  const delayed = reactivity.ref(!!delay);
+  if (delay) {
+    setTimeout(() => {
+      delayed.value = false;
+    }, delay);
+  }
+  if (timeout != null) {
+    setTimeout(() => {
+      if (!loaded.value && !error.value) {
+        const err = new Error(`Async component timed out after ${timeout}ms.`);
+        onError(err);
+        error.value = err;
+      }
+    }, timeout);
+  }
+  return { loaded, error, delayed };
+};
+function performAsyncHydrate(el, instance, hydrate, getResolvedComp, load, hydrateStrategy) {
+  let patched = false;
+  (instance.bu || (instance.bu = [])).push(() => patched = true);
+  const performHydrate = () => {
+    if (patched) {
+      {
+        const resolvedComp = getResolvedComp();
+        warn$1(
+          `Skipping lazy hydration for component '${getComponentName(resolvedComp) || resolvedComp.__file}': it was updated before lazy hydration performed.`
+        );
+      }
+      return;
+    }
+    hydrate();
+  };
+  const doHydrate = hydrateStrategy ? () => {
+    const teardown = hydrateStrategy(
+      performHydrate,
+      (cb) => forEachElement(el, cb)
+    );
+    if (teardown) {
+      (instance.bum || (instance.bum = [])).push(teardown);
+    }
+  } : performHydrate;
+  if (getResolvedComp()) {
+    doHydrate();
+  } else {
+    load().then(() => !instance.isUnmounted && doHydrate());
+  }
+}
 
 const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
 const KeepAliveImpl = {
@@ -2628,83 +2768,37 @@ const KeepAliveImpl = {
       keepAliveInstance.__v_cache = cache;
     }
     const parentSuspense = keepAliveInstance.suspense;
+    const { renderer } = sharedContext;
     const {
-      renderer: {
-        p: patch,
-        m: move,
-        um: _unmount,
-        o: { createElement }
-      }
-    } = sharedContext;
+      um: _unmount,
+      o: { createElement }
+    } = renderer;
     const storageContainer = createElement("div");
+    sharedContext.getStorageContainer = () => storageContainer;
+    sharedContext.getCachedComponent = (vnode) => {
+      const key = vnode.key == null ? vnode.type : vnode.key;
+      return cache.get(key);
+    };
     sharedContext.activate = (vnode, container, anchor, namespace, optimized) => {
-      const instance = vnode.component;
-      move(
+      activate(
         vnode,
         container,
         anchor,
-        0,
+        renderer,
         keepAliveInstance,
-        parentSuspense
-      );
-      patch(
-        instance.vnode,
-        vnode,
-        container,
-        anchor,
-        instance,
         parentSuspense,
         namespace,
-        vnode.slotScopeIds,
         optimized
       );
-      queuePostRenderEffect(
-        () => {
-          instance.isDeactivated = false;
-          if (instance.a) {
-            shared.invokeArrayFns(instance.a);
-          }
-          const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
-          if (vnodeHook) {
-            invokeVNodeHook(vnodeHook, instance.parent, vnode);
-          }
-        },
-        void 0,
-        parentSuspense
-      );
-      {
-        devtoolsComponentAdded(instance);
-      }
     };
     sharedContext.deactivate = (vnode) => {
-      const instance = vnode.component;
-      invalidateMount(instance.m);
-      invalidateMount(instance.a);
-      move(
+      deactivate(
         vnode,
         storageContainer,
-        null,
-        1,
+        renderer,
         keepAliveInstance,
         parentSuspense
       );
-      queuePostRenderEffect(
-        () => {
-          if (instance.da) {
-            shared.invokeArrayFns(instance.da);
-          }
-          const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
-          if (vnodeHook) {
-            invokeVNodeHook(vnodeHook, instance.parent, vnode);
-          }
-          instance.isDeactivated = true;
-        },
-        void 0,
-        parentSuspense
-      );
-      {
-        devtoolsComponentAdded(instance);
-      }
     };
     function unmount(vnode) {
       resetShapeFlag(vnode);
@@ -2851,7 +2945,7 @@ function onActivated(hook, target) {
 function onDeactivated(hook, target) {
   registerKeepAliveHook(hook, "da", target);
 }
-function registerKeepAliveHook(hook, type, target = getCurrentInstance()) {
+function registerKeepAliveHook(hook, type, target = getCurrentGenericInstance()) {
   const wrappedHook = hook.__wdc || (hook.__wdc = () => {
     let current = target;
     while (current) {
@@ -2865,8 +2959,9 @@ function registerKeepAliveHook(hook, type, target = getCurrentInstance()) {
   injectHook(type, wrappedHook, target);
   if (target) {
     let current = target.parent;
-    while (current && current.parent && current.parent.vnode) {
-      if (isKeepAlive(current.parent.vnode)) {
+    while (current && current.parent) {
+      let parent = current.parent;
+      if (isKeepAlive(parent.vapor ? parent : parent.vnode)) {
         injectToKeepAliveRoot(wrappedHook, type, target, current);
       }
       current = current.parent;
@@ -2892,6 +2987,68 @@ function resetShapeFlag(vnode) {
 function getInnerChild(vnode) {
   return vnode.shapeFlag & 128 ? vnode.ssContent : vnode;
 }
+function activate(vnode, container, anchor, { p: patch, m: move }, parentComponent, parentSuspense, namespace, optimized) {
+  const instance = vnode.component;
+  move(
+    vnode,
+    container,
+    anchor,
+    0,
+    parentComponent,
+    parentSuspense
+  );
+  patch(
+    instance.vnode,
+    vnode,
+    container,
+    anchor,
+    instance,
+    parentSuspense,
+    namespace,
+    vnode.slotScopeIds,
+    optimized
+  );
+  queuePostRenderEffect(
+    () => {
+      instance.isDeactivated = false;
+      if (instance.a) {
+        shared.invokeArrayFns(instance.a);
+      }
+      const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
+      if (vnodeHook) {
+        invokeVNodeHook(vnodeHook, instance.parent, vnode);
+      }
+    },
+    void 0,
+    parentSuspense
+  );
+  {
+    devtoolsComponentAdded(instance);
+  }
+}
+function deactivate(vnode, container, { m: move }, parentComponent, parentSuspense) {
+  const instance = vnode.component;
+  invalidateMount(instance.m);
+  invalidateMount(instance.a);
+  move(vnode, container, null, 1, parentComponent, parentSuspense);
+  queuePostRenderEffect(
+    () => {
+      if (instance.da) {
+        shared.invokeArrayFns(instance.da);
+      }
+      const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
+      if (vnodeHook) {
+        invokeVNodeHook(vnodeHook, instance.parent, vnode);
+      }
+      instance.isDeactivated = true;
+    },
+    void 0,
+    parentSuspense
+  );
+  {
+    devtoolsComponentAdded(instance);
+  }
+}
 
 function injectHook(type, hook, target = currentInstance, prepend = false) {
   if (target) {
@@ -3080,12 +3237,13 @@ function renderSlot(slots, name, props = {}, fallback, noSlotted) {
     return ret;
   }
   if (currentRenderingInstance && (currentRenderingInstance.ce || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.ce)) {
+    const hasProps = Object.keys(props).length > 0;
     if (name !== "default") props.name = name;
     return openBlock(), createBlock(
       Fragment,
       null,
       [createVNode("slot", props, fallback && fallback())],
-      64
+      hasProps ? -2 : 64
     );
   }
   if (slot && slot.length > 1) {
@@ -3099,6 +3257,7 @@ function renderSlot(slots, name, props = {}, fallback, noSlotted) {
   }
   openBlock();
   const validSlotContent = slot && ensureValidVNode(slot(props));
+  ensureVaporSlotFallback(validSlotContent, fallback);
   const slotKey = props.key || // slot content array of a dynamic conditional slot may have a branch
   // key attached in the `createSlots` helper, respect that
   validSlotContent && validSlotContent.key;
@@ -3128,6 +3287,14 @@ function ensureValidVNode(vnodes) {
     return true;
   }) ? vnodes : null;
 }
+function ensureVaporSlotFallback(vnodes, fallback) {
+  let vaporSlot;
+  if (vnodes && vnodes.length === 1 && isVNode(vnodes[0]) && (vaporSlot = vnodes[0].vs)) {
+    if (!vaporSlot.fallback && fallback) {
+      vaporSlot.fallback = fallback;
+    }
+  }
+}
 
 function toHandlers(obj, preserveCaseIfNecessary) {
   const ret = {};
@@ -3290,10 +3457,10 @@ const PublicInstanceProxyHandlers = {
     return true;
   },
   has({
-    _: { data, setupState, accessCache, ctx, appContext, propsOptions }
+    _: { data, setupState, accessCache, ctx, appContext, propsOptions, type }
   }, key) {
-    let normalizedProps;
-    return !!accessCache[key] || data !== shared.EMPTY_OBJ && shared.hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && shared.hasOwn(normalizedProps, key) || shared.hasOwn(ctx, key) || shared.hasOwn(publicPropertiesMap, key) || shared.hasOwn(appContext.config.globalProperties, key);
+    let normalizedProps, cssModules;
+    return !!(accessCache[key] || data !== shared.EMPTY_OBJ && key[0] !== "$" && shared.hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && shared.hasOwn(normalizedProps, key) || shared.hasOwn(ctx, key) || shared.hasOwn(publicPropertiesMap, key) || shared.hasOwn(appContext.config.globalProperties, key) || (cssModules = type.__cssModules) && cssModules[key]);
   },
   defineProperty(target, key, descriptor) {
     if (descriptor.get != null) {
@@ -3431,15 +3598,15 @@ function withDefaults(props, defaults) {
   return null;
 }
 function useSlots() {
-  return getContext().slots;
+  return getContext("useSlots").slots;
 }
 function useAttrs() {
-  return getContext().attrs;
+  return getContext("useAttrs").attrs;
 }
-function getContext() {
+function getContext(calledFunctionName) {
   const i = getCurrentGenericInstance();
   if (!i) {
-    warn$1(`useContext() called without active instance.`);
+    warn$1(`${calledFunctionName}() called without active instance.`);
   }
   if (i.vapor) {
     return i;
@@ -3695,7 +3862,8 @@ function applyOptions(instance) {
       expose.forEach((key) => {
         Object.defineProperty(exposed, key, {
           get: () => publicThis[key],
-          set: (val) => publicThis[key] = val
+          set: (val) => publicThis[key] = val,
+          enumerable: true
         });
       });
     } else if (!instance.exposed) {
@@ -4568,7 +4736,7 @@ function isBoolean(...args) {
   return args.some((elem) => elem.toLowerCase() === "boolean");
 }
 
-const isInternalKey = (key) => key[0] === "_" || key === "$stable";
+const isInternalKey = (key) => key === "_" || key === "_ctx" || key === "$stable";
 const normalizeSlotValue = (value) => shared.isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
 const normalizeSlot = (key, rawSlot, ctx) => {
   if (rawSlot._n) {
@@ -4622,8 +4790,6 @@ const assignSlots = (slots, children, optimized) => {
 const initSlots = (instance, children, optimized) => {
   const slots = instance.slots = createInternalObject();
   if (instance.vnode.shapeFlag & 32) {
-    const cacheIndexes = children.__;
-    if (cacheIndexes) shared.def(slots, "__", cacheIndexes, true);
     const type = children._;
     if (type) {
       assignSlots(slots, children, optimized);
@@ -4687,12 +4853,10 @@ function endMeasure(instance, type) {
   if (instance.appContext.config.performance && isSupported()) {
     const startTag = `vue-${type}-${instance.uid}`;
     const endTag = startTag + `:end`;
+    const measureName = `<${formatComponentName(instance, instance.type)}> ${type}`;
     perf.mark(endTag);
-    perf.measure(
-      `<${formatComponentName(instance, instance.type)}> ${type}`,
-      startTag,
-      endTag
-    );
+    perf.measure(measureName, startTag, endTag);
+    perf.clearMeasures(measureName);
     perf.clearMarks(startTag);
     perf.clearMarks(endTag);
   }
@@ -4931,15 +5095,25 @@ function baseCreateRenderer(options, createHydrationFns) {
         optimized
       );
     } else {
-      patchElement(
-        n1,
-        n2,
-        parentComponent,
-        parentSuspense,
-        namespace,
-        slotScopeIds,
-        optimized
-      );
+      const customElement = !!(n1.el && n1.el._isVueCE) ? n1.el : null;
+      try {
+        if (customElement) {
+          customElement._beginPatch();
+        }
+        patchElement(
+          n1,
+          n2,
+          parentComponent,
+          parentSuspense,
+          namespace,
+          slotScopeIds,
+          optimized
+        );
+      } finally {
+        if (customElement) {
+          customElement._endPatch();
+        }
+      }
     }
   };
   const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
@@ -4990,16 +5164,20 @@ function baseCreateRenderer(options, createHydrationFns) {
     if (dirs) {
       invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
     }
-    const needCallTransitionHooks = needTransition(parentSuspense, transition);
-    if (needCallTransitionHooks) {
-      transition.beforeEnter(el);
+    if (transition) {
+      performTransitionEnter(
+        el,
+        transition,
+        () => hostInsert(el, container, anchor),
+        parentSuspense
+      );
+    } else {
+      hostInsert(el, container, anchor);
     }
-    hostInsert(el, container, anchor);
-    if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {
+    if ((vnodeHook = props && props.onVnodeMounted) || dirs) {
       queuePostRenderEffect(
         () => {
           vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
-          needCallTransitionHooks && transition.enter(el);
           dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
         },
         void 0,
@@ -5016,21 +5194,9 @@ function baseCreateRenderer(options, createHydrationFns) {
         hostSetScopeId(el, slotScopeIds[i]);
       }
     }
-    let subTree = parentComponent && parentComponent.subTree;
-    if (subTree) {
-      if (subTree.patchFlag > 0 && subTree.patchFlag & 2048) {
-        subTree = filterSingleRoot(subTree.children) || subTree;
-      }
-      if (vnode === subTree || isSuspense(subTree.type) && (subTree.ssContent === vnode || subTree.ssFallback === vnode)) {
-        const parentVNode = parentComponent.vnode;
-        setScopeId(
-          el,
-          parentVNode,
-          parentVNode.scopeId,
-          parentVNode.slotScopeIds,
-          parentComponent.parent
-        );
-      }
+    const inheritedScopeIds = getInheritedScopeIds(vnode, parentComponent);
+    for (let i = 0; i < inheritedScopeIds.length; i++) {
+      hostSetScopeId(el, inheritedScopeIds[i]);
     }
   };
   const mountChildren = (children, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, start = 0) => {
@@ -5271,12 +5437,21 @@ function baseCreateRenderer(options, createHydrationFns) {
     n2.slotScopeIds = slotScopeIds;
     if (n2.type.__vapor) {
       if (n1 == null) {
-        getVaporInterface(parentComponent, n2).mount(
-          n2,
-          container,
-          anchor,
-          parentComponent
-        );
+        if (n2.shapeFlag & 512) {
+          getVaporInterface(parentComponent, n2).activate(
+            n2,
+            container,
+            anchor,
+            parentComponent
+          );
+        } else {
+          getVaporInterface(parentComponent, n2).mount(
+            n2,
+            container,
+            anchor,
+            parentComponent
+          );
+        }
       } else {
         getVaporInterface(parentComponent, n2).update(
           n1,
@@ -5339,6 +5514,7 @@ function baseCreateRenderer(options, createHydrationFns) {
       if (!initialVNode.el) {
         const placeholder = instance.subTree = createVNode(Comment);
         processCommentNode(null, placeholder, container, anchor);
+        initialVNode.placeholder = placeholder.el;
       }
     } else {
       setupRenderEffect(
@@ -5879,7 +6055,11 @@ function baseCreateRenderer(options, createHydrationFns) {
       for (i = toBePatched - 1; i >= 0; i--) {
         const nextIndex = s2 + i;
         const nextChild = c2[nextIndex];
-        const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor;
+        const anchorVNode = c2[nextIndex + 1];
+        const anchor = nextIndex + 1 < l2 ? (
+          // #13559, fallback to el placeholder for unresolved async component
+          anchorVNode.el || anchorVNode.placeholder
+        ) : parentAnchor;
         if (newIndexToOldIndexMap[i] === 0) {
           patch(
             null,
@@ -5959,12 +6139,12 @@ function baseCreateRenderer(options, createHydrationFns) {
     const needTransition2 = moveType !== 2 && shapeFlag & 1 && transition;
     if (needTransition2) {
       if (moveType === 0) {
-        transition.beforeEnter(el);
-        hostInsert(el, container, anchor);
-        queuePostRenderEffect(
-          () => transition.enter(el),
-          void 0,
-          parentSuspense
+        performTransitionEnter(
+          el,
+          transition,
+          () => hostInsert(el, container, anchor),
+          parentSuspense,
+          true
         );
       } else {
         const { leave, delayLeave, afterLeave } = transition;
@@ -5976,6 +6156,12 @@ function baseCreateRenderer(options, createHydrationFns) {
           }
         };
         const performLeave = () => {
+          if (el._isLeaving) {
+            el[leaveCbKey](
+              true
+              /* cancelled */
+            );
+          }
           leave(el, () => {
             remove2();
             afterLeave && afterLeave();
@@ -6015,7 +6201,14 @@ function baseCreateRenderer(options, createHydrationFns) {
       parentComponent.renderCache[cacheIndex] = void 0;
     }
     if (shapeFlag & 256) {
-      parentComponent.ctx.deactivate(vnode);
+      if (vnode.type.__vapor) {
+        getVaporInterface(parentComponent, vnode).deactivate(
+          vnode,
+          parentComponent.ctx.getStorageContainer()
+        );
+      } else {
+        parentComponent.ctx.deactivate(vnode);
+      }
       return;
     }
     const shouldInvokeDirs = shapeFlag & 1 && dirs;
@@ -6103,22 +6296,15 @@ function baseCreateRenderer(options, createHydrationFns) {
       removeStaticNode(vnode);
       return;
     }
-    const performRemove = () => {
-      hostRemove(el);
-      if (transition && !transition.persisted && transition.afterLeave) {
-        transition.afterLeave();
-      }
-    };
-    if (vnode.shapeFlag & 1 && transition && !transition.persisted) {
-      const { leave, delayLeave } = transition;
-      const performLeave = () => leave(el, performRemove);
-      if (delayLeave) {
-        delayLeave(vnode.el, performRemove, performLeave);
-      } else {
-        performLeave();
-      }
+    if (transition) {
+      performTransitionLeave(
+        el,
+        transition,
+        () => hostRemove(el),
+        !!(vnode.shapeFlag & 1)
+      );
     } else {
-      performRemove();
+      hostRemove(el);
     }
   };
   const removeFragment = (cur, end) => {
@@ -6134,27 +6320,12 @@ function baseCreateRenderer(options, createHydrationFns) {
     if (instance.type.__hmrId) {
       unregisterHMR(instance);
     }
-    const {
-      bum,
-      scope,
-      effect,
-      subTree,
-      um,
-      m,
-      a,
-      parent,
-      slots: { __: slotCacheKeys }
-    } = instance;
+    const { bum, scope, effect, subTree, um, m, a } = instance;
     invalidateMount(m);
     invalidateMount(a);
     if (bum) {
       shared.invokeArrayFns(bum);
     }
-    if (parent && shared.isArray(slotCacheKeys)) {
-      slotCacheKeys.forEach((v) => {
-        parent.renderCache[v] = void 0;
-      });
-    }
     scope.stop();
     if (effect) {
       effect.stop();
@@ -6168,12 +6339,6 @@ function baseCreateRenderer(options, createHydrationFns) {
       void 0,
       parentSuspense
     );
-    if (parentSuspense && parentSuspense.pendingBranch && !parentSuspense.isUnmounted && instance.asyncDep && !instance.asyncResolved && instance.suspenseId === parentSuspense.pendingId) {
-      parentSuspense.deps--;
-      if (parentSuspense.deps === 0) {
-        parentSuspense.resolve();
-      }
-    }
     {
       devtoolsComponentRemoved(instance);
     }
@@ -6186,7 +6351,7 @@ function baseCreateRenderer(options, createHydrationFns) {
   const getNextHostNode = (vnode) => {
     if (vnode.shapeFlag & 6) {
       if (vnode.type.__vapor) {
-        return hostNextSibling(vnode.component.block);
+        return hostNextSibling(vnode.anchor);
       }
       return getNextHostNode(vnode.component.subTree);
     }
@@ -6264,6 +6429,7 @@ function baseCreateRenderer(options, createHydrationFns) {
   return {
     render,
     hydrate,
+    hydrateNode,
     internals,
     createApp: createAppAPI(
       mountApp,
@@ -6303,7 +6469,8 @@ function traverseStaticChildren(n1, n2, shallow = false) {
         if (!shallow && c2.patchFlag !== -2)
           traverseStaticChildren(c1, c2);
       }
-      if (c2.type === Text) {
+      if (c2.type === Text && // avoid cached text nodes retaining detached dom nodes
+      c2.patchFlag !== -1) {
         c2.el = c1.el;
       }
       if (c2.type === Comment && !c2.el) {
@@ -6316,7 +6483,7 @@ function traverseStaticChildren(n1, n2, shallow = false) {
   }
 }
 function locateNonHydratedAsyncRoot(instance) {
-  const subComponent = instance.subTree.component;
+  const subComponent = instance.subTree && instance.subTree.component;
   if (subComponent) {
     if (subComponent.asyncDep && !subComponent.asyncResolved) {
       return subComponent;
@@ -6331,6 +6498,34 @@ function invalidateMount(hooks) {
       hooks[i].flags |= 4;
   }
 }
+function performTransitionEnter(el, transition, insert, parentSuspense, force = false) {
+  if (force || needTransition(parentSuspense, transition)) {
+    transition.beforeEnter(el);
+    insert();
+    queuePostRenderEffect(() => transition.enter(el), void 0, parentSuspense);
+  } else {
+    insert();
+  }
+}
+function performTransitionLeave(el, transition, remove, isElement = true) {
+  const performRemove = () => {
+    remove();
+    if (transition && !transition.persisted && transition.afterLeave) {
+      transition.afterLeave();
+    }
+  };
+  if (isElement && transition && !transition.persisted) {
+    const { leave, delayLeave } = transition;
+    const performLeave = () => leave(el, performRemove);
+    if (delayLeave) {
+      delayLeave(el, performRemove, performLeave);
+    } else {
+      performLeave();
+    }
+  } else {
+    performRemove();
+  }
+}
 function getVaporInterface(instance, vnode) {
   const ctx = instance ? instance.appContext : vnode.appContext;
   const res = ctx && ctx.vapor;
@@ -6345,6 +6540,32 @@ app.use(vaporInteropPlugin)
   }
   return res;
 }
+function getInheritedScopeIds(vnode, parentComponent) {
+  const inheritedScopeIds = [];
+  let currentParent = parentComponent;
+  let currentVNode = vnode;
+  while (currentParent) {
+    let subTree = currentParent.subTree;
+    if (!subTree) break;
+    if (subTree.patchFlag > 0 && subTree.patchFlag & 2048) {
+      subTree = filterSingleRoot(subTree.children) || subTree;
+    }
+    if (currentVNode === subTree || isSuspense(subTree.type) && (subTree.ssContent === currentVNode || subTree.ssFallback === currentVNode)) {
+      const parentVNode = currentParent.vnode;
+      if (parentVNode.scopeId) {
+        inheritedScopeIds.push(parentVNode.scopeId);
+      }
+      if (parentVNode.slotScopeIds) {
+        inheritedScopeIds.push(...parentVNode.slotScopeIds);
+      }
+      currentVNode = parentVNode;
+      currentParent = currentParent.parent;
+    } else {
+      break;
+    }
+  }
+  return inheritedScopeIds;
+}
 
 const ssrContextKey = Symbol.for("v-scx");
 const useSSRContext = () => {
@@ -6684,8 +6905,9 @@ function baseEmit(instance, props, getter, event, ...rawArgs) {
 function defaultPropGetter(props, key) {
   return props[key];
 }
+const mixinEmitsCache = /* @__PURE__ */ new WeakMap();
 function normalizeEmitsOptions(comp, appContext, asMixin = false) {
-  const cache = appContext.emitsCache;
+  const cache = asMixin ? mixinEmitsCache : appContext.emitsCache;
   const cached = cache.get(comp);
   if (cached !== void 0) {
     return cached;
@@ -7133,7 +7355,7 @@ function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, sl
   const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense;
   if (pendingBranch) {
     suspense.pendingBranch = newBranch;
-    if (isSameVNodeType(newBranch, pendingBranch)) {
+    if (isSameVNodeType(pendingBranch, newBranch)) {
       patch(
         pendingBranch,
         newBranch,
@@ -7204,7 +7426,7 @@ function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, sl
           );
           setActiveBranch(suspense, newFallback);
         }
-      } else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
+      } else if (activeBranch && isSameVNodeType(activeBranch, newBranch)) {
         patch(
           activeBranch,
           newBranch,
@@ -7235,7 +7457,7 @@ function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, sl
       }
     }
   } else {
-    if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
+    if (activeBranch && isSameVNodeType(activeBranch, newBranch)) {
       patch(
         activeBranch,
         newBranch,
@@ -7348,7 +7570,8 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
         pendingId,
         effects,
         parentComponent: parentComponent2,
-        container: container2
+        container: container2,
+        isInFallback
       } = suspense;
       let delayEnter = false;
       if (suspense.isHydrating) {
@@ -7366,6 +7589,9 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
                 parentComponent2
               );
               queuePostFlushCb(effects);
+              if (isInFallback && vnode2.ssFallback) {
+                vnode2.ssFallback.el = null;
+              }
             }
           };
         }
@@ -7374,6 +7600,9 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
             anchor = next(activeBranch);
           }
           unmount(activeBranch, parentComponent2, suspense, true);
+          if (!delayEnter && isInFallback && vnode2.ssFallback) {
+            vnode2.ssFallback.el = null;
+          }
         }
         if (!delayEnter) {
           move(
@@ -7498,6 +7727,7 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
           optimized2
         );
         if (placeholder) {
+          vnode2.placeholder = null;
           remove(placeholder);
         }
         updateHOCHostEl(instance, vnode2.el);
@@ -7703,15 +7933,11 @@ const createVNodeWithArgsTransform = (...args) => {
   );
 };
 const normalizeKey = ({ key }) => key != null ? key : null;
-const normalizeRef = ({
-  ref,
-  ref_key,
-  ref_for
-}) => {
+const normalizeRef = ({ ref, ref_key, ref_for }, i = currentRenderingInstance) => {
   if (typeof ref === "number") {
     ref = "" + ref;
   }
-  return ref != null ? shared.isString(ref) || reactivity.isRef(ref) || shared.isFunction(ref) ? { i: currentRenderingInstance, r: ref, k: ref_key, f: !!ref_for } : ref : null;
+  return ref != null ? shared.isString(ref) || reactivity.isRef(ref) || shared.isFunction(ref) ? { i, r: ref, k: ref_key, f: !!ref_for } : ref : null;
 };
 function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
   const vnode = {
@@ -7877,6 +8103,7 @@ function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false
     suspense: vnode.suspense,
     ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
     ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
+    placeholder: vnode.placeholder,
     el: vnode.el,
     anchor: vnode.anchor,
     ctx: vnode.ctx,
@@ -8403,7 +8630,7 @@ function getComponentPublicInstance(instance) {
     return instance.proxy;
   }
 }
-const classifyRE = /(?:^|[-_])(\w)/g;
+const classifyRE = /(?:^|[-_])\w/g;
 const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
 function getComponentName(Component, includeInferred = true) {
   return shared.isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
@@ -8439,23 +8666,28 @@ const computed = (getterOrOptions, debugOptions) => {
 };
 
 function h(type, propsOrChildren, children) {
-  const l = arguments.length;
-  if (l === 2) {
-    if (shared.isObject(propsOrChildren) && !shared.isArray(propsOrChildren)) {
-      if (isVNode(propsOrChildren)) {
-        return createVNode(type, null, [propsOrChildren]);
+  try {
+    setBlockTracking(-1);
+    const l = arguments.length;
+    if (l === 2) {
+      if (shared.isObject(propsOrChildren) && !shared.isArray(propsOrChildren)) {
+        if (isVNode(propsOrChildren)) {
+          return createVNode(type, null, [propsOrChildren]);
+        }
+        return createVNode(type, propsOrChildren);
+      } else {
+        return createVNode(type, null, propsOrChildren);
       }
-      return createVNode(type, propsOrChildren);
     } else {
-      return createVNode(type, null, propsOrChildren);
-    }
-  } else {
-    if (l > 3) {
-      children = Array.prototype.slice.call(arguments, 2);
-    } else if (l === 3 && isVNode(children)) {
-      children = [children];
+      if (l > 3) {
+        children = Array.prototype.slice.call(arguments, 2);
+      } else if (l === 3 && isVNode(children)) {
+        children = [children];
+      }
+      return createVNode(type, propsOrChildren, children);
     }
-    return createVNode(type, propsOrChildren, children);
+  } finally {
+    setBlockTracking(1);
   }
 }
 
@@ -8665,7 +8897,7 @@ function isMemoSame(cached, memo) {
   return true;
 }
 
-const version = "3.6.0-alpha.1";
+const version = "3.6.0-alpha.3";
 const warn = warn$1 ;
 const ErrorTypeStrings = ErrorTypeStrings$1 ;
 const devtools = devtools$1 ;