@vue/runtime-dom 3.5.44 → 3.5.45

package/dist/runtime-dom.esm-browser.js

@@ -1,5 +1,5 @@
 /**
-* @vue/runtime-dom v3.5.44
+* @vue/runtime-dom v3.5.45
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -61,24 +61,20 @@ const cacheStringFunction = (fn) => {
   });
 };
 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++) {
@@ -191,7 +187,7 @@ const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
 const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
 const isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);
 
-const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,playsinline,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`
@@ -535,7 +531,11 @@ function getCurrentScope() {
 }
 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.`
@@ -1342,7 +1342,7 @@ function noTracking(self, method, args = []) {
 }
 
 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) {
@@ -2552,7 +2552,7 @@ function callWithAsyncErrorHandling(fn, instance, type, args) {
     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;
@@ -2569,7 +2569,7 @@ function callWithAsyncErrorHandling(fn, instance, type, args) {
     );
   }
 }
-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) {
@@ -2578,7 +2578,9 @@ function handleError(err, instance, type, throwInDev = true) {
     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;
@@ -2906,14 +2908,32 @@ function reload(id, newComp) {
       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") {
@@ -3129,12 +3149,31 @@ function withDirectives(vnode, directives) {
   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) {
@@ -3142,7 +3181,7 @@ function invokeDirectiveHook(vnode, prevVNode, instance, name) {
       callWithAsyncErrorHandling(hook, instance, 8, [
         vnode.el,
         binding,
-        vnode,
+        hookVNode,
         prevVNode
       ]);
       resetTracking();
@@ -3766,13 +3805,11 @@ const BaseTransitionImpl = {
       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);
@@ -3791,7 +3828,17 @@ const BaseTransitionImpl = {
           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;
@@ -3855,7 +3902,7 @@ function getLeavingNodesForType(state, vnode) {
   }
   return leavingVNodesCache;
 }
-function resolveTransitionHooks(vnode, props, state, instance, postClone) {
+function resolveTransitionHooks(vnode, props, state, instance) {
   const {
     appear,
     mode,
@@ -3994,15 +4041,21 @@ function resolveTransitionHooks(vnode, props, state, instance, postClone) {
       }
     },
     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;
@@ -4043,8 +4096,16 @@ function setTransitionHooks(vnode, hooks) {
       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)) {
@@ -4745,7 +4806,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);
     }
@@ -5179,7 +5240,8 @@ function defineAsyncComponent(source) {
           err,
           instance,
           13,
-          !errorComponent
+          !errorComponent,
+          true
         );
       };
       if (suspensible && instance.suspense || isInSSRComponentSetup) {
@@ -5197,7 +5259,7 @@ function defineAsyncComponent(source) {
       const delayed = ref(!!delay);
       let timeoutTimer;
       let delayTimer;
-      onUnmounted(() => {
+      onScopeDispose(() => {
         if (timeoutTimer != null) clearTimeout(timeoutTimer);
         if (delayTimer != null) clearTimeout(delayTimer);
       });
@@ -5325,6 +5387,12 @@ const KeepAliveImpl = {
       }
     };
     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);
@@ -5345,6 +5413,7 @@ const KeepAliveImpl = {
       {
         instance2.__keepAliveStorageContainer = storageContainer;
       }
+      return true;
     };
     function unmount(vnode) {
       resetShapeFlag(vnode);
@@ -5384,12 +5453,17 @@ const KeepAliveImpl = {
     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));
         }
@@ -5520,9 +5594,12 @@ function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
     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;
@@ -8180,6 +8257,8 @@ function baseCreateRenderer(options, createHydrationFns) {
     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) {
@@ -8662,16 +8741,23 @@ function baseCreateRenderer(options, createHydrationFns) {
       } 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;
           }
@@ -8710,8 +8796,11 @@ function baseCreateRenderer(options, createHydrationFns) {
         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,
@@ -9151,8 +9240,7 @@ function baseCreateRenderer(options, createHydrationFns) {
     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;
@@ -9274,16 +9362,18 @@ function baseCreateRenderer(options, createHydrationFns) {
     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);
     }
@@ -9435,13 +9525,13 @@ function getSequence(arr) {
   }
   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);
     }
   }
 }
@@ -9459,11 +9549,16 @@ function resolveAsyncComponentPlaceholder(anchorVnode) {
   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
@@ -9485,11 +9580,22 @@ const SuspenseImpl = {
         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,
@@ -9514,6 +9620,38 @@ function triggerEvent(vnode, name) {
     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,
@@ -9613,7 +9751,7 @@ function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, sl
         unmount(pendingBranch, parentComponent, suspense);
       }
       suspense.deps = 0;
-      suspense.effects.length = 0;
+      discardEffects(suspense);
       suspense.hiddenContainer = createElement("div");
       if (isInFallback) {
         patch(
@@ -9691,11 +9829,7 @@ function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, sl
     } 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,
@@ -9710,12 +9844,11 @@ function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, sl
       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);
@@ -9762,6 +9895,7 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
     deps: 0,
     pendingId: suspenseId++,
     timeout: typeof timeout === "number" ? timeout : -1,
+    timeoutTimer: void 0,
     activeBranch: null,
     isFallbackMountPending: false,
     pendingBranch: null,
@@ -9800,7 +9934,8 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
         let hasUpdatedAnchor = false;
         if (delayEnter) {
           activeBranch.transition.afterLeave = () => {
-            if (pendingId === suspense.pendingId) {
+            if (pendingId === suspense.pendingId && !suspense.isUnmounted) {
+              enterDeferred(pendingBranch);
               move(
                 pendingBranch,
                 container2,
@@ -9815,7 +9950,9 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
           };
         }
         if (activeBranch && !suspense.isFallbackMountPending) {
-          if (parentNode(activeBranch.el) === container2) {
+          if (parentNode(
+            activeBranch.el || resolveAsyncComponentPlaceholder(activeBranch)
+          ) === container2) {
             anchor = next(activeBranch);
             hasUpdatedAnchor = true;
           }
@@ -9825,13 +9962,26 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
           }
         }
         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) {
@@ -9860,7 +10010,7 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
       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;
@@ -9868,7 +10018,7 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
       const anchor2 = next(activeBranch);
       const mountFallback = () => {
         suspense.isFallbackMountPending = false;
-        if (!suspense.isInFallback) {
+        if (suspense.isUnmounted || !suspense.isInFallback) {
           return;
         }
         const latestFallback = suspense.vnode.ssFallback;
@@ -9920,19 +10070,7 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
         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 (!instance.scope.active) {
-          if (isInPendingSuspense && --suspense.deps === 0) {
-            suspense.resolve();
-          }
-          return;
-        }
+      const render = (asyncSetupResult) => {
         instance.asyncResolved = true;
         const { vnode: vnode2 } = instance;
         {
@@ -9965,13 +10103,57 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
         {
           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,
@@ -9981,12 +10163,8 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
         );
       }
       if (suspense.pendingBranch) {
-        unmount(
-          suspense.pendingBranch,
-          parentComponent,
-          parentSuspense2,
-          doRemove
-        );
+        unmount(suspense.pendingBranch, parentComponent, suspense, doRemove);
+        discardEffects(suspense);
       }
     }
   };
@@ -10056,6 +10234,16 @@ function normalizeSuspenseSlot(s) {
   }
   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)) {
@@ -10307,7 +10495,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;
@@ -10486,7 +10675,7 @@ function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
   ]);
 }
 
-const emptyAppContext = createAppContext();
+const emptyAppContext = /* @__PURE__ */ createAppContext();
 let uid = 0;
 function getNextUid() {
   return uid;
@@ -10699,7 +10888,8 @@ function setupStatefulComponent(instance, isSSR) {
             setInSSRSetupState(false);
           }
         }).catch((e) => {
-          handleError(e, instance, 0);
+          handleError(e, instance, 0, void 0, true);
+          instance.ssrRender = (_, push) => push("<!---->");
         });
       } else {
         instance.asyncDep = setupResult;
@@ -10807,11 +10997,12 @@ function finishComponentSetup(instance, isSSR, skipOptions) {
     }
   }
 }
+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.`);
@@ -11163,7 +11354,7 @@ function isMemoSame(cached, memo) {
   return true;
 }
 
-const version = "3.5.44";
+const version = "3.5.45";
 const warn = warn$1 ;
 const ErrorTypeStrings = ErrorTypeStrings$1 ;
 const devtools = devtools$1 ;
@@ -12968,18 +13159,18 @@ const vModelSelect = {
   },
   // 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);
     }
   }
 };
@@ -12995,7 +13186,7 @@ function isSameSelectValue(value, assignedValue, multiple) {
   }
   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)) {
@@ -13016,7 +13207,7 @@ function setSelected(el, 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;