@vue/runtime-dom 3.5.44 → 3.5.45

package/dist/runtime-dom.global.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
 **/
@@ -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,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`
@@ -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.`
@@ -1345,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) {
@@ -2555,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;
@@ -2572,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) {
@@ -2581,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;
@@ -2909,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") {
@@ -3132,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) {
@@ -3145,7 +3184,7 @@ var VueRuntimeDOM = (function (exports) {
         callWithAsyncErrorHandling(hook, instance, 8, [
           vnode.el,
           binding,
-          vnode,
+          hookVNode,
           prevVNode
         ]);
         resetTracking();
@@ -3741,13 +3780,11 @@ 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);
@@ -3766,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;
@@ -3830,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,
@@ -3969,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;
@@ -4018,8 +4071,16 @@ 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)) {
@@ -4720,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);
       }
@@ -5154,7 +5215,8 @@ Server rendered element contains fewer child nodes than client vdom.`
             err,
             instance,
             13,
-            !errorComponent
+            !errorComponent,
+            true
           );
         };
         if (suspensible && instance.suspense || false) {
@@ -5172,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);
         });
@@ -5294,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);
@@ -5314,6 +5382,7 @@ Server rendered element contains fewer child nodes than client vdom.`
         {
           instance2.__keepAliveStorageContainer = storageContainer;
         }
+        return true;
       };
       function unmount(vnode) {
         resetShapeFlag(vnode);
@@ -5353,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));
           }
@@ -5489,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;
@@ -8146,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) {
@@ -8628,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;
             }
@@ -8676,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,
@@ -9117,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;
@@ -9240,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);
       }
@@ -9401,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);
       }
     }
   }
@@ -9425,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
@@ -9451,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,
@@ -9480,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,
@@ -9579,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(
@@ -9657,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,
@@ -9676,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);
@@ -9728,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,
@@ -9766,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,
@@ -9781,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;
             }
@@ -9791,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) {
@@ -9826,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;
@@ -9834,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;
@@ -9886,19 +10036,7 @@ If you want to remount the same app, move your app creation logic into a factory
           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;
           {
@@ -9931,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,
@@ -9947,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);
         }
       }
     };
@@ -10022,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)) {
@@ -10273,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;
@@ -10452,7 +10641,7 @@ Component that was made reactive: `,
     ]);
   }
 
-  const emptyAppContext = createAppContext();
+  const emptyAppContext = /* @__PURE__ */ createAppContext();
   let uid = 0;
   function getNextUid() {
     return uid;
@@ -10653,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;
@@ -10759,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.`);
@@ -11115,7 +11306,7 @@ Component that was made reactive: `,
     return true;
   }
 
-  const version = "3.5.44";
+  const version = "3.5.45";
   const warn = warn$1 ;
   const ErrorTypeStrings = ErrorTypeStrings$1 ;
   const devtools = devtools$1 ;
@@ -12889,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);
       }
     }
   };
@@ -12916,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)) {
@@ -12937,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;