@vue/runtime-dom 3.5.43 → 3.5.45

package/dist/runtime-dom.global.js

@@ -1,5 +1,5 @@
 /**
-* @vue/runtime-dom v3.5.43
+* @vue/runtime-dom v3.5.45
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -64,24 +64,20 @@ var VueRuntimeDOM = (function (exports) {
     });
   };
   const camelizeRE = /-\w/g;
-  const camelize = cacheStringFunction(
-    (str) => {
-      return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
-    }
-  );
+  const camelize = /* @__PURE__ */ cacheStringFunction((str) => {
+    return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
+  });
   const hyphenateRE = /\B([A-Z])/g;
-  const hyphenate = cacheStringFunction(
+  const hyphenate = /* @__PURE__ */ cacheStringFunction(
     (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
   );
-  const capitalize = cacheStringFunction((str) => {
+  const capitalize = /* @__PURE__ */ cacheStringFunction((str) => {
     return str.charAt(0).toUpperCase() + str.slice(1);
   });
-  const toHandlerKey = cacheStringFunction(
-    (str) => {
-      const s = str ? `on${capitalize(str)}` : ``;
-      return s;
-    }
-  );
+  const toHandlerKey = /* @__PURE__ */ cacheStringFunction((str) => {
+    const s = str ? `on${capitalize(str)}` : ``;
+    return s;
+  });
   const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
   const invokeArrayFns = (fns, ...arg) => {
     for (let i = 0; i < fns.length; i++) {
@@ -194,7 +190,7 @@ var VueRuntimeDOM = (function (exports) {
   const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
   const isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);
 
-  const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
+  const specialBooleanAttrs = `itemscope,allowfullscreen,disablepictureinpicture,disableremoteplayback,formnovalidate,ismap,nomodule,novalidate,playsinline,readonly`;
   const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
   const isBooleanAttr = /* @__PURE__ */ makeMap(
     specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
@@ -538,7 +534,11 @@ var VueRuntimeDOM = (function (exports) {
   }
   function onScopeDispose(fn, failSilently = false) {
     if (activeEffectScope) {
-      activeEffectScope.cleanups.push(fn);
+      if (activeEffectScope.active) {
+        activeEffectScope.cleanups.push(fn);
+      } else {
+        fn();
+      }
     } else if (!failSilently) {
       warn$2(
         `onScopeDispose() is called when there is no active effect scope to be associated with.`
@@ -1242,19 +1242,41 @@ var VueRuntimeDOM = (function (exports) {
   };
   function iterator(self, method, wrapValue) {
     const arr = shallowReadArray(self);
-    const iter = arr[method]();
+    const methodFn = arr[method];
+    const iter = methodFn.call(arr);
     if (arr !== self && !isShallow(self)) {
-      iter._next = iter.next;
-      iter.next = () => {
-        const result = iter._next();
-        if (!result.done) {
-          result.value = wrapValue(result.value);
+      if (iter[Symbol.toStringTag] === "Array Iterator") {
+        const wrapped = Object.create(Object.getPrototypeOf(iter));
+        wrapped.next = () => wrapResult(iter.next(), wrapValue);
+        if (methodFn !== arrayProto[method]) {
+          Object.defineProperties(wrapped, {
+            return: {
+              get() {
+                const fn = iter.return;
+                return typeof fn === "function" ? fn.bind(iter) : fn;
+              }
+            },
+            throw: {
+              get() {
+                const fn = iter.throw;
+                return typeof fn === "function" ? fn.bind(iter) : fn;
+              }
+            }
+          });
         }
-        return result;
-      };
+        return wrapped;
+      }
+      iter._next = iter.next;
+      iter.next = () => wrapResult(iter._next(), wrapValue);
     }
     return iter;
   }
+  function wrapResult(result, wrapValue) {
+    if (!result.done) {
+      result.value = wrapValue(result.value);
+    }
+    return result;
+  }
   const arrayProto = Array.prototype;
   function apply(self, method, fn, thisArg, wrappedRetFn, args) {
     const arr = shallowReadArray(self);
@@ -1323,7 +1345,7 @@ var VueRuntimeDOM = (function (exports) {
   }
 
   const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
-  const builtInSymbols = new Set(
+  const builtInSymbols = /* @__PURE__ */ new Set(
     /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
   );
   function hasOwnProperty(key) {
@@ -1677,6 +1699,8 @@ var VueRuntimeDOM = (function (exports) {
         return !isReadonly2;
       } else if (key === "__v_isReadonly") {
         return isReadonly2;
+      } else if (key === "__v_isShallow") {
+        return shallow;
       } else if (key === "__v_raw") {
         return target;
       }
@@ -2222,9 +2246,11 @@ var VueRuntimeDOM = (function (exports) {
     if (once && cb) {
       const _cb = cb;
       cb = (...args) => {
-        const res = _cb(...args);
-        watchHandle();
-        return res;
+        try {
+          return _cb(...args);
+        } finally {
+          watchHandle();
+        }
       };
     }
     let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
@@ -2235,12 +2261,13 @@ var VueRuntimeDOM = (function (exports) {
       if (cb) {
         const newValue = effect.run();
         if (immediateFirstRun || deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) {
-          if (cleanup) {
-            cleanup();
-          }
           const currentWatcher = activeWatcher;
-          activeWatcher = effect;
+          pauseTracking();
           try {
+            if (cleanup) {
+              cleanup();
+            }
+            activeWatcher = effect;
             const args = [
               newValue,
               // pass undefined as the old value when it's changed for the first time
@@ -2254,6 +2281,7 @@ var VueRuntimeDOM = (function (exports) {
             );
           } finally {
             activeWatcher = currentWatcher;
+            resetTracking();
           }
         }
       } else {
@@ -2527,7 +2555,7 @@ var VueRuntimeDOM = (function (exports) {
       const res = callWithErrorHandling(fn, instance, type, args);
       if (res && isPromise(res)) {
         res.catch((err) => {
-          handleError(err, instance, type);
+          handleError(err, instance, type, void 0, true);
         });
       }
       return res;
@@ -2544,7 +2572,7 @@ var VueRuntimeDOM = (function (exports) {
       );
     }
   }
-  function handleError(err, instance, type, throwInDev = true) {
+  function handleError(err, instance, type, throwInDev = true, isAsyncError = false) {
     const contextVNode = instance ? instance.vnode : null;
     const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
     if (instance) {
@@ -2553,7 +2581,9 @@ var VueRuntimeDOM = (function (exports) {
       const errorInfo = ErrorTypeStrings$1[type] ;
       while (cur) {
         const errorCapturedHooks = cur.ec;
-        if (errorCapturedHooks) {
+        if (errorCapturedHooks && !cur.isUnmounted && // Async failures may outlive stopped scopes whose unmount effects
+        // are deferred or discarded by Suspense.
+        (!isAsyncError || cur.scope.active)) {
           for (let i = 0; i < errorCapturedHooks.length; i++) {
             if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
               return;
@@ -2654,21 +2684,21 @@ var VueRuntimeDOM = (function (exports) {
     }
     queueFlush();
   }
-  function flushPreFlushCbs(instance, seen, i = flushIndex + 1) {
+  function flushPreFlushCbs(instance, minUid, seen, i = flushIndex + 1) {
     {
       seen = seen || /* @__PURE__ */ new Map();
     }
     for (; i < queue.length; i++) {
       const cb = queue[i];
       if (cb && cb.flags & 2) {
-        if (instance && cb.id !== instance.uid) {
+        if (instance && cb.id !== instance.uid || minUid !== void 0 && !(cb.id >= minUid)) {
           continue;
         }
         if (checkRecursiveUpdates(seen, cb)) {
           continue;
         }
         queue.splice(i, 1);
-        i--;
+        i = instance ? i - 1 : flushIndex;
         if (cb.flags & 4) {
           cb.flags &= -2;
         }
@@ -2679,12 +2709,23 @@ var VueRuntimeDOM = (function (exports) {
       }
     }
   }
-  function flushPostFlushCbs(seen) {
+  function flushPostFlushCbs(seen, skip, minUid = 0) {
     if (pendingPostFlushCbs.length) {
-      const deduped = [...new Set(pendingPostFlushCbs)].sort(
-        (a, b) => getId(a) - getId(b)
-      );
-      pendingPostFlushCbs.length = 0;
+      let cbs = pendingPostFlushCbs;
+      let kept = 0;
+      if (skip) {
+        cbs = [];
+        for (let i = 0; i < pendingPostFlushCbs.length; i++) {
+          const cb = pendingPostFlushCbs[i];
+          if (cb.i !== void 0 ? !cb.i || cb.i.uid < minUid : skip.has(cb)) {
+            pendingPostFlushCbs[kept++] = cb;
+          } else {
+            cbs.push(cb);
+          }
+        }
+      }
+      const deduped = [...new Set(cbs)].sort((a, b) => getId(a) - getId(b));
+      pendingPostFlushCbs.length = kept;
       if (activePostFlushCbs) {
         for (let i = 0; i < deduped.length; i++) {
           activePostFlushCbs.push(deduped[i]);
@@ -2710,6 +2751,22 @@ var VueRuntimeDOM = (function (exports) {
       postFlushIndex = 0;
     }
   }
+  let isFlushing = false;
+  function flushOnAppMount(fn, minUid) {
+    if (isFlushing) {
+      fn();
+      return;
+    }
+    const queued = minUid === void 0 ? void 0 : new Set(pendingPostFlushCbs);
+    fn();
+    isFlushing = true;
+    try {
+      flushPreFlushCbs(void 0, minUid);
+      flushPostFlushCbs(void 0, queued, minUid);
+    } finally {
+      isFlushing = false;
+    }
+  }
   const getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
   function flushJobs(seen) {
     {
@@ -2854,14 +2911,32 @@ var VueRuntimeDOM = (function (exports) {
         instance.ceReload(newComp.styles);
         dirtyInstances.delete(instance);
       } else if (instance.parent) {
-        queueJob(() => {
-          if (!(instance.job.flags & 8)) {
-            isHmrUpdating = true;
+        const update = () => {
+          if (!instance.scope.active) return;
+          const pending = instance.asyncDep && !instance.asyncResolved ? instance : locateUnresolvedAsyncRoot(instance.parent);
+          if (pending) {
+            pending.asyncDep.catch(NOOP).then(() => {
+              if (instance.scope.active && (pending.asyncResolved || !pending.scope.active)) {
+                queueJob(update);
+              }
+            });
+            return;
+          }
+          dirtyInstances = hmrDirtyComponents.get(oldComp);
+          if (!dirtyInstances) {
+            hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set());
+          }
+          dirtyInstances.add(instance);
+          isHmrUpdating = true;
+          try {
             instance.parent.update();
+          } finally {
             isHmrUpdating = false;
             dirtyInstances.delete(instance);
+            queuePostFlushCb(() => hmrDirtyComponents.clear());
           }
-        });
+        };
+        queueJob(update);
       } else if (instance.appContext.reload) {
         instance.appContext.reload();
       } else if (typeof window !== "undefined") {
@@ -3077,12 +3152,31 @@ var VueRuntimeDOM = (function (exports) {
     return vnode;
   }
   function invokeDirectiveHook(vnode, prevVNode, instance, name) {
-    const bindings = vnode.dirs;
+    let hookVNode = vnode;
+    if (name === "beforeMount") {
+      vnode._mount = vnode;
+    } else if (name === "beforeUpdate") {
+      const mount = prevVNode && prevVNode._mount;
+      if (mount) {
+        mount._latest = vnode;
+        vnode._mount = mount;
+      }
+    } else if (name === "mounted") {
+      const latest = vnode._latest;
+      vnode._mount = vnode._latest = void 0;
+      if (latest) {
+        hookVNode = latest;
+        latest._mount = void 0;
+      }
+    }
+    const bindings = hookVNode.dirs;
     const oldBindings = prevVNode && prevVNode.dirs;
     for (let i = 0; i < bindings.length; i++) {
-      const binding = bindings[i];
+      let binding = bindings[i];
       if (oldBindings) {
         binding.oldValue = oldBindings[i].value;
+      } else if (name === "mounted" && binding.oldValue !== void 0) {
+        binding = extend({}, binding, { oldValue: void 0 });
       }
       let hook = binding.dir[name];
       if (hook) {
@@ -3090,7 +3184,7 @@ var VueRuntimeDOM = (function (exports) {
         callWithAsyncErrorHandling(hook, instance, 8, [
           vnode.el,
           binding,
-          vnode,
+          hookVNode,
           prevVNode
         ]);
         resetTracking();
@@ -3190,6 +3284,7 @@ var VueRuntimeDOM = (function (exports) {
     let isPre = false;
     if (flush === "post") {
       baseWatchOptions.scheduler = (job) => {
+        job.i = instance;
         queuePostRenderEffect(job, instance && instance.suspense);
       };
     } else if (flush !== "sync") {
@@ -3484,7 +3579,11 @@ var VueRuntimeDOM = (function (exports) {
   };
   function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) {
     if (moveType === 0) {
+      if (vnode.targetStart) {
+        insert(vnode.targetStart, container, parentAnchor);
+      }
       insert(vnode.targetAnchor, container, parentAnchor);
+      parentAnchor = vnode.targetAnchor;
     }
     const { el, anchor, shapeFlag, children, props } = vnode;
     const isReorder = moveType === 2;
@@ -3653,10 +3752,6 @@ var VueRuntimeDOM = (function (exports) {
     onAfterAppear: TransitionHookValidator,
     onAppearCancelled: TransitionHookValidator
   };
-  const recursiveGetSubtree = (instance) => {
-    const subTree = instance.subTree;
-    return subTree.component ? recursiveGetSubtree(subTree.component) : subTree;
-  };
   const BaseTransitionImpl = {
     name: `BaseTransition`,
     props: BaseTransitionPropsValidators,
@@ -3685,19 +3780,17 @@ var VueRuntimeDOM = (function (exports) {
         if (!innerChild) {
           return emptyPlaceholder(child);
         }
-        let enterHooks = resolveTransitionHooks(
+        const enterHooks = resolveTransitionHooks(
           innerChild,
           rawProps,
           state,
-          instance,
-          // #11061, ensure enterHooks is fresh after clone
-          (hooks) => enterHooks = hooks
+          instance
         );
         if (innerChild.type !== Comment) {
           setTransitionHooks(innerChild, enterHooks);
         }
         let oldInnerChild = instance.subTree && getInnerChild$1(instance.subTree);
-        if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(oldInnerChild, innerChild) && recursiveGetSubtree(instance).type !== Comment) {
+        if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(oldInnerChild, innerChild) && getTransitionRoot(instance.subTree)) {
           let leavingHooks = resolveTransitionHooks(
             oldInnerChild,
             rawProps,
@@ -3710,7 +3803,17 @@ var VueRuntimeDOM = (function (exports) {
             leavingHooks.afterLeave = () => {
               state.isLeaving = false;
               if (!(instance.job.flags & 8)) {
-                instance.update();
+                if (instance.effect.flags & 2) {
+                  const job = () => {
+                    if (!(instance.job.flags & 8)) {
+                      instance.update();
+                    }
+                  };
+                  job.i = instance;
+                  queueJob(job);
+                } else {
+                  instance.update();
+                }
               }
               delete leavingHooks.afterLeave;
               oldInnerChild = void 0;
@@ -3774,7 +3877,7 @@ var VueRuntimeDOM = (function (exports) {
     }
     return leavingVNodesCache;
   }
-  function resolveTransitionHooks(vnode, props, state, instance, postClone) {
+  function resolveTransitionHooks(vnode, props, state, instance) {
     const {
       appear,
       mode,
@@ -3830,8 +3933,15 @@ var VueRuntimeDOM = (function (exports) {
           );
         }
         const leavingVNode = leavingVNodesCache[key];
-        if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) {
-          leavingVNode.el[leaveCbKey]();
+        if (leavingVNode && isSameVNodeType(vnode, leavingVNode)) {
+          let leavingCb = leavingVNode.el[leaveCbKey];
+          if (!leavingCb) {
+            const leavingRoot = getTransitionRoot(leavingVNode);
+            leavingCb = leavingRoot && leavingRoot.el[leaveCbKey];
+          }
+          if (leavingCb) {
+            leavingCb();
+          }
         }
         callHook(hook, [el]);
       },
@@ -3906,15 +4016,21 @@ var VueRuntimeDOM = (function (exports) {
         }
       },
       clone(vnode2) {
-        const hooks2 = resolveTransitionHooks(
-          vnode2,
-          props,
-          state,
-          instance,
-          postClone
-        );
-        if (postClone) postClone(hooks2);
-        return hooks2;
+        const cloned = resolveTransitionHooks(vnode2, props, state, instance);
+        cloned.afterLeave = () => {
+          if (hooks.afterLeave) hooks.afterLeave();
+        };
+        cloned.delayLeave = (el, earlyRemove, delayedLeave) => {
+          if (hooks.delayLeave) {
+            hooks.delayLeave(el, earlyRemove, delayedLeave);
+          } else {
+            delayedLeave();
+          }
+        };
+        cloned.delayedLeave = () => {
+          if (hooks.delayedLeave) hooks.delayedLeave();
+        };
+        return cloned;
       }
     };
     return hooks;
@@ -3955,10 +4071,24 @@ var VueRuntimeDOM = (function (exports) {
         hooks
       );
     } else if (vnode.shapeFlag & 128) {
-      vnode.ssContent.transition = hooks.clone(vnode.ssContent);
-      vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
+      const suspense = vnode.suspense;
+      if (suspense) {
+        const branch = suspense.isHydrating ? suspense.pendingBranch : suspense.activeBranch;
+        if (branch) {
+          setTransitionHooks(branch, hooks.clone(branch));
+        }
+      } else {
+        vnode.ssContent.transition = hooks.clone(vnode.ssContent);
+        vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
+      }
     } else {
       vnode.transition = hooks;
+      if (vnode.type === Fragment && isArray(vnode.children)) {
+        const child = filterSingleRoot(vnode.children, false);
+        if (child) {
+          setTransitionHooks(child, hooks);
+        }
+      }
     }
   }
   function getTransitionRawChildren(children, keepComment = false, parentKey) {
@@ -3983,6 +4113,18 @@ var VueRuntimeDOM = (function (exports) {
     }
     return ret;
   }
+  function getTransitionRoot(vnode) {
+    if (vnode.component) {
+      return getTransitionRoot(vnode.component.subTree);
+    }
+    if (vnode.type === Fragment) {
+      const child = isArray(vnode.children) && filterSingleRoot(vnode.children, false);
+      return child ? getTransitionRoot(child) : void 0;
+    }
+    if (vnode.type !== Comment) {
+      return vnode;
+    }
+  }
 
   // @__NO_SIDE_EFFECTS__
   function defineComponent(options, extraOptions) {
@@ -4639,7 +4781,7 @@ Server rendered element contains fewer child nodes than client vdom.`
         getContainerType(container),
         slotScopeIds
       );
-      if (parentComponent) {
+      if (parentComponent && parentComponent.vnode.el === node) {
         parentComponent.vnode.el = vnode.el;
         updateHOCHostEl(parentComponent, vnode.el);
       }
@@ -4888,14 +5030,22 @@ Server rendered element contains fewer child nodes than client vdom.`
         break;
       }
     }, opts);
-    forEach((el) => {
-      if (!(el instanceof Element)) return;
+    const observe = (el) => {
       if (elementIsVisibleInViewport(el)) {
         hydrate();
         ob.disconnect();
         return false;
       }
+      if (getComputedStyle(el).display === "contents") {
+        for (let i = 0; i < el.children.length; i++) {
+          if (observe(el.children[i]) === false) return false;
+        }
+      }
       ob.observe(el);
+    };
+    forEach((el) => {
+      if (!(el instanceof Element)) return;
+      return observe(el);
     });
     return () => ob.disconnect();
   };
@@ -5065,7 +5215,8 @@ Server rendered element contains fewer child nodes than client vdom.`
             err,
             instance,
             13,
-            !errorComponent
+            !errorComponent,
+            true
           );
         };
         if (suspensible && instance.suspense || false) {
@@ -5083,7 +5234,7 @@ Server rendered element contains fewer child nodes than client vdom.`
         const delayed = ref(!!delay);
         let timeoutTimer;
         let delayTimer;
-        onUnmounted(() => {
+        onScopeDispose(() => {
           if (timeoutTimer != null) clearTimeout(timeoutTimer);
           if (delayTimer != null) clearTimeout(delayTimer);
         });
@@ -5205,6 +5356,12 @@ Server rendered element contains fewer child nodes than client vdom.`
         }
       };
       sharedContext.deactivate = (vnode) => {
+        const cached = cache.get(
+          vnode.key == null ? vnode.type : vnode.key
+        );
+        if (!cached || cached.component !== vnode.component) {
+          return false;
+        }
         const instance2 = vnode.component;
         invalidateMount(instance2.m);
         invalidateMount(instance2.a);
@@ -5225,6 +5382,7 @@ Server rendered element contains fewer child nodes than client vdom.`
         {
           instance2.__keepAliveStorageContainer = storageContainer;
         }
+        return true;
       };
       function unmount(vnode) {
         resetShapeFlag(vnode);
@@ -5246,6 +5404,7 @@ Server rendered element contains fewer child nodes than client vdom.`
           unmount(cached);
         } else if (current) {
           resetShapeFlag(current);
+          if (cached) resetShapeFlag(cached);
         }
         cache.delete(key);
         keys.delete(key);
@@ -5263,12 +5422,17 @@ Server rendered element contains fewer child nodes than client vdom.`
       const cacheSubtree = () => {
         if (pendingCacheKey != null) {
           if (isSuspense(instance.subTree.type)) {
-            queuePostRenderEffect(() => {
+            const cacheInnerChild = () => {
               const vnode = getInnerChild(instance.subTree);
               if (vnode.component) {
                 cache.set(pendingCacheKey, vnode);
               }
-            }, instance.subTree.suspense);
+            };
+            if (instance.subTree.suspense.pendingBranch) {
+              queuePostRenderEffect(cacheInnerChild, instance.subTree.suspense);
+            } else {
+              cacheInnerChild();
+            }
           } else {
             cache.set(pendingCacheKey, getInnerChild(instance.subTree));
           }
@@ -5399,9 +5563,12 @@ Server rendered element contains fewer child nodes than client vdom.`
       true
       /* prepend */
     );
-    onUnmounted(() => {
-      remove(keepAliveRoot[type], injected);
-    }, target);
+    const removal = injectHook(
+      "um",
+      () => remove(keepAliveRoot[type], injected),
+      target
+    );
+    removal.flags = 16;
   }
   function resetShapeFlag(vnode) {
     vnode.shapeFlag &= -257;
@@ -5537,9 +5704,11 @@ If this is a native custom element, make sure to exclude it from component resol
       }
     } else if (typeof source === "number") {
       if (!Number.isInteger(source) || source < 0) {
-        warn$1(
-          `The v-for range expects a positive integer value but got ${source}.`
-        );
+        {
+          warn$1(
+            `The v-for range expects a positive integer value but got ${source}.`
+          );
+        }
         ret = [];
       } else {
         ret = new Array(source);
@@ -7174,7 +7343,7 @@ If you want to remount the same app, move your app creation logic into a factory
     }
     for (let i = 0; i < nextKeys.length; i++) {
       const key = nextKeys[i];
-      if (hasPropValueChanged(nextProps, prevProps, key) && !isEmitListener(emitsOptions, key)) {
+      if (!hasOwn(prevProps, key) || hasPropValueChanged(nextProps, prevProps, key) && !isEmitListener(emitsOptions, key)) {
         return true;
       }
     }
@@ -8054,6 +8223,8 @@ If you want to remount the same app, move your app creation logic into a factory
       const needCallTransitionHooks = needTransition(parentSuspense, transition);
       if (needCallTransitionHooks) {
         transition.beforeEnter(el);
+      } else if (transition && !transition.persisted) {
+        el[deferredEnterKey] = true;
       }
       hostInsert(el, container, anchor);
       if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {
@@ -8213,15 +8384,16 @@ If you want to remount the same app, move your app creation logic into a factory
       for (let i = 0; i < newChildren.length; i++) {
         const oldVNode = oldChildren[i];
         const newVNode = newChildren[i];
+        const oldEl = oldVNode.el || resolveAsyncComponentPlaceholder(oldVNode);
         const container = (
           // oldVNode may be an errored async setup() component inside Suspense
           // which will not have a mounted element
-          oldVNode.el && // - In the case of a Fragment, we need to provide the actual parent
+          oldEl && // - In the case of a Fragment, we need to provide the actual parent
           // of the Fragment itself so it can move its children.
           (oldVNode.type === Fragment || // - In the case of different nodes, there is going to be a replacement
           // which also requires the correct parent container
           !isSameVNodeType(oldVNode, newVNode) || // - In the case of a component, it could contain anything.
-          oldVNode.shapeFlag & (6 | 64 | 128)) ? hostParentNode(oldVNode.el) : (
+          oldVNode.shapeFlag & (6 | 64 | 128)) ? hostParentNode(oldEl) : (
             // In other cases, the parent container is not actually used so we
             // just pass the block element here to avoid a DOM parentNode call.
             fallbackContainer
@@ -8385,7 +8557,12 @@ If you want to remount the same app, move your app creation logic into a factory
       }
       if (isHmrUpdating) initialVNode.el = null;
       if (instance.asyncDep) {
-        parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect, optimized);
+        parentSuspense && parentSuspense.registerDep(
+          instance,
+          setupRenderEffect,
+          optimized,
+          namespace
+        );
         if (!initialVNode.el) {
           const placeholder = instance.subTree = createVNode(Comment);
           processCommentNode(null, placeholder, container, anchor);
@@ -8415,6 +8592,7 @@ If you want to remount the same app, move your app creation logic into a factory
             pushWarningContext(n2);
           }
           n2.el = n1.el;
+          n2.placeholder = n1.placeholder;
           updateComponentPreRender(instance, n2, optimized);
           {
             popWarningContext();
@@ -8426,6 +8604,7 @@ If you want to remount the same app, move your app creation logic into a factory
         }
       } else {
         n2.el = n1.el;
+        n2.placeholder = n1.placeholder;
         instance.vnode = n2;
       }
     };
@@ -8528,16 +8707,23 @@ If you want to remount the same app, move your app creation logic into a factory
         } else {
           let { next, bu, u, parent, vnode } = instance;
           {
-            const nonHydratedAsyncRoot = locateNonHydratedAsyncRoot(instance);
-            if (nonHydratedAsyncRoot) {
+            const unresolvedAsyncRoot = locateUnresolvedAsyncRoot(instance);
+            if (unresolvedAsyncRoot) {
               if (next) {
                 next.el = vnode.el;
                 updateComponentPreRender(instance, next, optimized);
               }
-              nonHydratedAsyncRoot.asyncDep.then(() => {
-                queuePostRenderEffect(() => {
-                  if (!instance.isUnmounted) update();
-                }, parentSuspense);
+              unresolvedAsyncRoot.asyncDep.then(() => {
+                const retry = () => {
+                  if (instance.job.flags & 8) return;
+                  if (parentSuspense && parentSuspense.pendingBranch) {
+                    queuePostRenderEffect(retry, parentSuspense);
+                  } else {
+                    update();
+                  }
+                };
+                retry.flags = 16 | 32;
+                queuePostRenderEffect(retry, parentSuspense);
               });
               return;
             }
@@ -8576,8 +8762,11 @@ If you want to remount the same app, move your app creation logic into a factory
           patch(
             prevTree,
             nextTree,
-            // parent may have changed if it's in a teleport
-            hostParentNode(prevTree.el),
+            // parent may have changed if it's in a teleport. a root that is a
+            // pending async component only has its placeholder comment
+            hostParentNode(
+              prevTree.el || resolveAsyncComponentPlaceholder(prevTree)
+            ),
             // anchor may have changed if it's in a fragment
             getNextHostNode(prevTree),
             instance,
@@ -9017,8 +9206,7 @@ If you want to remount the same app, move your app creation logic into a factory
       if (cacheIndex != null && (!vnode.ctx || vnode.ctx === parentComponent)) {
         parentComponent.renderCache[cacheIndex] = void 0;
       }
-      if (shapeFlag & 256) {
-        parentComponent.ctx.deactivate(vnode);
+      if (shapeFlag & 256 && parentComponent.ctx.deactivate(vnode)) {
         return;
       }
       const shouldInvokeDirs = shapeFlag & 1 && dirs;
@@ -9079,18 +9267,9 @@ If you want to remount the same app, move your app creation logic into a factory
     };
     const remove = (vnode) => {
       const { type, el, anchor, transition } = vnode;
-      if (type === Fragment) {
-        if (vnode.patchFlag > 0 && vnode.patchFlag & 2048 && transition && !transition.persisted) {
-          vnode.children.forEach((child) => {
-            if (child.type === Comment) {
-              hostRemove(child.el);
-            } else {
-              remove(child);
-            }
-          });
-        } else {
-          removeFragment(el, anchor);
-        }
+      const isFragment = type === Fragment;
+      if (isFragment && !transition) {
+        removeFragment(el, anchor);
         return;
       }
       if (type === Static) {
@@ -9100,17 +9279,25 @@ If you want to remount the same app, move your app creation logic into a factory
         }
         return;
       }
+      const leavingNode = isFragment ? getTransitionRoot(vnode) : vnode;
       const performRemove = () => {
-        hostRemove(el);
+        if (isFragment) {
+          if (hostParentNode(el)) {
+            removeFragment(el, anchor);
+          }
+        } else {
+          hostRemove(el);
+        }
         if (transition && !transition.persisted && transition.afterLeave) {
           transition.afterLeave();
         }
       };
-      if (vnode.shapeFlag & 1 && transition && !transition.persisted) {
+      if (leavingNode && leavingNode.shapeFlag & 1 && transition && !transition.persisted) {
         const { leave, delayLeave } = transition;
-        const performLeave = () => leave(el, performRemove);
+        const leavingEl = leavingNode.el;
+        const performLeave = () => leave(leavingEl, performRemove);
         if (delayLeave) {
-          delayLeave(vnode.el, performRemove, performLeave);
+          delayLeave(leavingEl, performRemove, performLeave);
         } else {
           performLeave();
         }
@@ -9141,16 +9328,18 @@ If you want to remount the same app, move your app creation logic into a factory
       if (job) {
         job.flags |= 8;
         unmount(subTree, instance, parentSuspense, doRemove);
-      } else if (instance.vnode.el && subTree) {
+      } else if (subTree) {
         subTree.transition = instance.vnode.transition;
         unmount(subTree, instance, parentSuspense, doRemove);
       }
       if (um) {
         queuePostRenderEffect(um, parentSuspense);
       }
-      queuePostRenderEffect(() => {
+      const markUnmounted = () => {
         instance.isUnmounted = true;
-      }, parentSuspense);
+      };
+      markUnmounted.flags = 16;
+      queuePostRenderEffect(markUnmounted, parentSuspense);
       {
         devtoolsComponentRemoved(instance);
       }
@@ -9171,32 +9360,26 @@ If you want to remount the same app, move your app creation logic into a factory
       const teleportEnd = el && el[TeleportEndKey];
       return teleportEnd ? hostNextSibling(teleportEnd) : el;
     };
-    let isFlushing = false;
     const render = (vnode, container, namespace) => {
-      let instance;
-      if (vnode == null) {
-        if (container._vnode) {
-          unmount(container._vnode, null, null, true);
-          instance = container._vnode.component;
+      const minUid = vnode && container._vnode ? void 0 : vnode && vnode.component ? vnode.component.uid : getNextUid();
+      flushOnAppMount(() => {
+        if (vnode == null) {
+          if (container._vnode) {
+            unmount(container._vnode, null, null, true);
+          }
+        } else {
+          patch(
+            container._vnode || null,
+            vnode,
+            container,
+            null,
+            null,
+            null,
+            namespace
+          );
         }
-      } else {
-        patch(
-          container._vnode || null,
-          vnode,
-          container,
-          null,
-          null,
-          null,
-          namespace
-        );
-      }
-      container._vnode = vnode;
-      if (!isFlushing) {
-        isFlushing = true;
-        flushPreFlushCbs(instance);
-        flushPostFlushCbs();
-        isFlushing = false;
-      }
+        container._vnode = vnode;
+      }, minUid);
     };
     const internals = {
       p: patch,
@@ -9308,13 +9491,13 @@ If you want to remount the same app, move your app creation logic into a factory
     }
     return result;
   }
-  function locateNonHydratedAsyncRoot(instance) {
+  function locateUnresolvedAsyncRoot(instance) {
     const subComponent = instance.subTree.component;
     if (subComponent) {
       if (subComponent.asyncDep && !subComponent.asyncResolved) {
         return subComponent;
       } else {
-        return locateNonHydratedAsyncRoot(subComponent);
+        return locateUnresolvedAsyncRoot(subComponent);
       }
     }
   }
@@ -9332,11 +9515,16 @@ If you want to remount the same app, move your app creation logic into a factory
     if (instance) {
       return resolveAsyncComponentPlaceholder(instance.subTree);
     }
+    const suspense = anchorVnode.suspense;
+    if (suspense && suspense.activeBranch) {
+      return resolveAsyncComponentPlaceholder(suspense.activeBranch);
+    }
     return null;
   }
 
   const isSuspense = (type) => type.__isSuspense;
   let suspenseId = 0;
+  const deferredEnterKey = /* @__PURE__ */ Symbol("_deferredEnter");
   const SuspenseImpl = {
     name: "Suspense",
     // In order to make Suspense tree-shakable, we need to avoid importing it
@@ -9358,11 +9546,22 @@ If you want to remount the same app, move your app creation logic into a factory
           rendererInternals
         );
       } else {
-        if (parentSuspense && parentSuspense.deps > 0 && !n1.suspense.isInFallback && !parentSuspense.isHydrating) {
-          n2.suspense = n1.suspense;
-          n2.suspense.vnode = n2;
-          n2.el = n1.el;
-          return;
+        const suspense = n1.suspense;
+        if (parentSuspense && parentSuspense.deps > 0 && !parentSuspense.isHydrating) {
+          const owner = suspense.parentComponent;
+          const retained = !!owner && owner.suspense === parentSuspense && owner.suspenseId !== parentSuspense.pendingId;
+          if (retained ? (
+            // deps can outlive the pending branch: skip only while it exists
+            parentSuspense.pendingBranch && !isSameVNodeType(
+              n2.ssContent,
+              suspense.pendingBranch || suspense.activeBranch
+            )
+          ) : !suspense.isInFallback) {
+            n2.suspense = suspense;
+            suspense.vnode = n2;
+            n2.el = n1.el;
+            return;
+          }
         }
         patchSuspense(
           n1,
@@ -9387,6 +9586,38 @@ If you want to remount the same app, move your app creation logic into a factory
       eventListener();
     }
   }
+  function enterDeferred(branch) {
+    const enters = [];
+    collectDeferredEnters(branch, enters, true);
+    if (enters.length) {
+      queuePostFlushCb(enters);
+    }
+  }
+  function collectDeferredEnters(vnode, enters, isRoot) {
+    const { el, transition, children, shapeFlag } = vnode;
+    if (shapeFlag & 6) {
+      collectDeferredEnters(vnode.component.subTree, enters, isRoot);
+      return;
+    }
+    if (shapeFlag & (128 | 64)) {
+      return;
+    }
+    if (shapeFlag & 1) {
+      if (!isRoot && el && el[deferredEnterKey]) {
+        el[deferredEnterKey] = void 0;
+        if (transition && !transition.persisted) {
+          transition.beforeEnter(el);
+          enters.push(() => transition.enter(el));
+        }
+      }
+      isRoot = false;
+    }
+    if (shapeFlag & 16) {
+      for (let i = 0; i < children.length; i++) {
+        collectDeferredEnters(children[i], enters, isRoot);
+      }
+    }
+  }
   function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
     const {
       p: patch,
@@ -9486,7 +9717,7 @@ If you want to remount the same app, move your app creation logic into a factory
           unmount(pendingBranch, parentComponent, suspense);
         }
         suspense.deps = 0;
-        suspense.effects.length = 0;
+        discardEffects(suspense);
         suspense.hiddenContainer = createElement("div");
         if (isInFallback) {
           patch(
@@ -9564,11 +9795,7 @@ If you want to remount the same app, move your app creation logic into a factory
       } else {
         triggerEvent(n2, "onPending");
         suspense.pendingBranch = newBranch;
-        if (newBranch.shapeFlag & 512) {
-          suspense.pendingId = newBranch.component.suspenseId;
-        } else {
-          suspense.pendingId = suspenseId++;
-        }
+        suspense.pendingId = suspenseId++;
         patch(
           null,
           newBranch,
@@ -9583,12 +9810,11 @@ If you want to remount the same app, move your app creation logic into a factory
         if (suspense.deps <= 0) {
           suspense.resolve();
         } else {
-          const { timeout, pendingId } = suspense;
+          const { timeout } = suspense;
           if (timeout > 0) {
-            setTimeout(() => {
-              if (suspense.pendingId === pendingId) {
-                suspense.fallback(newFallback);
-              }
+            suspense.timeoutTimer = setTimeout(() => {
+              suspense.timeoutTimer = void 0;
+              suspense.fallback(suspense.vnode.ssFallback);
             }, timeout);
           } else if (timeout === 0) {
             suspense.fallback(newFallback);
@@ -9635,6 +9861,7 @@ If you want to remount the same app, move your app creation logic into a factory
       deps: 0,
       pendingId: suspenseId++,
       timeout: typeof timeout === "number" ? timeout : -1,
+      timeoutTimer: void 0,
       activeBranch: null,
       isFallbackMountPending: false,
       pendingBranch: null,
@@ -9673,7 +9900,8 @@ If you want to remount the same app, move your app creation logic into a factory
           let hasUpdatedAnchor = false;
           if (delayEnter) {
             activeBranch.transition.afterLeave = () => {
-              if (pendingId === suspense.pendingId) {
+              if (pendingId === suspense.pendingId && !suspense.isUnmounted) {
+                enterDeferred(pendingBranch);
                 move(
                   pendingBranch,
                   container2,
@@ -9688,7 +9916,9 @@ If you want to remount the same app, move your app creation logic into a factory
             };
           }
           if (activeBranch && !suspense.isFallbackMountPending) {
-            if (parentNode(activeBranch.el) === container2) {
+            if (parentNode(
+              activeBranch.el || resolveAsyncComponentPlaceholder(activeBranch)
+            ) === container2) {
               anchor = next(activeBranch);
               hasUpdatedAnchor = true;
             }
@@ -9698,13 +9928,26 @@ If you want to remount the same app, move your app creation logic into a factory
             }
           }
           if (!delayEnter) {
+            enterDeferred(pendingBranch);
             move(pendingBranch, container2, anchor, 0);
           }
         }
+        clearTimeout(suspense.timeoutTimer);
+        suspense.timeoutTimer = void 0;
         suspense.isFallbackMountPending = false;
         setActiveBranch(suspense, pendingBranch);
         suspense.pendingBranch = null;
         suspense.isInFallback = false;
+        let kept = 0;
+        for (let i = 0; i < effects.length; i++) {
+          const effect = effects[i];
+          if (effect.flags & 32) {
+            queuePostFlushCb(effect);
+          } else {
+            effects[kept++] = effect;
+          }
+        }
+        effects.length = kept;
         let parent = suspense.parent;
         let hasUnresolvedAncestor = false;
         while (parent) {
@@ -9733,7 +9976,7 @@ If you want to remount the same app, move your app creation logic into a factory
         triggerEvent(vnode2, "onResolve");
       },
       fallback(fallbackVNode) {
-        if (!suspense.pendingBranch) {
+        if (suspense.isUnmounted || !suspense.pendingBranch) {
           return;
         }
         const { vnode: vnode2, activeBranch, parentComponent: parentComponent2, container: container2, namespace: namespace2 } = suspense;
@@ -9741,7 +9984,7 @@ If you want to remount the same app, move your app creation logic into a factory
         const anchor2 = next(activeBranch);
         const mountFallback = () => {
           suspense.isFallbackMountPending = false;
-          if (!suspense.isInFallback) {
+          if (suspense.isUnmounted || !suspense.isInFallback) {
             return;
           }
           const latestFallback = suspense.vnode.ssFallback;
@@ -9784,25 +10027,16 @@ If you want to remount the same app, move your app creation logic into a factory
       next() {
         return suspense.activeBranch && next(suspense.activeBranch);
       },
-      registerDep(instance, setupRenderEffect, optimized2) {
+      // `namespace` intentionally shadows the boundary's own: the dep must be
+      // mounted with the namespace of the position it was rendered at, which can
+      // differ from the boundary's (e.g. a component nested inside an <svg>).
+      registerDep(instance, setupRenderEffect, optimized2, namespace2) {
         const isInPendingSuspense = !!suspense.pendingBranch;
         if (isInPendingSuspense) {
           suspense.deps++;
         }
         const hydratedEl = instance.vnode.el;
-        instance.asyncDep.catch((err) => {
-          handleError(err, instance, 0);
-        }).then((asyncSetupResult) => {
-          if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) {
-            return;
-          }
-          unsetCurrentInstance();
-          if (hydratedEl && !instance.scope.active) {
-            if (isInPendingSuspense && --suspense.deps === 0) {
-              suspense.resolve();
-            }
-            return;
-          }
+        const render = (asyncSetupResult) => {
           instance.asyncResolved = true;
           const { vnode: vnode2 } = instance;
           {
@@ -9824,7 +10058,7 @@ If you want to remount the same app, move your app creation logic into a factory
             // consider the comment placeholder case.
             hydratedEl ? null : next(instance.subTree),
             suspense,
-            namespace,
+            namespace2,
             optimized2
           );
           if (placeholder) {
@@ -9835,13 +10069,57 @@ If you want to remount the same app, move your app creation logic into a factory
           {
             popWarningContext();
           }
-          if (isInPendingSuspense && --suspense.deps === 0) {
+        };
+        instance.asyncDep.catch((err) => {
+          handleError(err, instance, 0, false, true);
+          return () => null;
+        }).then((asyncSetupResult) => {
+          if (instance.isUnmounted || suspense.isUnmounted) {
+            return;
+          }
+          const isPendingDep = isInPendingSuspense && suspense.pendingId === instance.suspenseId;
+          unsetCurrentInstance();
+          if (!instance.scope.active) {
+            if (isPendingDep && --suspense.deps === 0) {
+              suspense.resolve();
+            }
+            return;
+          }
+          if (!isPendingDep && suspense.pendingBranch) {
+            const job = () => {
+              if (instance.isUnmounted || suspense.isUnmounted || !instance.scope.active) {
+                return;
+              }
+              if (suspense.pendingBranch) {
+                queueEffectWithSuspense(job, suspense);
+              } else {
+                render(asyncSetupResult);
+              }
+            };
+            job.flags = 16 | 32;
+            queueEffectWithSuspense(job, suspense);
+            return;
+          }
+          render(asyncSetupResult);
+          if (isPendingDep && --suspense.deps === 0) {
             suspense.resolve();
           }
         });
       },
       unmount(parentSuspense2, doRemove) {
         suspense.isUnmounted = true;
+        clearTimeout(suspense.timeoutTimer);
+        suspense.timeoutTimer = void 0;
+        if (parentSuspenseId !== void 0) {
+          const parent = suspense.parent;
+          const pendingId = parentSuspenseId;
+          parentSuspenseId = void 0;
+          queuePostFlushCb(() => {
+            if (parent.pendingId === pendingId && !parent.isUnmounted && --parent.deps === 0) {
+              parent.resolve();
+            }
+          });
+        }
         if (suspense.activeBranch) {
           unmount(
             suspense.activeBranch,
@@ -9851,12 +10129,8 @@ If you want to remount the same app, move your app creation logic into a factory
           );
         }
         if (suspense.pendingBranch) {
-          unmount(
-            suspense.pendingBranch,
-            parentComponent,
-            parentSuspense2,
-            doRemove
-          );
+          unmount(suspense.pendingBranch, parentComponent, suspense, doRemove);
+          discardEffects(suspense);
         }
       }
     };
@@ -9926,6 +10200,16 @@ If you want to remount the same app, move your app creation logic into a factory
     }
     return s;
   }
+  function discardEffects(suspense) {
+    const { effects } = suspense;
+    for (let i = 0; i < effects.length; i++) {
+      const effect = effects[i];
+      if (effect.flags & 16) {
+        queuePostFlushCb(effect);
+      }
+    }
+    effects.length = 0;
+  }
   function queueEffectWithSuspense(fn, suspense) {
     if (suspense && suspense.pendingBranch) {
       if (isArray(fn)) {
@@ -10177,7 +10461,8 @@ Component that was made reactive: `,
   }
   function guardReactiveProps(props) {
     if (!props) return null;
-    return isProxy(props) || isInternalObject(props) ? extend({}, props) : props;
+    if (isProxy(props)) return extend({}, props);
+    return isInternalObject(props) ? extend({}, props[rawAttrsKey] || props) : props;
   }
   function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false) {
     const { props, ref, patchFlag, children, transition } = vnode;
@@ -10356,8 +10641,11 @@ Component that was made reactive: `,
     ]);
   }
 
-  const emptyAppContext = createAppContext();
+  const emptyAppContext = /* @__PURE__ */ createAppContext();
   let uid = 0;
+  function getNextUid() {
+    return uid;
+  }
   function createComponentInstance(vnode, parent, suspense) {
     const type = vnode.type;
     const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
@@ -10554,7 +10842,8 @@ Component that was made reactive: `,
               setInSSRSetupState(false);
             }
           }).catch((e) => {
-            handleError(e, instance, 0);
+            handleError(e, instance, 0, void 0, true);
+            instance.ssrRender = (_, push) => push("<!---->");
           });
         } else {
           instance.asyncDep = setupResult;
@@ -10660,11 +10949,12 @@ Component that was made reactive: `,
       }
     }
   }
+  const rawAttrsKey = /* @__PURE__ */ Symbol();
   const attrsProxyHandlers = {
     get(target, key) {
       markAttrsAccessed();
       track(target, "get", "");
-      return target[key];
+      return key === rawAttrsKey ? target : target[key];
     },
     set() {
       warn$1(`setupContext.attrs is readonly.`);
@@ -11016,7 +11306,7 @@ Component that was made reactive: `,
     return true;
   }
 
-  const version = "3.5.43";
+  const version = "3.5.45";
   const warn = warn$1 ;
   const ErrorTypeStrings = ErrorTypeStrings$1 ;
   const devtools = devtools$1 ;
@@ -11573,7 +11863,9 @@ Component that was made reactive: `,
       }
     }
     if (vShowOriginalDisplay in el) {
-      el[vShowOriginalDisplay] = hasControlledDisplay ? style.display : "";
+      if (!isCssString || prev !== next) {
+        el[vShowOriginalDisplay] = hasControlledDisplay ? style.display : "";
+      }
       if (el[vShowHidden]) {
         style.display = "none";
       }
@@ -12055,7 +12347,9 @@ Expected function or array of functions, received type ${typeof value}.`
             "Custom element style injection is not supported when using shadowRoot: false"
           );
         }
-        this._mount(def);
+        if (this._connected) {
+          this._mount(def);
+        }
       };
       const asyncDef = this._def.__asyncLoader;
       if (asyncDef) {
@@ -12413,6 +12707,7 @@ Expected function or array of functions, received type ${typeof value}.`
   const newPositionMap = /* @__PURE__ */ new WeakMap();
   const moveCbKey = /* @__PURE__ */ Symbol("_moveCb");
   const enterCbKey = /* @__PURE__ */ Symbol("_enterCb");
+  const pendingGroups = /* @__PURE__ */ new WeakMap();
   const decorate = (t) => {
     delete t.props.mode;
     return t;
@@ -12428,21 +12723,30 @@ Expected function or array of functions, received type ${typeof value}.`
       const state = useTransitionState();
       let prevChildren;
       let children;
-      onUpdated(() => {
-        if (!prevChildren.length) {
-          return;
+      let origins;
+      let moves;
+      const willMove = () => {
+        if (moves === void 0) {
+          moves = prevChildren.length > 0 && hasCSSTransform(
+            prevChildren[0].el,
+            instance.vnode.el,
+            resolveMoveClass(props)
+          );
         }
-        const moveClass = props.moveClass || `${props.name || "v"}-move`;
-        if (!hasCSSTransform(
-          prevChildren[0].el,
-          instance.vnode.el,
-          moveClass
-        )) {
+        return moves;
+      };
+      onUpdated(() => {
+        pendingGroups.delete(instance);
+        if (!willMove()) {
           prevChildren = [];
+          origins = void 0;
           return;
         }
+        const moveClass = resolveMoveClass(props);
         prevChildren.forEach(callPendingCbs);
-        prevChildren.forEach(recordPosition);
+        const shift = origins && getOriginShift(origins, instance.vnode.el);
+        origins = void 0;
+        prevChildren.forEach((c) => recordPosition(c, shift));
         const movedChildren = prevChildren.filter(applyTranslation);
         forceReflow(instance.vnode.el);
         movedChildren.forEach((c) => {
@@ -12469,6 +12773,7 @@ Expected function or array of functions, received type ${typeof value}.`
         const cssTransitionProps = resolveTransitionProps(rawProps);
         let tag = rawProps.tag || Fragment;
         prevChildren = [];
+        moves = void 0;
         if (children) {
           for (let i = 0; i < children.length; i++) {
             const child = children[i];
@@ -12500,6 +12805,10 @@ Expected function or array of functions, received type ${typeof value}.`
             warn(`<TransitionGroup> children must be keyed.`);
           }
         }
+        if (prevChildren.length) {
+          origins = getOrigins(instance);
+          pendingGroups.set(instance, willMove);
+        }
         return createVNode(tag, null, children);
       };
     }
@@ -12514,8 +12823,11 @@ Expected function or array of functions, received type ${typeof value}.`
       el[enterCbKey]();
     }
   }
-  function recordPosition(c) {
-    newPositionMap.set(c, getPosition(c.el));
+  function resolveMoveClass(props) {
+    return props.moveClass || `${props.name || "v"}-move`;
+  }
+  function recordPosition(c, shift) {
+    newPositionMap.set(c, getPosition(c.el, shift));
   }
   function applyTranslation(c) {
     const oldPos = positionMap.get(c);
@@ -12539,13 +12851,41 @@ Expected function or array of functions, received type ${typeof value}.`
       return c;
     }
   }
-  function getPosition(el) {
+  function getPosition(el, shift) {
     const rect = el.getBoundingClientRect();
     return {
-      left: rect.left,
-      top: rect.top
+      left: rect.left - (shift ? shift.left : 0),
+      top: rect.top - (shift ? shift.top : 0)
     };
   }
+  function getOrigins(instance) {
+    let origins;
+    for (let group = instance.parent; group; group = group.parent) {
+      const willMove = pendingGroups.get(group);
+      if (willMove) {
+        const item = findItem(group.vnode.el, instance.vnode.el);
+        if (item) {
+          (origins || (origins = [])).push(
+            extend(getPosition(item), { item, willMove })
+          );
+        }
+      }
+    }
+    return origins;
+  }
+  function findItem(root, node) {
+    const container = root.nodeType === 1 ? root : root.parentNode;
+    while (node && node.parentNode !== container) {
+      node = node.parentNode;
+    }
+    if (node && node.nodeType === 1) {
+      return node;
+    }
+  }
+  function getOriginShift(origins, root) {
+    const origin = origins.find((o) => o.willMove() && o.item.contains(root));
+    return origin && getPosition(origin.item, origin);
+  }
   function hasCSSTransform(el, root, moveClass) {
     const clone = el.cloneNode();
     const _vtc = el[vtcKey];
@@ -12740,18 +13080,18 @@ Expected function or array of functions, received type ${typeof value}.`
     },
     // set value in mounted & updated because <select> relies on its children
     // <option>s.
-    mounted(el, { value }) {
-      setSelected(el, value);
+    mounted(el, { value, modifiers: { number } }) {
+      setSelected(el, value, number);
     },
     beforeUpdate(el, { value }, vnode) {
       el._modelValue = value;
       el[assignKey] = getModelAssigner(vnode);
     },
-    updated(el, { value }) {
+    updated(el, { value, modifiers: { number } }) {
       const pending = el._pendingValue;
       el._pendingValue = void 0;
       if (!pending || pending[0] !== el.multiple || !isSameSelectValue(value, pending[1], pending[0])) {
-        setSelected(el, value);
+        setSelected(el, value, number);
       }
     }
   };
@@ -12767,7 +13107,7 @@ Expected function or array of functions, received type ${typeof value}.`
     }
     return false;
   }
-  function setSelected(el, value) {
+  function setSelected(el, value, number = false) {
     const isMultiple = el.multiple;
     const isArrayValue = isArray(value);
     if (isMultiple && !isArrayValue && !isSet(value)) {
@@ -12788,7 +13128,7 @@ Expected function or array of functions, received type ${typeof value}.`
             option.selected = looseIndexOf(value, optionValue) > -1;
           }
         } else {
-          option.selected = value.has(optionValue);
+          option.selected = value.has(optionValue) || number && typeof optionValue === "string" && value.has(looseToNumber(optionValue));
         }
       } else if (looseEqual(getValue(option), value)) {
         if (el.selectedIndex !== i) el.selectedIndex = i;