@vue/compat 3.6.0-alpha.2 → 3.6.0-alpha.4

package/dist/vue.cjs.prod.js

@@ -1,5 +1,5 @@
 /**
-* @vue/compat v3.6.0-alpha.2
+* @vue/compat v3.6.0-alpha.4
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -10,7 +10,6 @@ var estreeWalker = require('estree-walker');
 var decode_js = require('entities/lib/decode.js');
 var sourceMapJs = require('source-map-js');
 
-/*! #__NO_SIDE_EFFECTS__ */
 // @__NO_SIDE_EFFECTS__
 function makeMap(str) {
   const map = /* @__PURE__ */ Object.create(null);
@@ -65,10 +64,10 @@ const isBuiltInDirective = /* @__PURE__ */ makeMap(
 );
 const cacheStringFunction = (fn) => {
   const cache = /* @__PURE__ */ Object.create(null);
-  return (str) => {
+  return ((str) => {
     const hit = cache[str];
     return hit || (cache[str] = fn(str));
-  };
+  });
 };
 const camelizeRE = /-(\w)/g;
 const camelizeReplacer = (_, c) => c ? c.toUpperCase() : "";
@@ -88,6 +87,9 @@ const toHandlerKey = cacheStringFunction(
     return s;
   }
 );
+const getModifierPropName = (name) => {
+  return `${name === "modelValue" || name === "model-value" ? "model" : name}Modifiers${name === "model" ? "$" : ""}`;
+};
 const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
 const invokeArrayFns = (fns, ...arg) => {
   for (let i = 0; i < fns.length; i++) {
@@ -249,6 +251,9 @@ function shouldSetAsAttr(tagName, key) {
   if ((key === "width" || key === "height") && (tagName === "IMG" || tagName === "VIDEO" || tagName === "CANVAS" || tagName === "SOURCE")) {
     return true;
   }
+  if (key === "sandbox" && tagName === "IFRAME") {
+    return true;
+  }
   return false;
 }
 
@@ -448,6 +453,7 @@ var ReactiveFlags = /* @__PURE__ */ ((ReactiveFlags2) => {
 const notifyBuffer = [];
 let batchDepth = 0;
 let activeSub = void 0;
+let globalVersion = 0;
 let notifyIndex = 0;
 let notifyBufferLength = 0;
 function setActiveSub(sub) {
@@ -470,17 +476,18 @@ function link(dep, sub) {
   if (prevDep !== void 0 && prevDep.dep === dep) {
     return;
   }
-  let nextDep = void 0;
-  const recursedCheck = sub.flags & 4 /* RecursedCheck */;
-  if (recursedCheck) {
-    nextDep = prevDep !== void 0 ? prevDep.nextDep : sub.deps;
-    if (nextDep !== void 0 && nextDep.dep === dep) {
-      sub.depsTail = nextDep;
-      return;
-    }
+  const nextDep = prevDep !== void 0 ? prevDep.nextDep : sub.deps;
+  if (nextDep !== void 0 && nextDep.dep === dep) {
+    nextDep.version = globalVersion;
+    sub.depsTail = nextDep;
+    return;
   }
   const prevSub = dep.subsTail;
+  if (prevSub !== void 0 && prevSub.version === globalVersion && prevSub.sub === sub) {
+    return;
+  }
   const newLink = sub.depsTail = dep.subsTail = {
+    version: globalVersion,
     dep,
     sub,
     prevDep,
@@ -586,6 +593,7 @@ function propagate(link2) {
   } while (true);
 }
 function startTracking(sub) {
+  ++globalVersion;
   sub.depsTail = void 0;
   sub.flags = sub.flags & -57 | 4 /* RecursedCheck */;
   return setActiveSub(sub);
@@ -681,18 +689,12 @@ function shallowPropagate(link2) {
   } while (link2 !== void 0);
 }
 function isValidLink(checkLink, sub) {
-  const depsTail = sub.depsTail;
-  if (depsTail !== void 0) {
-    let link2 = sub.deps;
-    do {
-      if (link2 === checkLink) {
-        return true;
-      }
-      if (link2 === depsTail) {
-        break;
-      }
-      link2 = link2.nextDep;
-    } while (link2 !== void 0);
+  let link2 = sub.depsTail;
+  while (link2 !== void 0) {
+    if (link2 === checkLink) {
+      return true;
+    }
+    link2 = link2.prevDep;
   }
   return false;
 }
@@ -860,7 +862,7 @@ const arrayInstrumentations = {
   join(separator) {
     return reactiveReadArray(this).join(separator);
   },
-  // keys() iterator only reads `length`, no optimisation required
+  // keys() iterator only reads `length`, no optimization required
   lastIndexOf(...args) {
     return searchProxy(this, "lastIndexOf", args);
   },
@@ -912,7 +914,7 @@ function iterator(self, method, wrapValue) {
     iter._next = iter.next;
     iter.next = () => {
       const result = iter._next();
-      if (result.value) {
+      if (!result.done) {
         result.value = wrapValue(result.value);
       }
       return result;
@@ -1043,7 +1045,8 @@ class BaseReactiveHandler {
       return res;
     }
     if (isRef(res)) {
-      return targetIsArray && isIntegerKey(key) ? res : res.value;
+      const value = targetIsArray && isIntegerKey(key) ? res : res.value;
+      return isReadonly2 && isObject(value) ? readonly(value) : value;
     }
     if (isObject(res)) {
       return isReadonly2 ? readonly(res) : reactive(res);
@@ -1065,7 +1068,7 @@ class MutableReactiveHandler extends BaseReactiveHandler {
       }
       if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
         if (isOldValueReadonly) {
-          return false;
+          return true;
         } else {
           oldValue.value = value;
           return true;
@@ -1191,7 +1194,7 @@ function createInstrumentations(readonly, shallow) {
     get size() {
       const target = this["__v_raw"];
       !readonly && track(toRaw(target), "iterate", ITERATE_KEY);
-      return Reflect.get(target, "size", target);
+      return target.size;
     },
     has(key) {
       const target = this["__v_raw"];
@@ -2111,11 +2114,11 @@ function traverse(value, depth = Infinity, seen) {
   if (depth <= 0 || !isObject(value) || value["__v_skip"]) {
     return value;
   }
-  seen = seen || /* @__PURE__ */ new Set();
-  if (seen.has(value)) {
+  seen = seen || /* @__PURE__ */ new Map();
+  if ((seen.get(value) || 0) >= depth) {
     return value;
   }
-  seen.add(value);
+  seen.set(value, depth);
   depth--;
   if (isRef(value)) {
     traverse(value.value, depth, seen);
@@ -2837,9 +2840,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,
@@ -2861,6 +2861,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);
@@ -3049,26 +3052,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;
@@ -3099,6 +3110,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);
 }
@@ -3139,7 +3154,7 @@ function useTransitionState() {
     isMounted: false,
     isLeaving: false,
     isUnmounting: false,
-    leavingVNodes: /* @__PURE__ */ new Map()
+    leavingNodes: /* @__PURE__ */ new Map()
   };
   onMounted(() => {
     state.isMounted = true;
@@ -3171,7 +3186,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 = {
@@ -3207,7 +3222,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,
@@ -3272,15 +3287,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,
@@ -3298,8 +3351,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,
@@ -3335,10 +3386,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) {
@@ -3375,7 +3423,6 @@ function resolveTransitionHooks(vnode, props, state, instance, postClone) {
       }
     },
     leave(el, remove) {
-      const key2 = String(vnode.key);
       if (el[enterCbKey$1]) {
         el[enterCbKey$1](
           true
@@ -3397,27 +3444,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;
@@ -3451,8 +3488,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);
@@ -3483,7 +3527,6 @@ function getTransitionRawChildren(children, keepComment = false, parentKey) {
   return ret;
 }
 
-/*! #__NO_SIDE_EFFECTS__ */
 // @__NO_SIDE_EFFECTS__
 function defineComponent(options, extraOptions) {
   return isFunction(options) ? (
@@ -3521,6 +3564,7 @@ function useTemplateRef(key) {
   return ret;
 }
 
+const pendingSetRefMap = /* @__PURE__ */ new WeakMap();
 function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
   if (isArray(rawRef)) {
     rawRef.forEach(
@@ -3546,18 +3590,20 @@ function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
   const oldRef = oldRawRef && oldRawRef.r;
   const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs;
   const setupState = owner.setupState;
-  const rawSetupState = toRaw(setupState);
-  const canSetSetupRef = setupState === EMPTY_OBJ ? () => false : (key) => {
-    return hasOwn(rawSetupState, key);
-  };
+  const canSetSetupRef = createCanSetSetupRefChecker(setupState);
   if (oldRef != null && oldRef !== ref) {
+    invalidatePendingSetRef(oldRawRef);
     if (isString(oldRef)) {
       refs[oldRef] = null;
       if (canSetSetupRef(oldRef)) {
         setupState[oldRef] = null;
       }
     } else if (isRef(oldRef)) {
-      oldRef.value = null;
+      {
+        oldRef.value = null;
+      }
+      const oldRawRefAtom = oldRawRef;
+      if (oldRawRefAtom.k) refs[oldRawRefAtom.k] = null;
     }
   }
   if (isFunction(ref)) {
@@ -3568,7 +3614,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] : ref.value ;
           if (isUnmount) {
             isArray(existing) && remove(existing, refValue);
           } else {
@@ -3579,8 +3625,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];
+                {
+                  ref.value = newVal;
+                }
+                if (rawRef.k) refs[rawRef.k] = newVal;
               }
             } else if (!existing.includes(refValue)) {
               existing.push(refValue);
@@ -3592,18 +3641,39 @@ function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
             setupState[ref] = value;
           }
         } else if (_isRef) {
-          ref.value = value;
+          {
+            ref.value = value;
+          }
           if (rawRef.k) refs[rawRef.k] = value;
         } else ;
       };
       if (value) {
-        queuePostRenderEffect(doSet, -1, parentSuspense);
+        const job = () => {
+          doSet();
+          pendingSetRefMap.delete(rawRef);
+        };
+        pendingSetRefMap.set(rawRef, job);
+        queuePostRenderEffect(job, -1, parentSuspense);
       } else {
+        invalidatePendingSetRef(rawRef);
         doSet();
       }
     }
   }
 }
+function createCanSetSetupRefChecker(setupState) {
+  const rawSetupState = toRaw(setupState);
+  return setupState === void 0 || setupState === EMPTY_OBJ ? NO : (key) => {
+    return hasOwn(rawSetupState, key);
+  };
+}
+function invalidatePendingSetRef(rawRef) {
+  const pendingSetRef = pendingSetRefMap.get(rawRef);
+  if (pendingSetRef) {
+    pendingSetRef.flags |= 4;
+    pendingSetRefMap.delete(rawRef);
+  }
+}
 
 let hasLoggedMismatchError = false;
 const logMismatchError = () => {
@@ -3684,7 +3754,7 @@ function createHydrationFunctions(rendererInternals) {
         }
         break;
       case Comment:
-        if (isTemplateNode(node)) {
+        if (isTemplateNode$1(node)) {
           nextNode = nextSibling(node);
           replaceNode(
             vnode.el = node.content.firstChild,
@@ -3732,9 +3802,15 @@ 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)) {
+          if ((domType !== 1 || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) && !isTemplateNode$1(node)) {
             nextNode = onMismatch();
           } else {
             nextNode = hydrateElement(
@@ -3747,9 +3823,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) {
@@ -3759,15 +3832,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) {
@@ -3822,7 +3905,7 @@ function createHydrationFunctions(rendererInternals) {
         invokeDirectiveHook(vnode, null, parentComponent, "created");
       }
       let needCallTransitionHooks = false;
-      if (isTemplateNode(el)) {
+      if (isTemplateNode$1(el)) {
         needCallTransitionHooks = needTransition(
           null,
           // no need check parentSuspense in hydration
@@ -3849,7 +3932,7 @@ function createHydrationFunctions(rendererInternals) {
           optimized
         );
         while (next) {
-          if (!isMismatchAllowed(el, 1 /* CHILDREN */)) {
+          if (!isMismatchAllowed(el, 1)) {
             logMismatchError();
           }
           const cur = next;
@@ -3861,8 +3944,10 @@ function createHydrationFunctions(rendererInternals) {
         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)) {
             logMismatchError();
           }
           el.textContent = vnode.children;
@@ -3942,7 +4027,7 @@ function createHydrationFunctions(rendererInternals) {
       } else if (isText && !vnode.children) {
         insert(vnode.el = createText(""), container);
       } else {
-        if (!isMismatchAllowed(container, 1 /* CHILDREN */)) {
+        if (!isMismatchAllowed(container, 1)) {
           logMismatchError();
         }
         patch(
@@ -3983,7 +4068,7 @@ function createHydrationFunctions(rendererInternals) {
     }
   };
   const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => {
-    if (!isMismatchAllowed(node.parentElement, 1 /* CHILDREN */)) {
+    if (!isMismatchAllowed(node.parentElement, 1)) {
       logMismatchError();
     }
     vnode.el = null;
@@ -4047,21 +4132,21 @@ function createHydrationFunctions(rendererInternals) {
       parent = parent.parent;
     }
   };
-  const isTemplateNode = (node) => {
-    return node.nodeType === 1 && node.tagName === "TEMPLATE";
-  };
   return [hydrate, hydrateNode];
 }
+const isTemplateNode$1 = (node) => {
+  return node.nodeType === 1 && node.tagName === "TEMPLATE";
+};
 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;
     }
@@ -4073,7 +4158,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]);
@@ -4130,7 +4215,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 = () => {
@@ -4172,89 +4259,46 @@ function forEachElement(node, cb) {
 }
 
 const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
-/*! #__NO_SIDE_EFFECTS__ */
 // @__NO_SIDE_EFFECTS__
 function defineAsyncComponent(source) {
-  if (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 && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
-        comp = comp.default;
-      }
-      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) {
-      const doHydrate = hydrateStrategy ? () => {
-        const performHydrate = () => {
-          hydrate();
-        };
-        const teardown = hydrateStrategy(
-          performHydrate,
-          (cb) => forEachElement(el, cb)
-        );
-        if (teardown) {
-          (instance.bum || (instance.bum = [])).push(teardown);
-        }
-        (instance.u || (instance.u = [])).push(() => 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,
@@ -4272,25 +4316,11 @@ function defineAsyncComponent(source) {
           }) : null;
         });
       }
-      const loaded = ref(false);
-      const error = ref();
-      const delayed = 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)) {
@@ -4301,6 +4331,7 @@ function defineAsyncComponent(source) {
         error.value = err;
       });
       return () => {
+        resolvedComp = getResolvedComp();
         if (loaded.value && resolvedComp) {
           return createInnerComp(resolvedComp, instance);
         } else if (error.value && errorComponent) {
@@ -4308,7 +4339,10 @@ function defineAsyncComponent(source) {
             error: error.value
           });
         } else if (loadingComponent && !delayed.value) {
-          return createVNode(loadingComponent);
+          return createInnerComp(
+            loadingComponent,
+            instance
+          );
         }
       };
     }
@@ -4322,6 +4356,94 @@ function createInnerComp(comp, parent) {
   delete parent.vnode.ce;
   return vnode;
 }
+function createAsyncComponentContext(source) {
+  if (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 && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
+        comp = comp.default;
+      }
+      resolvedComp = comp;
+      return comp;
+    }));
+  };
+  return {
+    load,
+    source,
+    getResolvedComp: () => resolvedComp,
+    setPendingRequest: (request) => pendingRequest = request
+  };
+}
+const useAsyncComponentState = (delay, timeout, onError) => {
+  const loaded = ref(false);
+  const error = ref();
+  const delayed = 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) {
+      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 = {
@@ -4348,77 +4470,37 @@ const KeepAliveImpl = {
     const keys = /* @__PURE__ */ new Set();
     let current = null;
     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) {
-            invokeArrayFns(instance.a);
-          }
-          const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
-          if (vnodeHook) {
-            invokeVNodeHook(vnodeHook, instance.parent, vnode);
-          }
-        },
-        void 0,
-        parentSuspense
-      );
     };
     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) {
-            invokeArrayFns(instance.da);
-          }
-          const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
-          if (vnodeHook) {
-            invokeVNodeHook(vnodeHook, instance.parent, vnode);
-          }
-          instance.isDeactivated = true;
-        },
-        void 0,
-        parentSuspense
-      );
     };
     function unmount(vnode) {
       resetShapeFlag(vnode);
@@ -4566,7 +4648,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) {
@@ -4580,8 +4662,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;
@@ -4607,6 +4690,62 @@ 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) {
+        invokeArrayFns(instance.a);
+      }
+      const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
+      if (vnodeHook) {
+        invokeVNodeHook(vnodeHook, instance.parent, vnode);
+      }
+    },
+    void 0,
+    parentSuspense
+  );
+}
+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) {
+        invokeArrayFns(instance.da);
+      }
+      const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
+      if (vnodeHook) {
+        invokeVNodeHook(vnodeHook, instance.parent, vnode);
+      }
+      instance.isDeactivated = true;
+    },
+    void 0,
+    parentSuspense
+  );
+}
 
 function injectHook(type, hook, target = currentInstance, prepend = false) {
   if (target) {
@@ -5065,12 +5204,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._c) {
@@ -5078,6 +5218,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;
@@ -5107,6 +5248,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 = {};
@@ -5164,7 +5313,7 @@ function legacyRenderSlot(instance, name, fallback, props, bindObject) {
   }
   return renderSlot(instance.slots, name, props, fallback && (() => fallback));
 }
-function legacyresolveScopedSlots(fns, raw, hasDynamicKeys) {
+function legacyResolveScopedSlots(fns, raw, hasDynamicKeys) {
   return createSlots(
     raw || { $stable: !hasDynamicKeys },
     mapKeyToName(fns)
@@ -5325,7 +5474,7 @@ function installCompatInstanceProperties(map) {
     _b: () => legacyBindObjectProps,
     _v: () => createTextVNode,
     _e: () => createCommentVNode,
-    _u: () => legacyresolveScopedSlots,
+    _u: () => legacyResolveScopedSlots,
     _g: () => legacyBindObjectListeners,
     _d: () => legacyBindDynamicKeys,
     _p: () => legacyPrependModifier
@@ -5463,10 +5612,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 !== EMPTY_OBJ && hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
+    let normalizedProps, cssModules;
+    return !!(accessCache[key] || data !== EMPTY_OBJ && key[0] !== "$" && hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key) || (cssModules = type.__cssModules) && cssModules[key]);
   },
   defineProperty(target, key, descriptor) {
     if (descriptor.get != null) {
@@ -5527,7 +5676,7 @@ function useSlots() {
 function useAttrs() {
   return getContext().attrs;
 }
-function getContext() {
+function getContext(calledFunctionName) {
   const i = getCurrentGenericInstance();
   if (i.vapor) {
     return i;
@@ -5719,7 +5868,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) {
@@ -6007,7 +6157,7 @@ function createCompatVue$1(createApp, createSingletonApp) {
       return vm;
     }
   }
-  Vue.version = `2.6.14-compat:${"3.6.0-alpha.2"}`;
+  Vue.version = `2.6.14-compat:${"3.6.0-alpha.4"}`;
   Vue.config = singletonApp.config;
   Vue.use = (plugin, ...options) => {
     if (plugin && isFunction(plugin.install)) {
@@ -6021,22 +6171,22 @@ function createCompatVue$1(createApp, createSingletonApp) {
     singletonApp.mixin(m);
     return Vue;
   };
-  Vue.component = (name, comp) => {
+  Vue.component = ((name, comp) => {
     if (comp) {
       singletonApp.component(name, comp);
       return Vue;
     } else {
       return singletonApp.component(name);
     }
-  };
-  Vue.directive = (name, dir) => {
+  });
+  Vue.directive = ((name, dir) => {
     if (dir) {
       singletonApp.directive(name, dir);
       return Vue;
     } else {
       return singletonApp.directive(name);
     }
-  };
+  });
   Vue.options = { _base: Vue };
   let cid = 1;
   Vue.cid = cid;
@@ -6099,14 +6249,14 @@ function createCompatVue$1(createApp, createSingletonApp) {
     assertCompatEnabled("GLOBAL_OBSERVABLE", null);
     return reactive(target);
   };
-  Vue.filter = (name, filter) => {
+  Vue.filter = ((name, filter) => {
     if (filter) {
       singletonApp.filter(name, filter);
       return Vue;
     } else {
       return singletonApp.filter(name);
     }
-  };
+  });
   const util = {
     warn: NOOP,
     extend,
@@ -6852,7 +7002,7 @@ function validatePropName(key) {
   return false;
 }
 
-const isInternalKey = (key) => key[0] === "_" || key === "$stable";
+const isInternalKey = (key) => key === "_" || key === "_ctx" || key === "$stable";
 const normalizeSlotValue = (value) => isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
 const normalizeSlot = (key, rawSlot, ctx) => {
   if (rawSlot._n) {
@@ -6892,8 +7042,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) def(slots, "__", cacheIndexes, true);
     const type = children._;
     if (type) {
       assignSlots(slots, children, optimized);
@@ -7133,15 +7281,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) => {
@@ -7188,16 +7346,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,
@@ -7214,18 +7376,9 @@ function baseCreateRenderer(options, createHydrationFns) {
         hostSetScopeId(el, slotScopeIds[i]);
       }
     }
-    let subTree = parentComponent && parentComponent.subTree;
-    if (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) => {
@@ -7458,12 +7611,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,
@@ -7513,6 +7675,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(
@@ -8011,7 +8174,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,
@@ -8091,12 +8258,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;
@@ -8108,6 +8275,12 @@ function baseCreateRenderer(options, createHydrationFns) {
           }
         };
         const performLeave = () => {
+          if (el._isLeaving) {
+            el[leaveCbKey](
+              true
+              /* cancelled */
+            );
+          }
           leave(el, () => {
             remove2();
             afterLeave && afterLeave();
@@ -8147,7 +8320,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;
@@ -8227,22 +8407,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) => {
@@ -8255,27 +8428,12 @@ function baseCreateRenderer(options, createHydrationFns) {
     hostRemove(end);
   };
   const unmountComponent = (instance, parentSuspense, doRemove) => {
-    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) {
       invokeArrayFns(bum);
     }
-    if (parent && isArray(slotCacheKeys)) {
-      slotCacheKeys.forEach((v) => {
-        parent.renderCache[v] = void 0;
-      });
-    }
     if (isCompatEnabled$1("INSTANCE_EVENT_HOOKS", instance)) {
       instance.emit("hook:beforeDestroy");
     }
@@ -8299,12 +8457,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();
-      }
-    }
   };
   const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {
     for (let i = start; i < children.length; i++) {
@@ -8314,7 +8466,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);
     }
@@ -8385,6 +8537,7 @@ function baseCreateRenderer(options, createHydrationFns) {
   return {
     render,
     hydrate,
+    hydrateNode,
     internals,
     createApp: createAppAPI(
       mountApp,
@@ -8426,7 +8579,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) {
@@ -8436,7 +8590,7 @@ function traverseStaticChildren(n1, n2, shallow = false) {
   }
 }
 function locateNonHydratedAsyncRoot(instance) {
-  const subComponent = instance.vapor ? null : instance.subTree.component;
+  const subComponent = instance.subTree && instance.subTree.component;
   if (subComponent) {
     if (subComponent.asyncDep && !subComponent.asyncResolved) {
       return subComponent;
@@ -8451,11 +8605,62 @@ 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;
   return res;
 }
+function getInheritedScopeIds(vnode, parentComponent) {
+  const inheritedScopeIds = [];
+  let currentParent = parentComponent;
+  let currentVNode = vnode;
+  while (currentParent) {
+    let subTree = currentParent.subTree;
+    if (!subTree) break;
+    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 = () => {
@@ -8663,7 +8868,7 @@ function useModel(props, name, options = EMPTY_OBJ) {
   return res;
 }
 const getModelModifiers = (props, modelName, getter) => {
-  return modelName === "modelValue" || modelName === "model-value" ? getter(props, "modelModifiers") : getter(props, `${modelName}Modifiers`) || getter(props, `${camelize(modelName)}Modifiers`) || getter(props, `${hyphenate(modelName)}Modifiers`);
+  return getter(props, getModifierPropName(modelName)) || getter(props, `${camelize(modelName)}Modifiers`) || getter(props, `${hyphenate(modelName)}Modifiers`);
 };
 
 function emit(instance, event, ...rawArgs) {
@@ -8730,8 +8935,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;
@@ -9117,7 +9323,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,
@@ -9188,7 +9394,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,
@@ -9219,7 +9425,7 @@ function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, sl
       }
     }
   } else {
-    if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
+    if (activeBranch && isSameVNodeType(activeBranch, newBranch)) {
       patch(
         activeBranch,
         newBranch,
@@ -9310,7 +9516,8 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
         pendingId,
         effects,
         parentComponent: parentComponent2,
-        container: container2
+        container: container2,
+        isInFallback
       } = suspense;
       let delayEnter = false;
       if (suspense.isHydrating) {
@@ -9328,6 +9535,9 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
                 parentComponent2
               );
               queuePostFlushCb(effects);
+              if (isInFallback && vnode2.ssFallback) {
+                vnode2.ssFallback.el = null;
+              }
             }
           };
         }
@@ -9336,6 +9546,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(
@@ -9457,6 +9670,7 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
           optimized2
         );
         if (placeholder) {
+          vnode2.placeholder = null;
           remove(placeholder);
         }
         updateHOCHostEl(instance, vnode2.el);
@@ -9698,15 +9912,11 @@ function isSameVNodeType(n1, n2) {
 function transformVNodeArgs(transformer) {
 }
 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 ? isString(ref) || isRef(ref) || isFunction(ref) ? { i: currentRenderingInstance, r: ref, k: ref_key, f: !!ref_for } : ref : null;
+  return ref != null ? isString(ref) || isRef(ref) || 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 = {
@@ -9864,6 +10074,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,
@@ -10019,6 +10230,17 @@ const setCurrentInstance = (instance, scope = instance !== null ? instance.scope
     simpleSetCurrentInstance(instance);
   }
 };
+const internalOptions = ["ce", "type"];
+const useInstanceOption = (key, silent = false) => {
+  const instance = getCurrentGenericInstance();
+  if (!instance) {
+    return { hasInstance: false, value: void 0 };
+  }
+  if (!internalOptions.includes(key)) {
+    return { hasInstance: true, value: void 0 };
+  }
+  return { hasInstance: true, value: instance[key] };
+};
 
 const emptyAppContext = createAppContext();
 let uid = 0;
@@ -10293,23 +10515,28 @@ const computed = (getterOrOptions, debugOptions) => {
 };
 
 function h(type, propsOrChildren, children) {
-  const l = arguments.length;
-  if (l === 2) {
-    if (isObject(propsOrChildren) && !isArray(propsOrChildren)) {
-      if (isVNode(propsOrChildren)) {
-        return createVNode(type, null, [propsOrChildren]);
+  try {
+    setBlockTracking(-1);
+    const l = arguments.length;
+    if (l === 2) {
+      if (isObject(propsOrChildren) && !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);
   }
 }
 
@@ -10345,7 +10572,7 @@ function isMemoSame(cached, memo) {
   return true;
 }
 
-const version = "3.6.0-alpha.2";
+const version = "3.6.0-alpha.4";
 const warn$1 = NOOP;
 const ErrorTypeStrings = ErrorTypeStrings$1 ;
 const devtools = void 0;
@@ -10614,11 +10841,11 @@ function resolveTransitionProps(rawProps) {
         addTransitionClass(el, legacyLeaveFromClass);
       }
       if (!el._enterCancelled) {
-        forceReflow();
+        forceReflow(el);
         addTransitionClass(el, leaveActiveClass);
       } else {
         addTransitionClass(el, leaveActiveClass);
-        forceReflow();
+        forceReflow(el);
       }
       nextFrame(() => {
         if (!el._isLeaving) {
@@ -10744,7 +10971,7 @@ function getTransitionInfo(el, expectedType) {
     type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION$1 : ANIMATION : null;
     propCount = type ? type === TRANSITION$1 ? transitionDurations.length : animationDurations.length : 0;
   }
-  const hasTransform = type === TRANSITION$1 && /\b(transform|all)(,|$)/.test(
+  const hasTransform = type === TRANSITION$1 && /\b(?:transform|all)(?:,|$)/.test(
     getStyleProperties(`${TRANSITION$1}Property`).toString()
   );
   return {
@@ -10764,8 +10991,9 @@ function toMs(s) {
   if (s === "auto") return 0;
   return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
 }
-function forceReflow() {
-  return document.body.offsetHeight;
+function forceReflow(el) {
+  const targetDocument = el ? el.ownerDocument : document;
+  return targetDocument.body.offsetHeight;
 }
 
 function patchClass(el, value, isSVG) {
@@ -10785,6 +11013,8 @@ function patchClass(el, value, isSVG) {
 const vShowOriginalDisplay = Symbol("_vod");
 const vShowHidden = Symbol("_vsh");
 const vShow = {
+  // used for prop mismatch check during hydration
+  name: "show",
   beforeMount(el, { value }, { transition }) {
     el[vShowOriginalDisplay] = el.style.display === "none" ? "" : el.style.display;
     if (transition && value) {
@@ -10835,7 +11065,7 @@ function useCssVars(getter) {
   return;
 }
 
-const displayRE = /(^|;)\s*display\s*:/;
+const displayRE = /(?:^|;)\s*display\s*:/;
 function patchStyle(el, prev, next) {
   const style = el.style;
   const isCssString = isString(next);
@@ -11155,11 +11385,10 @@ function shouldSetAsProp(el, key, value, isSVG) {
 }
 
 const REMOVAL = {};
-/*! #__NO_SIDE_EFFECTS__ */
 // @__NO_SIDE_EFFECTS__
 function defineCustomElement(options, extraOptions, _createApp) {
-  const Comp = defineComponent(options, extraOptions);
-  if (isPlainObject(Comp)) extend(Comp, extraOptions);
+  let Comp = defineComponent(options, extraOptions);
+  if (isPlainObject(Comp)) Comp = extend({}, Comp, extraOptions);
   class VueCustomElement extends VueElement {
     constructor(initialProps) {
       super(Comp, initialProps, _createApp);
@@ -11168,18 +11397,14 @@ function defineCustomElement(options, extraOptions, _createApp) {
   VueCustomElement.def = Comp;
   return VueCustomElement;
 }
-/*! #__NO_SIDE_EFFECTS__ */
-const defineSSRCustomElement = /* @__NO_SIDE_EFFECTS__ */ (options, extraOptions) => {
+const defineSSRCustomElement = (/* @__NO_SIDE_EFFECTS__ */ (options, extraOptions) => {
   return /* @__PURE__ */ defineCustomElement(options, extraOptions, createSSRApp);
-};
+});
 const BaseClass = typeof HTMLElement !== "undefined" ? HTMLElement : class {
 };
-class VueElement extends BaseClass {
-  constructor(_def, _props = {}, _createApp = createApp) {
+class VueElementBase extends BaseClass {
+  constructor(def, props = {}, createAppFn) {
     super();
-    this._def = _def;
-    this._props = _props;
-    this._createApp = _createApp;
     this._isVueCE = true;
     /**
      * @internal
@@ -11189,20 +11414,26 @@ class VueElement extends BaseClass {
      * @internal
      */
     this._app = null;
-    /**
-     * @internal
-     */
-    this._nonce = this._def.nonce;
     this._connected = false;
     this._resolved = false;
     this._numberProps = null;
     this._styleChildren = /* @__PURE__ */ new WeakSet();
+    this._patching = false;
+    this._dirty = false;
     this._ob = null;
-    if (this.shadowRoot && _createApp !== createApp) {
+    this._def = def;
+    this._props = props;
+    this._createApp = createAppFn;
+    this._nonce = def.nonce;
+    if (this._needsHydration()) {
       this._root = this.shadowRoot;
     } else {
-      if (_def.shadowRoot !== false) {
-        this.attachShadow({ mode: "open" });
+      if (def.shadowRoot !== false) {
+        this.attachShadow(
+          extend({}, def.shadowRootOptions, {
+            mode: "open"
+          })
+        );
         this._root = this.shadowRoot;
       } else {
         this._root = this;
@@ -11217,14 +11448,14 @@ class VueElement extends BaseClass {
     this._connected = true;
     let parent = this;
     while (parent = parent && (parent.parentNode || parent.host)) {
-      if (parent instanceof VueElement) {
+      if (parent instanceof VueElementBase) {
         this._parent = parent;
         break;
       }
     }
     if (!this._instance) {
       if (this._resolved) {
-        this._mount(this._def);
+        this._mountComponent(this._def);
       } else {
         if (parent && parent._pendingResolve) {
           this._pendingResolve = parent._pendingResolve.then(() => {
@@ -11237,8 +11468,24 @@ class VueElement extends BaseClass {
       }
     }
   }
+  disconnectedCallback() {
+    this._connected = false;
+    nextTick(() => {
+      if (!this._connected) {
+        if (this._ob) {
+          this._ob.disconnect();
+          this._ob = null;
+        }
+        this._unmount();
+        if (this._teleportTargets) {
+          this._teleportTargets.clear();
+          this._teleportTargets = void 0;
+        }
+      }
+    });
+  }
   _setParent(parent = this._parent) {
-    if (parent) {
+    if (parent && this._instance) {
       this._instance.parent = parent._instance;
       this._inheritParentContext(parent);
     }
@@ -11251,19 +11498,10 @@ class VueElement extends BaseClass {
       );
     }
   }
-  disconnectedCallback() {
-    this._connected = false;
-    nextTick(() => {
-      if (!this._connected) {
-        if (this._ob) {
-          this._ob.disconnect();
-          this._ob = null;
-        }
-        this._app && this._app.unmount();
-        if (this._instance) this._instance.ce = void 0;
-        this._app = this._instance = null;
-      }
-    });
+  _processMutations(mutations) {
+    for (const m of mutations) {
+      this._setAttr(m.attributeName);
+    }
   }
   /**
    * resolve inner component definition (handle possible async component)
@@ -11275,13 +11513,9 @@ class VueElement extends BaseClass {
     for (let i = 0; i < this.attributes.length; i++) {
       this._setAttr(this.attributes[i].name);
     }
-    this._ob = new MutationObserver((mutations) => {
-      for (const m of mutations) {
-        this._setAttr(m.attributeName);
-      }
-    });
+    this._ob = new MutationObserver(this._processMutations.bind(this));
     this._ob.observe(this, { attributes: true });
-    const resolve = (def, isAsync = false) => {
+    const resolve = (def) => {
       this._resolved = true;
       this._pendingResolve = void 0;
       const { props, styles } = def;
@@ -11302,26 +11536,25 @@ class VueElement extends BaseClass {
       if (this.shadowRoot) {
         this._applyStyles(styles);
       }
-      this._mount(def);
+      this._mountComponent(def);
     };
     const asyncDef = this._def.__asyncLoader;
     if (asyncDef) {
+      const { configureApp } = this._def;
       this._pendingResolve = asyncDef().then((def) => {
-        def.configureApp = this._def.configureApp;
-        resolve(this._def = def, true);
+        def.configureApp = configureApp;
+        this._def = def;
+        resolve(def);
       });
     } else {
       resolve(this._def);
     }
   }
-  _mount(def) {
-    this._app = this._createApp(def);
-    this._inheritParentContext();
-    if (def.configureApp) {
-      def.configureApp(this._app);
-    }
-    this._app._ceVNode = this._createVNode();
-    this._app.mount(this._root);
+  _mountComponent(def) {
+    this._mount(def);
+    this._processExposed();
+  }
+  _processExposed() {
     const exposed = this._instance && this._instance.exposed;
     if (!exposed) return;
     for (const key in exposed) {
@@ -11333,6 +11566,25 @@ class VueElement extends BaseClass {
       }
     }
   }
+  _processInstance() {
+    this._instance.ce = this;
+    this._instance.isCE = true;
+    const dispatch = (event, args) => {
+      this.dispatchEvent(
+        new CustomEvent(
+          event,
+          isPlainObject(args[0]) ? extend({ detail: args }, args[0]) : { detail: args }
+        )
+      );
+    };
+    this._instance.emit = (event, ...args) => {
+      dispatch(event, args);
+      if (hyphenate(event) !== event) {
+        dispatch(hyphenate(event), args);
+      }
+    };
+    this._setParent();
+  }
   _resolveProps(def) {
     const { props } = def;
     const declaredPropKeys = isArray(props) ? props : Object.keys(props || {});
@@ -11347,7 +11599,7 @@ class VueElement extends BaseClass {
           return this._getProp(key);
         },
         set(val) {
-          this._setProp(key, val, true, true);
+          this._setProp(key, val, true, !this._patching);
         }
       });
     }
@@ -11373,11 +11625,12 @@ class VueElement extends BaseClass {
    */
   _setProp(key, val, shouldReflect = true, shouldUpdate = false) {
     if (val !== this._props[key]) {
+      this._dirty = true;
       if (val === REMOVAL) {
         delete this._props[key];
       } else {
         this._props[key] = val;
-        if (key === "key" && this._app) {
+        if (key === "key" && this._app && this._app._ceVNode) {
           this._app._ceVNode.key = val;
         }
       }
@@ -11386,7 +11639,10 @@ class VueElement extends BaseClass {
       }
       if (shouldReflect) {
         const ob = this._ob;
-        ob && ob.disconnect();
+        if (ob) {
+          this._processMutations(ob.takeRecords());
+          ob.disconnect();
+        }
         if (val === true) {
           this.setAttribute(hyphenate(key), "");
         } else if (typeof val === "string" || typeof val === "number") {
@@ -11398,41 +11654,6 @@ class VueElement extends BaseClass {
       }
     }
   }
-  _update() {
-    const vnode = this._createVNode();
-    if (this._app) vnode.appContext = this._app._context;
-    render(vnode, this._root);
-  }
-  _createVNode() {
-    const baseProps = {};
-    if (!this.shadowRoot) {
-      baseProps.onVnodeMounted = baseProps.onVnodeUpdated = this._renderSlots.bind(this);
-    }
-    const vnode = createVNode(this._def, extend(baseProps, this._props));
-    if (!this._instance) {
-      vnode.ce = (instance) => {
-        this._instance = instance;
-        instance.ce = this;
-        instance.isCE = true;
-        const dispatch = (event, args) => {
-          this.dispatchEvent(
-            new CustomEvent(
-              event,
-              isPlainObject(args[0]) ? extend({ detail: args }, args[0]) : { detail: args }
-            )
-          );
-        };
-        instance.emit = (event, ...args) => {
-          dispatch(event, args);
-          if (hyphenate(event) !== event) {
-            dispatch(hyphenate(event), args);
-          }
-        };
-        this._setParent();
-      };
-    }
-    return vnode;
-  }
   _applyStyles(styles, owner) {
     if (!styles) return;
     if (owner) {
@@ -11465,13 +11686,15 @@ class VueElement extends BaseClass {
    * Only called when shadowRoot is false
    */
   _renderSlots() {
-    const outlets = (this._teleportTarget || this).querySelectorAll("slot");
+    const outlets = this._getSlots();
     const scopeId = this._instance.type.__scopeId;
+    const slotReplacements = /* @__PURE__ */ new Map();
     for (let i = 0; i < outlets.length; i++) {
       const o = outlets[i];
       const slotName = o.getAttribute("name") || "default";
       const content = this._slots[slotName];
       const parent = o.parentNode;
+      const replacementNodes = [];
       if (content) {
         for (const n of content) {
           if (scopeId && n.nodeType === 1) {
@@ -11484,28 +11707,122 @@ class VueElement extends BaseClass {
             }
           }
           parent.insertBefore(n, o);
+          replacementNodes.push(n);
         }
       } else {
-        while (o.firstChild) parent.insertBefore(o.firstChild, o);
+        while (o.firstChild) {
+          const child = o.firstChild;
+          parent.insertBefore(child, o);
+          replacementNodes.push(child);
+        }
       }
       parent.removeChild(o);
+      slotReplacements.set(o, replacementNodes);
+    }
+    this._updateSlotNodes(slotReplacements);
+  }
+  /**
+   * @internal
+   */
+  _getSlots() {
+    const roots = [this];
+    if (this._teleportTargets) {
+      roots.push(...this._teleportTargets);
+    }
+    const slots = /* @__PURE__ */ new Set();
+    for (const root of roots) {
+      const found = root.querySelectorAll("slot");
+      for (let i = 0; i < found.length; i++) {
+        slots.add(found[i]);
+      }
+    }
+    return Array.from(slots);
+  }
+  /**
+   * @internal
+   */
+  _injectChildStyle(comp) {
+    this._applyStyles(comp.styles, comp);
+  }
+  /**
+   * @internal
+   */
+  _beginPatch() {
+    this._patching = true;
+    this._dirty = false;
+  }
+  /**
+   * @internal
+   */
+  _endPatch() {
+    this._patching = false;
+    if (this._dirty && this._instance) {
+      this._update();
+    }
+  }
+  /**
+   * @internal
+   */
+  _removeChildStyle(comp) {
+  }
+}
+class VueElement extends VueElementBase {
+  constructor(def, props = {}, createAppFn = createApp) {
+    super(def, props, createAppFn);
+  }
+  _needsHydration() {
+    if (this.shadowRoot && this._createApp !== createApp) {
+      return true;
+    }
+    return false;
+  }
+  _mount(def) {
+    this._app = this._createApp(def);
+    this._inheritParentContext();
+    if (def.configureApp) {
+      def.configureApp(this._app);
+    }
+    this._app._ceVNode = this._createVNode();
+    this._app.mount(this._root);
+  }
+  _update() {
+    if (!this._app) return;
+    const vnode = this._createVNode();
+    vnode.appContext = this._app._context;
+    render(vnode, this._root);
+  }
+  _unmount() {
+    if (this._app) {
+      this._app.unmount();
+    }
+    if (this._instance && this._instance.ce) {
+      this._instance.ce = void 0;
     }
+    this._app = this._instance = null;
   }
   /**
-   * @internal
+   * Only called when shadowRoot is false
    */
-  _injectChildStyle(comp) {
-    this._applyStyles(comp.styles, comp);
+  _updateSlotNodes(replacements) {
   }
-  /**
-   * @internal
-   */
-  _removeChildStyle(comp) {
+  _createVNode() {
+    const baseProps = {};
+    if (!this.shadowRoot) {
+      baseProps.onVnodeMounted = baseProps.onVnodeUpdated = this._renderSlots.bind(this);
+    }
+    const vnode = createVNode(this._def, extend(baseProps, this._props));
+    if (!this._instance) {
+      vnode.ce = (instance) => {
+        this._instance = instance;
+        this._processInstance();
+      };
+    }
+    return vnode;
   }
 }
 function useHost(caller) {
-  const instance = getCurrentInstance();
-  const el = instance && instance.ce;
+  const { hasInstance, value } = useInstanceOption("ce", true);
+  const el = value;
   if (el) {
     return el;
   }
@@ -11518,11 +11835,11 @@ function useShadowRoot() {
 
 function useCssModule(name = "$style") {
   {
-    const instance = getCurrentInstance();
-    if (!instance) {
+    const { hasInstance, value: type } = useInstanceOption("type", true);
+    if (!hasInstance) {
       return EMPTY_OBJ;
     }
-    const modules = instance.type.__cssModules;
+    const modules = type.__cssModules;
     if (!modules) {
       return EMPTY_OBJ;
     }
@@ -11569,26 +11886,13 @@ const TransitionGroupImpl = /* @__PURE__ */ decorate({
         prevChildren = [];
         return;
       }
-      prevChildren.forEach(callPendingCbs);
+      prevChildren.forEach((vnode) => callPendingCbs(vnode.el));
       prevChildren.forEach(recordPosition);
       const movedChildren = prevChildren.filter(applyTranslation);
-      forceReflow();
+      forceReflow(instance.vnode.el);
       movedChildren.forEach((c) => {
         const el = c.el;
-        const style = el.style;
-        addTransitionClass(el, moveClass);
-        style.transform = style.webkitTransform = style.transitionDuration = "";
-        const cb = el[moveCbKey] = (e) => {
-          if (e && e.target !== el) {
-            return;
-          }
-          if (!e || /transform$/.test(e.propertyName)) {
-            el.removeEventListener("transitionend", cb);
-            el[moveCbKey] = null;
-            removeTransitionClass(el, moveClass);
-          }
-        };
-        el.addEventListener("transitionend", cb);
+        handleMovedChildren(el, moveClass);
       });
       prevChildren = [];
     });
@@ -11617,10 +11921,10 @@ const TransitionGroupImpl = /* @__PURE__ */ decorate({
                 instance
               )
             );
-            positionMap.set(
-              child,
-              child.el.getBoundingClientRect()
-            );
+            positionMap.set(child, {
+              left: child.el.offsetLeft,
+              top: child.el.offsetTop
+            });
           }
         }
       }
@@ -11639,8 +11943,7 @@ const TransitionGroupImpl = /* @__PURE__ */ decorate({
   }
 });
 const TransitionGroup = TransitionGroupImpl;
-function callPendingCbs(c) {
-  const el = c.el;
+function callPendingCbs(el) {
   if (el[moveCbKey]) {
     el[moveCbKey]();
   }
@@ -11649,19 +11952,30 @@ function callPendingCbs(c) {
   }
 }
 function recordPosition(c) {
-  newPositionMap.set(c, c.el.getBoundingClientRect());
+  newPositionMap.set(c, {
+    left: c.el.offsetLeft,
+    top: c.el.offsetTop
+  });
 }
 function applyTranslation(c) {
-  const oldPos = positionMap.get(c);
-  const newPos = newPositionMap.get(c);
+  if (baseApplyTranslation(
+    positionMap.get(c),
+    newPositionMap.get(c),
+    c.el
+  )) {
+    return c;
+  }
+}
+function baseApplyTranslation(oldPos, newPos, el) {
   const dx = oldPos.left - newPos.left;
   const dy = oldPos.top - newPos.top;
   if (dx || dy) {
-    const s = c.el.style;
+    const s = el.style;
     s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;
     s.transitionDuration = "0s";
-    return c;
+    return true;
   }
+  return false;
 }
 function hasCSSTransform(el, root, moveClass) {
   const clone = el.cloneNode();
@@ -11679,6 +11993,22 @@ function hasCSSTransform(el, root, moveClass) {
   container.removeChild(clone);
   return hasTransform;
 }
+const handleMovedChildren = (el, moveClass) => {
+  const style = el.style;
+  addTransitionClass(el, moveClass);
+  style.transform = style.webkitTransform = style.transitionDuration = "";
+  const cb = el[moveCbKey] = (e) => {
+    if (e && e.target !== el) {
+      return;
+    }
+    if (!e || e.propertyName.endsWith("transform")) {
+      el.removeEventListener("transitionend", cb);
+      el[moveCbKey] = null;
+      removeTransitionClass(el, moveClass);
+    }
+  };
+  el.addEventListener("transitionend", cb);
+};
 
 const getModelAssigner = (vnode) => {
   const fn = vnode.props["onUpdate:modelValue"] || vnode.props["onModelCompat:input"];
@@ -11714,21 +12044,21 @@ const vModelText = {
     vModelTextUpdate(el, oldValue, value, trim, number, lazy);
   }
 };
+function castValue(value, trim, number) {
+  if (trim) value = value.trim();
+  if (number) value = looseToNumber(value);
+  return value;
+}
 const vModelTextInit = (el, trim, number, lazy, set) => {
   addEventListener(el, lazy ? "change" : "input", (e) => {
     if (e.target.composing) return;
-    let domValue = el.value;
-    if (trim) {
-      domValue = domValue.trim();
-    }
-    if (number || el.type === "number") {
-      domValue = looseToNumber(domValue);
-    }
-    (0, el[assignKey])(domValue);
+    (0, el[assignKey])(
+      castValue(el.value, trim, number || el.type === "number")
+    );
   });
-  if (trim) {
+  if (trim || number) {
     addEventListener(el, "change", () => {
-      el.value = el.value.trim();
+      el.value = castValue(el.value, trim, number || el.type === "number");
     });
   }
   if (!lazy) {
@@ -12008,13 +12338,13 @@ const modifierGuards = {
 const withModifiers = (fn, modifiers) => {
   const cache = fn._withMods || (fn._withMods = {});
   const cacheKey = modifiers.join(".");
-  return cache[cacheKey] || (cache[cacheKey] = (event, ...args) => {
+  return cache[cacheKey] || (cache[cacheKey] = ((event, ...args) => {
     for (let i = 0; i < modifiers.length; i++) {
       const guard = modifierGuards[modifiers[i]];
       if (guard && guard(event, modifiers)) return;
     }
     return fn(event, ...args);
-  });
+  }));
 };
 const keyNames = {
   esc: "escape",
@@ -12038,7 +12368,7 @@ const withKeys = (fn, modifiers) => {
   }
   const cache = fn._withKeys || (fn._withKeys = {});
   const cacheKey = modifiers.join(".");
-  return cache[cacheKey] || (cache[cacheKey] = (event) => {
+  return cache[cacheKey] || (cache[cacheKey] = ((event) => {
     if (!("key" in event)) {
       return;
     }
@@ -12068,7 +12398,7 @@ const withKeys = (fn, modifiers) => {
         }
       }
     }
-  });
+  }));
 };
 
 const rendererOptions = /* @__PURE__ */ extend({ patchProp }, nodeOps);
@@ -12082,13 +12412,13 @@ function ensureHydrationRenderer() {
   enabledHydration = true;
   return renderer;
 }
-const render = (...args) => {
+const render = ((...args) => {
   ensureRenderer().render(...args);
-};
-const hydrate = (...args) => {
+});
+const hydrate = ((...args) => {
   ensureHydrationRenderer().hydrate(...args);
-};
-const createApp = (...args) => {
+});
+const createApp = ((...args) => {
   const app = ensureRenderer().createApp(...args);
   const { mount } = app;
   app.mount = (containerOrSelector) => {
@@ -12109,8 +12439,8 @@ const createApp = (...args) => {
     return proxy;
   };
   return app;
-};
-const createSSRApp = (...args) => {
+});
+const createSSRApp = ((...args) => {
   const app = ensureHydrationRenderer().createApp(...args);
   const { mount } = app;
   app.mount = (containerOrSelector) => {
@@ -12120,7 +12450,7 @@ const createSSRApp = (...args) => {
     }
   };
   return app;
-};
+});
 function resolveRootNamespace(container) {
   if (container instanceof SVGElement) {
     return "svg";
@@ -12166,6 +12496,7 @@ var runtimeDom = /*#__PURE__*/Object.freeze({
   TransitionGroup: TransitionGroup,
   TriggerOpTypes: TriggerOpTypes,
   VueElement: VueElement,
+  VueElementBase: VueElementBase,
   assertNumber: assertNumber,
   callWithAsyncErrorHandling: callWithAsyncErrorHandling,
   callWithErrorHandling: callWithErrorHandling,
@@ -12230,6 +12561,7 @@ var runtimeDom = /*#__PURE__*/Object.freeze({
   mergeModels: mergeModels,
   mergeProps: mergeProps,
   nextTick: nextTick,
+  nodeOps: nodeOps,
   normalizeClass: normalizeClass,
   normalizeProps: normalizeProps,
   normalizeStyle: normalizeStyle,
@@ -12248,6 +12580,7 @@ var runtimeDom = /*#__PURE__*/Object.freeze({
   onUpdated: onUpdated,
   onWatcherCleanup: onWatcherCleanup,
   openBlock: openBlock,
+  patchProp: patchProp,
   popScopeId: popScopeId,
   provide: provide,
   proxyRefs: proxyRefs,
@@ -12289,6 +12622,7 @@ var runtimeDom = /*#__PURE__*/Object.freeze({
   useCssVars: useCssVars,
   useHost: useHost,
   useId: useId,
+  useInstanceOption: useInstanceOption,
   useModel: useModel,
   useSSRContext: useSSRContext,
   useShadowRoot: useShadowRoot,
@@ -13596,16 +13930,34 @@ function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [
             (id) => markScopeIdentifier(node, id, knownIds)
           );
         }
+      } else if (node.type === "SwitchStatement") {
+        if (node.scopeIds) {
+          node.scopeIds.forEach((id) => markKnownIds(id, knownIds));
+        } else {
+          walkSwitchStatement(
+            node,
+            false,
+            (id) => markScopeIdentifier(node, id, knownIds)
+          );
+        }
       } else if (node.type === "CatchClause" && node.param) {
-        for (const id of extractIdentifiers(node.param)) {
-          markScopeIdentifier(node, id, knownIds);
+        if (node.scopeIds) {
+          node.scopeIds.forEach((id) => markKnownIds(id, knownIds));
+        } else {
+          for (const id of extractIdentifiers(node.param)) {
+            markScopeIdentifier(node, id, knownIds);
+          }
         }
       } else if (isForStatement(node)) {
-        walkForStatement(
-          node,
-          false,
-          (id) => markScopeIdentifier(node, id, knownIds)
-        );
+        if (node.scopeIds) {
+          node.scopeIds.forEach((id) => markKnownIds(id, knownIds));
+        } else {
+          walkForStatement(
+            node,
+            false,
+            (id) => markScopeIdentifier(node, id, knownIds)
+          );
+        }
       }
     },
     leave(node, parent) {
@@ -13628,14 +13980,15 @@ function isReferencedIdentifier(id, parent, parentStack) {
   if (id.name === "arguments") {
     return false;
   }
-  if (isReferenced(id, parent)) {
+  if (isReferenced(id, parent, parentStack[parentStack.length - 2])) {
     return true;
   }
   switch (parent.type) {
     case "AssignmentExpression":
     case "AssignmentPattern":
       return true;
-    case "ObjectPattern":
+    case "ObjectProperty":
+      return parent.key !== id && isInDestructureAssignment(parent, parentStack);
     case "ArrayPattern":
       return isInDestructureAssignment(parent, parentStack);
   }
@@ -13675,7 +14028,8 @@ function walkFunctionParams(node, onIdent) {
   }
 }
 function walkBlockDeclarations(block, onIdent) {
-  for (const stmt of block.body) {
+  const body = block.type === "SwitchCase" ? block.consequent : block.body;
+  for (const stmt of body) {
     if (stmt.type === "VariableDeclaration") {
       if (stmt.declare) continue;
       for (const decl of stmt.declarations) {
@@ -13688,6 +14042,8 @@ function walkBlockDeclarations(block, onIdent) {
       onIdent(stmt.id);
     } else if (isForStatement(stmt)) {
       walkForStatement(stmt, true, onIdent);
+    } else if (stmt.type === "SwitchStatement") {
+      walkSwitchStatement(stmt, true, onIdent);
     }
   }
 }
@@ -13704,6 +14060,20 @@ function walkForStatement(stmt, isVar, onIdent) {
     }
   }
 }
+function walkSwitchStatement(stmt, isVar, onIdent) {
+  for (const cs of stmt.cases) {
+    for (const stmt2 of cs.consequent) {
+      if (stmt2.type === "VariableDeclaration" && (stmt2.kind === "var" ? isVar : !isVar)) {
+        for (const decl of stmt2.declarations) {
+          for (const id of extractIdentifiers(decl.id)) {
+            onIdent(id);
+          }
+        }
+      }
+    }
+    walkBlockDeclarations(cs, onIdent);
+  }
+}
 function extractIdentifiers(param, nodes = []) {
   switch (param.type) {
     case "Identifier":
@@ -13804,7 +14174,7 @@ function isReferenced(node, parent, grandparent) {
       if (parent.key === node) {
         return !!parent.computed;
       }
-      return true;
+      return !grandparent || grandparent.type !== "ObjectPattern";
     // no: class { NODE = value; }
     // yes: class { [NODE] = value; }
     // yes: class { key = NODE; }
@@ -13854,6 +14224,9 @@ function isReferenced(node, parent, grandparent) {
     // yes: export { NODE as foo };
     // no: export { NODE as foo } from "foo";
     case "ExportSpecifier":
+      if (grandparent == null ? void 0 : grandparent.source) {
+        return false;
+      }
       return parent.local === node;
     // no: import NODE from "foo";
     // no: import * as NODE from "foo";
@@ -13934,8 +14307,9 @@ function isCoreComponent(tag) {
       return BASE_TRANSITION;
   }
 }
-const nonIdentifierRE = /^\d|[^\$\w\xA0-\uFFFF]/;
+const nonIdentifierRE = /^$|^\d|[^\$\w\xA0-\uFFFF]/;
 const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
+const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
 const getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source;
 const isMemberExpressionNode = (exp, context) => {
   try {
@@ -14027,6 +14401,9 @@ function hasDynamicKeyVBind(node) {
 function isText$1(node) {
   return node.type === 5 || node.type === 2;
 }
+function isVPre(p) {
+  return p.type === 7 && p.name === "pre";
+}
 function isVSlot(p) {
   return p.type === 7 && p.name === "slot";
 }
@@ -14325,7 +14702,7 @@ const tokenizer = new Tokenizer(stack, {
   ondirarg(start, end) {
     if (start === end) return;
     const arg = getSlice(start, end);
-    if (inVPre) {
+    if (inVPre && !isVPre(currentProp)) {
       currentProp.name += arg;
       setLocEnd(currentProp.nameLoc, end);
     } else {
@@ -14340,7 +14717,7 @@ const tokenizer = new Tokenizer(stack, {
   },
   ondirmodifier(start, end) {
     const mod = getSlice(start, end);
-    if (inVPre) {
+    if (inVPre && !isVPre(currentProp)) {
       currentProp.name += "." + mod;
       setLocEnd(currentProp.nameLoc, end);
     } else if (currentProp.name === "slot") {
@@ -14950,6 +15327,11 @@ function walk(node, parent, context, doNotHoistNode = false, inFor = false) {
     } else if (child.type === 12) {
       const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
       if (constantType >= 2) {
+        if (child.codegenNode.type === 14 && child.codegenNode.arguments.length > 0) {
+          child.codegenNode.arguments.push(
+            -1 + (``)
+          );
+        }
         toCache.push(child);
         continue;
       }
@@ -14978,7 +15360,6 @@ function walk(node, parent, context, doNotHoistNode = false, inFor = false) {
     }
   }
   let cachedAsArray = false;
-  const slotCacheKeys = [];
   if (toCache.length === children.length && node.type === 1) {
     if (node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && isArray(node.codegenNode.children)) {
       node.codegenNode.children = getCacheExpression(
@@ -14988,7 +15369,6 @@ function walk(node, parent, context, doNotHoistNode = false, inFor = false) {
     } else if (node.tagType === 1 && node.codegenNode && node.codegenNode.type === 13 && node.codegenNode.children && !isArray(node.codegenNode.children) && node.codegenNode.children.type === 15) {
       const slot = getSlotNode(node.codegenNode, "default");
       if (slot) {
-        slotCacheKeys.push(context.cached.length);
         slot.returns = getCacheExpression(
           createArrayExpression(slot.returns)
         );
@@ -14998,7 +15378,6 @@ function walk(node, parent, context, doNotHoistNode = false, inFor = false) {
       const slotName = findDir(node, "slot", true);
       const slot = slotName && slotName.arg && getSlotNode(parent.codegenNode, slotName.arg);
       if (slot) {
-        slotCacheKeys.push(context.cached.length);
         slot.returns = getCacheExpression(
           createArrayExpression(slot.returns)
         );
@@ -15008,23 +15387,12 @@ function walk(node, parent, context, doNotHoistNode = false, inFor = false) {
   }
   if (!cachedAsArray) {
     for (const child of toCache) {
-      slotCacheKeys.push(context.cached.length);
       child.codegenNode = context.cache(child.codegenNode);
     }
   }
-  if (slotCacheKeys.length && node.type === 1 && node.tagType === 1 && node.codegenNode && node.codegenNode.type === 13 && node.codegenNode.children && !isArray(node.codegenNode.children) && node.codegenNode.children.type === 15) {
-    node.codegenNode.children.properties.push(
-      createObjectProperty(
-        `__`,
-        createSimpleExpression(JSON.stringify(slotCacheKeys), false)
-      )
-    );
-  }
   function getCacheExpression(value) {
     const exp = context.cache(value);
-    if (inFor && context.hmr) {
-      exp.needArraySpread = true;
-    }
+    exp.needArraySpread = true;
     return exp;
   }
   function getSlotNode(node2, name) {
@@ -16504,7 +16872,7 @@ function isConst(type) {
 }
 
 const transformIf = createStructuralDirectiveTransform(
-  /^(if|else|else-if)$/,
+  /^(?:if|else|else-if)$/,
   (node, dir, context) => {
     return processIf(node, dir, context, (ifNode, branch, isRoot) => {
       const siblings = context.parent.children;
@@ -16571,7 +16939,7 @@ function processIf(node, dir, context, processCodegen) {
         continue;
       }
       if (sibling && sibling.type === 9) {
-        if (dir.name === "else-if" && sibling.branches[sibling.branches.length - 1].condition === void 0) {
+        if ((dir.name === "else-if" || dir.name === "else") && sibling.branches[sibling.branches.length - 1].condition === void 0) {
           context.onError(
             createCompilerError(30, node.loc)
           );
@@ -16713,90 +17081,6 @@ function getParentCondition(node) {
   }
 }
 
-const transformBind = (dir, _node, context) => {
-  const { modifiers, loc } = dir;
-  const arg = dir.arg;
-  let { exp } = dir;
-  if (exp && exp.type === 4 && !exp.content.trim()) {
-    {
-      context.onError(
-        createCompilerError(34, loc)
-      );
-      return {
-        props: [
-          createObjectProperty(arg, createSimpleExpression("", true, loc))
-        ]
-      };
-    }
-  }
-  if (!exp) {
-    if (arg.type !== 4 || !arg.isStatic) {
-      context.onError(
-        createCompilerError(
-          52,
-          arg.loc
-        )
-      );
-      return {
-        props: [
-          createObjectProperty(arg, createSimpleExpression("", true, loc))
-        ]
-      };
-    }
-    transformBindShorthand(dir, context);
-    exp = dir.exp;
-  }
-  if (arg.type !== 4) {
-    arg.children.unshift(`(`);
-    arg.children.push(`) || ""`);
-  } else if (!arg.isStatic) {
-    arg.content = `${arg.content} || ""`;
-  }
-  if (modifiers.some((mod) => mod.content === "camel")) {
-    if (arg.type === 4) {
-      if (arg.isStatic) {
-        arg.content = camelize(arg.content);
-      } else {
-        arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;
-      }
-    } else {
-      arg.children.unshift(`${context.helperString(CAMELIZE)}(`);
-      arg.children.push(`)`);
-    }
-  }
-  if (!context.inSSR) {
-    if (modifiers.some((mod) => mod.content === "prop")) {
-      injectPrefix(arg, ".");
-    }
-    if (modifiers.some((mod) => mod.content === "attr")) {
-      injectPrefix(arg, "^");
-    }
-  }
-  return {
-    props: [createObjectProperty(arg, exp)]
-  };
-};
-const transformBindShorthand = (dir, context) => {
-  const arg = dir.arg;
-  const propName = camelize(arg.content);
-  dir.exp = createSimpleExpression(propName, false, arg.loc);
-  {
-    dir.exp = processExpression(dir.exp, context);
-  }
-};
-const injectPrefix = (arg, prefix) => {
-  if (arg.type === 4) {
-    if (arg.isStatic) {
-      arg.content = prefix + arg.content;
-    } else {
-      arg.content = `\`${prefix}\${${arg.content}}\``;
-    }
-  } else {
-    arg.children.unshift(`'${prefix}' + (`);
-    arg.children.push(`)`);
-  }
-};
-
 const transformFor = createStructuralDirectiveTransform(
   "for",
   (node, dir, context) => {
@@ -16809,9 +17093,6 @@ const transformFor = createStructuralDirectiveTransform(
       const memo = findDir(node, "memo");
       const keyProp = findProp(node, `key`, false, true);
       const isDirKey = keyProp && keyProp.type === 7;
-      if (isDirKey && !keyProp.exp) {
-        transformBindShorthand(keyProp, context);
-      }
       let keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp);
       if (memo && keyExp && isDirKey) {
         {
@@ -17092,7 +17373,9 @@ function buildSlots(node, context, buildSlotFn = buildClientSlotFn) {
   const dynamicSlots = [];
   let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0;
   if (!context.ssr && context.prefixIdentifiers) {
-    hasDynamicSlots = hasScopeRef(node, context.identifiers);
+    hasDynamicSlots = node.props.some(
+      (prop) => isVSlot(prop) && (hasScopeRef(prop.arg, context.identifiers) || hasScopeRef(prop.exp, context.identifiers))
+    ) || children.some((child) => hasScopeRef(child, context.identifiers));
   }
   const onComponentSlot = findDir(node, "slot", true);
   if (onComponentSlot) {
@@ -17155,7 +17438,7 @@ function buildSlots(node, context, buildSlotFn = buildClientSlotFn) {
       );
     } else if (vElse = findDir(
       slotElement,
-      /^else(-if)?$/,
+      /^else(?:-if)?$/,
       true
       /* allowEmpty */
     )) {
@@ -17167,7 +17450,7 @@ function buildSlots(node, context, buildSlotFn = buildClientSlotFn) {
           break;
         }
       }
-      if (prev && isTemplateNode(prev) && findDir(prev, /^(else-)?if$/)) {
+      if (prev && isTemplateNode(prev) && findDir(prev, /^(?:else-)?if$/)) {
         let conditional = dynamicSlots[dynamicSlots.length - 1];
         while (conditional.alternate.type === 19) {
           conditional = conditional.alternate;
@@ -18092,6 +18375,65 @@ const transformOn$1 = (dir, node, context, augmentor) => {
   return ret;
 };
 
+const transformBind = (dir, _node, context) => {
+  const { modifiers, loc } = dir;
+  const arg = dir.arg;
+  let { exp } = dir;
+  if (exp && exp.type === 4 && !exp.content.trim()) {
+    {
+      context.onError(
+        createCompilerError(34, loc)
+      );
+      return {
+        props: [
+          createObjectProperty(arg, createSimpleExpression("", true, loc))
+        ]
+      };
+    }
+  }
+  if (arg.type !== 4) {
+    arg.children.unshift(`(`);
+    arg.children.push(`) || ""`);
+  } else if (!arg.isStatic) {
+    arg.content = arg.content ? `${arg.content} || ""` : `""`;
+  }
+  if (modifiers.some((mod) => mod.content === "camel")) {
+    if (arg.type === 4) {
+      if (arg.isStatic) {
+        arg.content = camelize(arg.content);
+      } else {
+        arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;
+      }
+    } else {
+      arg.children.unshift(`${context.helperString(CAMELIZE)}(`);
+      arg.children.push(`)`);
+    }
+  }
+  if (!context.inSSR) {
+    if (modifiers.some((mod) => mod.content === "prop")) {
+      injectPrefix(arg, ".");
+    }
+    if (modifiers.some((mod) => mod.content === "attr")) {
+      injectPrefix(arg, "^");
+    }
+  }
+  return {
+    props: [createObjectProperty(arg, exp)]
+  };
+};
+const injectPrefix = (arg, prefix) => {
+  if (arg.type === 4) {
+    if (arg.isStatic) {
+      arg.content = prefix + arg.content;
+    } else {
+      arg.content = `\`${prefix}\${${arg.content}}\``;
+    }
+  } else {
+    arg.children.unshift(`'${prefix}' + (`);
+    arg.children.push(`)`);
+  }
+};
+
 const transformText = (node, context) => {
   if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) {
     return () => {
@@ -18253,7 +18595,7 @@ const transformModel$1 = (dir, node, context) => {
   }
   if (dir.modifiers.length && node.tagType === 1) {
     const modifiers = dir.modifiers.map((m) => m.content).map((m) => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `);
-    const modifiersKey = arg ? isStaticExp(arg) ? `${arg.content}Modifiers` : createCompoundExpression([arg, ' + "Modifiers"']) : `modelModifiers`;
+    const modifiersKey = arg ? isStaticExp(arg) ? getModifierPropName(arg.content) : createCompoundExpression([arg, ' + "Modifiers"']) : `modelModifiers`;
     props.push(
       createObjectProperty(
         modifiersKey,
@@ -18420,7 +18762,7 @@ const seen = /* @__PURE__ */ new WeakSet();
 const transformMemo = (node, context) => {
   if (node.type === 1) {
     const dir = findDir(node, "memo");
-    if (!dir || seen.has(node)) {
+    if (!dir || seen.has(node) || context.inSSR) {
       return;
     }
     seen.add(node);
@@ -18442,9 +18784,36 @@ const transformMemo = (node, context) => {
   }
 };
 
+const transformVBindShorthand = (node, context) => {
+  if (node.type === 1) {
+    for (const prop of node.props) {
+      if (prop.type === 7 && prop.name === "bind" && (!prop.exp || // #13930 :foo in in-DOM templates will be parsed into :foo="" by browser
+      false) && prop.arg) {
+        const arg = prop.arg;
+        if (arg.type !== 4 || !arg.isStatic) {
+          context.onError(
+            createCompilerError(
+              52,
+              arg.loc
+            )
+          );
+          prop.exp = createSimpleExpression("", true, arg.loc);
+        } else {
+          const propName = camelize(arg.content);
+          if (validFirstIdentCharRE.test(propName[0]) || // allow hyphen first char for https://github.com/vuejs/language-tools/pull/3424
+          propName[0] === "-") {
+            prop.exp = createSimpleExpression(propName, false, arg.loc);
+          }
+        }
+      }
+    }
+  }
+};
+
 function getBaseTransformPreset(prefixIdentifiers) {
   return [
     [
+      transformVBindShorthand,
       transformOnce,
       transformIf,
       transformMemo,
@@ -18563,7 +18932,7 @@ const parserOptions = {
     let ns = parent ? parent.ns : rootNamespace;
     if (parent && ns === 2) {
       if (parent.tag === "annotation-xml") {
-        if (tag === "svg") {
+        if (isSVGTag(tag)) {
           return 1;
         }
         if (parent.props.some(
@@ -18580,10 +18949,10 @@ const parserOptions = {
       }
     }
     if (ns === 0) {
-      if (tag === "svg") {
+      if (isSVGTag(tag)) {
         return 1;
       }
-      if (tag === "math") {
+      if (isMathMLTag(tag)) {
         return 2;
       }
     }
@@ -18932,7 +19301,7 @@ const getCachedNode = (node) => {
     return node.codegenNode;
   }
 };
-const dataAriaRE = /^(data|aria)-/;
+const dataAriaRE = /^(?:data|aria)-/;
 const isStringifiableAttr = (name, ns) => {
   return (ns === 0 ? isKnownHtmlAttr(name) : ns === 1 ? isKnownSvgAttr(name) : ns === 2 ? isKnownMathMLAttr(name) : false) || dataAriaRE.test(name);
 };
@@ -18943,6 +19312,9 @@ function analyzeNode(node) {
   if (node.type === 1 && isNonStringifiable(node.tag)) {
     return false;
   }
+  if (node.type === 1 && findDir(node, "once", true)) {
+    return false;
+  }
   if (node.type === 12) {
     return [1, 0];
   }