@vue/runtime-core 3.5.44 → 3.5.45

package/dist/runtime-core.esm-bundler.js

@@ -1,9 +1,9 @@
 /**
-* @vue/runtime-core v3.5.44
+* @vue/runtime-core v3.5.45
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
-import { pauseTracking, resetTracking, isRef, toRaw, traverse, watch as watch$1, shallowRef, readonly, isReactive, ref, isShallow, isReadonly, shallowReadArray, toReadonly, toReactive, shallowReadonly, track, reactive, customRef, shallowReactive, trigger, ReactiveEffect, isProxy, proxyRefs, markRaw, EffectScope, computed as computed$1 } from '@vue/reactivity';
+import { pauseTracking, resetTracking, isRef, toRaw, traverse, watch as watch$1, shallowRef, readonly, isReactive, ref, onScopeDispose, isShallow, isReadonly, shallowReadArray, toReadonly, toReactive, shallowReadonly, track, reactive, customRef, shallowReactive, trigger, ReactiveEffect, isProxy, proxyRefs, markRaw, EffectScope, computed as computed$1 } from '@vue/reactivity';
 export { EffectScope, ReactiveEffect, TrackOpTypes, TriggerOpTypes, customRef, effect, effectScope, getCurrentScope, getCurrentWatcher, isProxy, isReactive, isReadonly, isRef, isShallow, markRaw, onScopeDispose, onWatcherCleanup, proxyRefs, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, toValue, triggerRef, unref } from '@vue/reactivity';
 import { isString, isFunction, EMPTY_OBJ, isPromise, isArray, NOOP, getGlobalThis, extend, isBuiltInDirective, NO, hasOwn, remove, def, isOn, isReservedProp, normalizeClass, stringifyStyle, normalizeStyle, isKnownSvgAttr, isBooleanAttr, isKnownHtmlAttr, includeBooleanAttr, isRenderableAttrValue, normalizeCssVarValue, getEscapedCssVarName, isObject, isRegExp, invokeArrayFns, toHandlerKey, camelize, capitalize, isSymbol, isGloballyAllowed, hyphenate, hasChanged, looseToNumber, isModelListener, looseEqual, EMPTY_ARR, toRawType, makeMap, toNumber } from '@vue/shared';
 export { camelize, capitalize, normalizeClass, normalizeProps, normalizeStyle, toDisplayString, toHandlerKey } from '@vue/shared';
@@ -206,7 +206,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;
@@ -223,7 +223,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) {
@@ -232,7 +232,9 @@ function handleError(err, instance, type, throwInDev = true) {
     const errorInfo = !!(process.env.NODE_ENV !== "production") ? ErrorTypeStrings$1[type] : `https://vuejs.org/error-reference/#runtime-${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;
@@ -564,14 +566,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") {
@@ -787,12 +807,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) {
@@ -800,7 +839,7 @@ function invokeDirectiveHook(vnode, prevVNode, instance, name) {
       callWithAsyncErrorHandling(hook, instance, 8, [
         vnode.el,
         binding,
-        vnode,
+        hookVNode,
         prevVNode
       ]);
       resetTracking();
@@ -1424,13 +1463,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);
@@ -1449,7 +1486,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;
@@ -1514,7 +1561,7 @@ function getLeavingNodesForType(state, vnode) {
   }
   return leavingVNodesCache;
 }
-function resolveTransitionHooks(vnode, props, state, instance, postClone) {
+function resolveTransitionHooks(vnode, props, state, instance) {
   const {
     appear,
     mode,
@@ -1653,15 +1700,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;
@@ -1702,8 +1755,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)) {
@@ -2416,7 +2477,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);
     }
@@ -2850,7 +2911,8 @@ function defineAsyncComponent(source) {
           err,
           instance,
           13,
-          !errorComponent
+          !errorComponent,
+          true
         );
       };
       if (suspensible && instance.suspense || isInSSRComponentSetup) {
@@ -2868,7 +2930,7 @@ function defineAsyncComponent(source) {
       const delayed = ref(!!delay);
       let timeoutTimer;
       let delayTimer;
-      onUnmounted(() => {
+      onScopeDispose(() => {
         if (timeoutTimer != null) clearTimeout(timeoutTimer);
         if (delayTimer != null) clearTimeout(delayTimer);
       });
@@ -2996,6 +3058,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);
@@ -3016,6 +3084,7 @@ const KeepAliveImpl = {
       if (!!(process.env.NODE_ENV !== "production") && true) {
         instance2.__keepAliveStorageContainer = storageContainer;
       }
+      return true;
     };
     function unmount(vnode) {
       resetShapeFlag(vnode);
@@ -3055,12 +3124,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));
         }
@@ -3191,9 +3265,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;
@@ -5882,6 +5959,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) {
@@ -6375,16 +6454,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;
           }
@@ -6423,8 +6509,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,
@@ -6864,8 +6953,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;
@@ -6987,16 +7075,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);
     if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
       devtoolsComponentRemoved(instance);
     }
@@ -7148,13 +7238,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);
     }
   }
 }
@@ -7172,11 +7262,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
@@ -7198,11 +7293,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,
@@ -7227,6 +7333,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,
@@ -7326,7 +7464,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(
@@ -7404,11 +7542,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,
@@ -7423,12 +7557,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);
@@ -7475,6 +7608,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,
@@ -7513,7 +7647,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,
@@ -7528,7 +7663,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;
           }
@@ -7538,13 +7675,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) {
@@ -7573,7 +7723,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;
@@ -7581,7 +7731,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;
@@ -7633,19 +7783,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;
         if (!!(process.env.NODE_ENV !== "production")) {
@@ -7678,13 +7816,57 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
         if (!!(process.env.NODE_ENV !== "production")) {
           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,
@@ -7694,12 +7876,8 @@ function createSuspenseBoundary(vnode, parentSuspense, parentComponent, containe
         );
       }
       if (suspense.pendingBranch) {
-        unmount(
-          suspense.pendingBranch,
-          parentComponent,
-          parentSuspense2,
-          doRemove
-        );
+        unmount(suspense.pendingBranch, parentComponent, suspense, doRemove);
+        discardEffects(suspense);
       }
     }
   };
@@ -7769,6 +7947,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)) {
@@ -8020,7 +8208,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;
@@ -8199,7 +8388,7 @@ function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
   ]);
 }
 
-const emptyAppContext = createAppContext();
+const emptyAppContext = /* @__PURE__ */ createAppContext();
 let uid = 0;
 function getNextUid() {
   return uid;
@@ -8414,7 +8603,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;
@@ -8522,11 +8712,12 @@ function finishComponentSetup(instance, isSSR, skipOptions) {
     }
   }
 }
+const rawAttrsKey = /* @__PURE__ */ Symbol();
 const attrsProxyHandlers = !!(process.env.NODE_ENV !== "production") ? {
   get(target, key) {
     markAttrsAccessed();
     track(target, "get", "");
-    return target[key];
+    return key === rawAttrsKey ? target : target[key];
   },
   set() {
     warn$1(`setupContext.attrs is readonly.`);
@@ -8539,7 +8730,7 @@ const attrsProxyHandlers = !!(process.env.NODE_ENV !== "production") ? {
 } : {
   get(target, key) {
     track(target, "get", "");
-    return target[key];
+    return key === rawAttrsKey ? target : target[key];
   }
 };
 function getSlotsProxy(instance) {
@@ -8890,7 +9081,7 @@ function isMemoSame(cached, memo) {
   return true;
 }
 
-const version = "3.5.44";
+const version = "3.5.45";
 const warn = !!(process.env.NODE_ENV !== "production") ? warn$1 : NOOP;
 const ErrorTypeStrings = ErrorTypeStrings$1 ;
 const devtools = !!(process.env.NODE_ENV !== "production") || true ? devtools$1 : void 0;