@vue/runtime-dom 3.5.0-beta.1 → 3.5.0-beta.3

package/dist/runtime-dom.global.js

@@ -1,5 +1,5 @@
 /**
-* @vue/runtime-dom v3.5.0-beta.1
+* @vue/runtime-dom v3.5.0-beta.3
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -468,11 +468,11 @@ var VueRuntimeDOM = (function (exports) {
       }
     }
     pause() {
-      this.flags |= 128;
+      this.flags |= 64;
     }
     resume() {
-      if (this.flags & 128) {
-        this.flags &= ~128;
+      if (this.flags & 64) {
+        this.flags &= ~64;
         if (pausedQueueEffects.has(this)) {
           pausedQueueEffects.delete(this);
           this.trigger();
@@ -486,9 +486,6 @@ var VueRuntimeDOM = (function (exports) {
       if (this.flags & 2 && !(this.flags & 32)) {
         return;
       }
-      if (this.flags & 64) {
-        return this.trigger();
-      }
       if (!(this.flags & 8)) {
         this.flags |= 8;
         this.nextEffect = batchedEffect;
@@ -532,7 +529,7 @@ var VueRuntimeDOM = (function (exports) {
       }
     }
     trigger() {
-      if (this.flags & 128) {
+      if (this.flags & 64) {
         pausedQueueEffects.add(this);
       } else if (this.scheduler) {
         this.scheduler();
@@ -562,6 +559,7 @@ var VueRuntimeDOM = (function (exports) {
       batchDepth--;
       return;
     }
+    batchDepth--;
     let error;
     while (batchedEffect) {
       let e = batchedEffect;
@@ -580,7 +578,6 @@ var VueRuntimeDOM = (function (exports) {
         e = next;
       }
     }
-    batchDepth--;
     if (error) throw error;
   }
   function prepareDeps(sub) {
@@ -983,26 +980,26 @@ var VueRuntimeDOM = (function (exports) {
       });
     },
     every(fn, thisArg) {
-      return apply(this, "every", fn, thisArg);
+      return apply(this, "every", fn, thisArg, void 0, arguments);
     },
     filter(fn, thisArg) {
-      return apply(this, "filter", fn, thisArg, (v) => v.map(toReactive));
+      return apply(this, "filter", fn, thisArg, (v) => v.map(toReactive), arguments);
     },
     find(fn, thisArg) {
-      return apply(this, "find", fn, thisArg, toReactive);
+      return apply(this, "find", fn, thisArg, toReactive, arguments);
     },
     findIndex(fn, thisArg) {
-      return apply(this, "findIndex", fn, thisArg);
+      return apply(this, "findIndex", fn, thisArg, void 0, arguments);
     },
     findLast(fn, thisArg) {
-      return apply(this, "findLast", fn, thisArg, toReactive);
+      return apply(this, "findLast", fn, thisArg, toReactive, arguments);
     },
     findLastIndex(fn, thisArg) {
-      return apply(this, "findLastIndex", fn, thisArg);
+      return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
     },
     // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
     forEach(fn, thisArg) {
-      return apply(this, "forEach", fn, thisArg);
+      return apply(this, "forEach", fn, thisArg, void 0, arguments);
     },
     includes(...args) {
       return searchProxy(this, "includes", args);
@@ -1018,7 +1015,7 @@ var VueRuntimeDOM = (function (exports) {
       return searchProxy(this, "lastIndexOf", args);
     },
     map(fn, thisArg) {
-      return apply(this, "map", fn, thisArg);
+      return apply(this, "map", fn, thisArg, void 0, arguments);
     },
     pop() {
       return noTracking(this, "pop");
@@ -1037,7 +1034,7 @@ var VueRuntimeDOM = (function (exports) {
     },
     // slice could use ARRAY_ITERATE but also seems to beg for range tracking
     some(fn, thisArg) {
-      return apply(this, "some", fn, thisArg);
+      return apply(this, "some", fn, thisArg, void 0, arguments);
     },
     splice(...args) {
       return noTracking(this, "splice", args);
@@ -1073,12 +1070,17 @@ var VueRuntimeDOM = (function (exports) {
     }
     return iter;
   }
-  function apply(self, method, fn, thisArg, wrappedRetFn) {
+  const arrayProto = Array.prototype;
+  function apply(self, method, fn, thisArg, wrappedRetFn, args) {
     const arr = shallowReadArray(self);
-    let needsWrap = false;
+    const needsWrap = arr !== self && !isShallow(self);
+    const methodFn = arr[method];
+    if (methodFn !== arrayProto[method]) {
+      const result2 = methodFn.apply(arr, args);
+      return needsWrap ? toReactive(result2) : result2;
+    }
     let wrappedFn = fn;
     if (arr !== self) {
-      needsWrap = !isShallow(self);
       if (needsWrap) {
         wrappedFn = function(item, index) {
           return fn.call(this, toReactive(item), index, self);
@@ -1089,7 +1091,7 @@ var VueRuntimeDOM = (function (exports) {
         };
       }
     }
-    const result = arr[method](wrappedFn, thisArg);
+    const result = methodFn.call(arr, wrappedFn, thisArg);
     return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
   }
   function reduce(self, method, fn, args) {
@@ -1940,6 +1942,220 @@ var VueRuntimeDOM = (function (exports) {
     "CLEAR": "clear"
   };
 
+  const INITIAL_WATCHER_VALUE = {};
+  const cleanupMap = /* @__PURE__ */ new WeakMap();
+  let activeWatcher = void 0;
+  function getCurrentWatcher() {
+    return activeWatcher;
+  }
+  function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) {
+    if (owner) {
+      let cleanups = cleanupMap.get(owner);
+      if (!cleanups) cleanupMap.set(owner, cleanups = []);
+      cleanups.push(cleanupFn);
+    } else if (!failSilently) {
+      warn$2(
+        `onWatcherCleanup() was called when there was no active watcher to associate with.`
+      );
+    }
+  }
+  function watch$1(source, cb, options = EMPTY_OBJ) {
+    const { immediate, deep, once, scheduler, augmentJob, call } = options;
+    const warnInvalidSource = (s) => {
+      (options.onWarn || warn$2)(
+        `Invalid watch source: `,
+        s,
+        `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`
+      );
+    };
+    const reactiveGetter = (source2) => {
+      if (deep) return source2;
+      if (isShallow(source2) || deep === false || deep === 0)
+        return traverse(source2, 1);
+      return traverse(source2);
+    };
+    let effect;
+    let getter;
+    let cleanup;
+    let boundCleanup;
+    let forceTrigger = false;
+    let isMultiSource = false;
+    if (isRef(source)) {
+      getter = () => source.value;
+      forceTrigger = isShallow(source);
+    } else if (isReactive(source)) {
+      getter = () => reactiveGetter(source);
+      forceTrigger = true;
+    } else if (isArray(source)) {
+      isMultiSource = true;
+      forceTrigger = source.some((s) => isReactive(s) || isShallow(s));
+      getter = () => source.map((s) => {
+        if (isRef(s)) {
+          return s.value;
+        } else if (isReactive(s)) {
+          return reactiveGetter(s);
+        } else if (isFunction(s)) {
+          return call ? call(s, 2) : s();
+        } else {
+          warnInvalidSource(s);
+        }
+      });
+    } else if (isFunction(source)) {
+      if (cb) {
+        getter = call ? () => call(source, 2) : source;
+      } else {
+        getter = () => {
+          if (cleanup) {
+            pauseTracking();
+            try {
+              cleanup();
+            } finally {
+              resetTracking();
+            }
+          }
+          const currentEffect = activeWatcher;
+          activeWatcher = effect;
+          try {
+            return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
+          } finally {
+            activeWatcher = currentEffect;
+          }
+        };
+      }
+    } else {
+      getter = NOOP;
+      warnInvalidSource(source);
+    }
+    if (cb && deep) {
+      const baseGetter = getter;
+      const depth = deep === true ? Infinity : deep;
+      getter = () => traverse(baseGetter(), depth);
+    }
+    if (once) {
+      if (cb) {
+        const _cb = cb;
+        cb = (...args) => {
+          _cb(...args);
+          effect.stop();
+        };
+      } else {
+        const _getter = getter;
+        getter = () => {
+          _getter();
+          effect.stop();
+        };
+      }
+    }
+    let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
+    const job = (immediateFirstRun) => {
+      if (!(effect.flags & 1) || !effect.dirty && !immediateFirstRun) {
+        return;
+      }
+      if (cb) {
+        const newValue = effect.run();
+        if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) {
+          if (cleanup) {
+            cleanup();
+          }
+          const currentWatcher = activeWatcher;
+          activeWatcher = effect;
+          try {
+            const args = [
+              newValue,
+              // pass undefined as the old value when it's changed for the first time
+              oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
+              boundCleanup
+            ];
+            call ? call(cb, 3, args) : (
+              // @ts-expect-error
+              cb(...args)
+            );
+            oldValue = newValue;
+          } finally {
+            activeWatcher = currentWatcher;
+          }
+        }
+      } else {
+        effect.run();
+      }
+    };
+    if (augmentJob) {
+      augmentJob(job);
+    }
+    effect = new ReactiveEffect(getter);
+    effect.scheduler = scheduler ? () => scheduler(job, false) : job;
+    boundCleanup = (fn) => onWatcherCleanup(fn, false, effect);
+    cleanup = effect.onStop = () => {
+      const cleanups = cleanupMap.get(effect);
+      if (cleanups) {
+        if (call) {
+          call(cleanups, 4);
+        } else {
+          for (const cleanup2 of cleanups) cleanup2();
+        }
+        cleanupMap.delete(effect);
+      }
+    };
+    {
+      effect.onTrack = options.onTrack;
+      effect.onTrigger = options.onTrigger;
+    }
+    if (cb) {
+      if (immediate) {
+        job(true);
+      } else {
+        oldValue = effect.run();
+      }
+    } else if (scheduler) {
+      scheduler(job.bind(null, true), true);
+    } else {
+      effect.run();
+    }
+    const scope = getCurrentScope();
+    const watchHandle = () => {
+      effect.stop();
+      if (scope) {
+        remove(scope.effects, effect);
+      }
+    };
+    watchHandle.pause = effect.pause.bind(effect);
+    watchHandle.resume = effect.resume.bind(effect);
+    watchHandle.stop = watchHandle;
+    return watchHandle;
+  }
+  function traverse(value, depth = Infinity, seen) {
+    if (depth <= 0 || !isObject(value) || value["__v_skip"]) {
+      return value;
+    }
+    seen = seen || /* @__PURE__ */ new Set();
+    if (seen.has(value)) {
+      return value;
+    }
+    seen.add(value);
+    depth--;
+    if (isRef(value)) {
+      traverse(value.value, depth, seen);
+    } else if (isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        traverse(value[i], depth, seen);
+      }
+    } else if (isSet(value) || isMap(value)) {
+      value.forEach((v) => {
+        traverse(v, depth, seen);
+      });
+    } else if (isPlainObject(value)) {
+      for (const key in value) {
+        traverse(value[key], depth, seen);
+      }
+      for (const key of Object.getOwnPropertySymbols(value)) {
+        if (Object.prototype.propertyIsEnumerable.call(value, key)) {
+          traverse(value[key], depth, seen);
+        }
+      }
+    }
+    return value;
+  }
+
   const stack = [];
   function pushWarningContext(vnode) {
     stack.push(vnode);
@@ -2067,12 +2283,6 @@ var VueRuntimeDOM = (function (exports) {
     "0": "SETUP_FUNCTION",
     "RENDER_FUNCTION": 1,
     "1": "RENDER_FUNCTION",
-    "WATCH_GETTER": 2,
-    "2": "WATCH_GETTER",
-    "WATCH_CALLBACK": 3,
-    "3": "WATCH_CALLBACK",
-    "WATCH_CLEANUP": 4,
-    "4": "WATCH_CLEANUP",
     "NATIVE_EVENT_HANDLER": 5,
     "5": "NATIVE_EVENT_HANDLER",
     "COMPONENT_EVENT_HANDLER": 6,
@@ -2224,7 +2434,7 @@ var VueRuntimeDOM = (function (exports) {
     return fn ? p.then(this ? fn.bind(this) : fn) : p;
   }
   function findInsertionIndex(id) {
-    let start = flushIndex + 1;
+    let start = isFlushing ? flushIndex + 1 : 0;
     let end = queue.length;
     while (start < end) {
       const middle = start + end >>> 1;
@@ -2240,15 +2450,13 @@ var VueRuntimeDOM = (function (exports) {
   }
   function queueJob(job) {
     if (!(job.flags & 1)) {
-      if (job.id == null) {
-        queue.push(job);
-      } else if (
-        // fast path when the job id is larger than the tail
-        !(job.flags & 2) && job.id >= (queue[queue.length - 1] && queue[queue.length - 1].id || 0)
-      ) {
+      const jobId = getId(job);
+      const lastJob = queue[queue.length - 1];
+      if (!lastJob || // fast path when the job id is larger than the tail
+      !(job.flags & 2) && jobId >= getId(lastJob)) {
         queue.push(job);
       } else {
-        queue.splice(findInsertionIndex(job.id), 0, job);
+        queue.splice(findInsertionIndex(jobId), 0, job);
       }
       if (!(job.flags & 4)) {
         job.flags |= 1;
@@ -2262,12 +2470,6 @@ var VueRuntimeDOM = (function (exports) {
       currentFlushPromise = resolvedPromise.then(flushJobs);
     }
   }
-  function invalidateJob(job) {
-    const i = queue.indexOf(job);
-    if (i > flushIndex) {
-      queue.splice(i, 1);
-    }
-  }
   function queuePostFlushCb(cb) {
     if (!isArray(cb)) {
       if (activePostFlushCbs && cb.id === -1) {
@@ -2329,24 +2531,13 @@ var VueRuntimeDOM = (function (exports) {
       postFlushIndex = 0;
     }
   }
-  const getId = (job) => job.id == null ? Infinity : job.id;
-  const comparator = (a, b) => {
-    const diff = getId(a) - getId(b);
-    if (diff === 0) {
-      const isAPre = a.flags & 2;
-      const isBPre = b.flags & 2;
-      if (isAPre && !isBPre) return -1;
-      if (isBPre && !isAPre) return 1;
-    }
-    return diff;
-  };
+  const getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
   function flushJobs(seen) {
     isFlushPending = false;
     isFlushing = true;
     {
       seen = seen || /* @__PURE__ */ new Map();
     }
-    queue.sort(comparator);
     const check = (job) => checkRecursiveUpdates(seen, job) ;
     try {
       for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
@@ -3494,6 +3685,7 @@ var VueRuntimeDOM = (function (exports) {
   const isSVGContainer = (container) => container.namespaceURI.includes("svg") && container.tagName !== "foreignObject";
   const isMathMLContainer = (container) => container.namespaceURI.includes("MathML");
   const getContainerType = (container) => {
+    if (container.nodeType !== 1) return void 0;
     if (isSVGContainer(container)) return "svg";
     if (isMathMLContainer(container)) return "mathml";
     return void 0;
@@ -4416,7 +4608,7 @@ Server rendered element contains fewer child nodes than client vdom.`
       function pruneCache(filter) {
         cache.forEach((vnode, key) => {
           const name = getComponentName(vnode.type);
-          if (name && (!filter || !filter(name))) {
+          if (name && !filter(name)) {
             pruneCacheEntry(key);
           }
         });
@@ -4535,6 +4727,7 @@ Server rendered element contains fewer child nodes than client vdom.`
     } else if (isString(pattern)) {
       return pattern.split(",").includes(name);
     } else if (isRegExp(pattern)) {
+      pattern.lastIndex = 0;
       return pattern.test(name);
     }
     return false;
@@ -5426,16 +5619,20 @@ If this is a native custom element, make sure to exclude it from component resol
     );
   }
   function createWatcher(raw, ctx, publicThis, key) {
-    const getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
+    let getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
     if (isString(raw)) {
       const handler = ctx[raw];
       if (isFunction(handler)) {
-        watch(getter, handler);
+        {
+          watch(getter, handler);
+        }
       } else {
         warn$1(`Invalid watch handler specified by key "${raw}"`, handler);
       }
     } else if (isFunction(raw)) {
-      watch(getter, raw.bind(publicThis));
+      {
+        watch(getter, raw.bind(publicThis));
+      }
     } else if (isObject(raw)) {
       if (isArray(raw)) {
         raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
@@ -6673,7 +6870,7 @@ If you want to remount the same app, move your app creation logic into a factory
         if (subTree.patchFlag > 0 && subTree.patchFlag & 2048) {
           subTree = filterSingleRoot(subTree.children) || subTree;
         }
-        if (vnode === subTree) {
+        if (vnode === subTree || isSuspense(subTree.type) && (subTree.ssContent === vnode || subTree.ssFallback === vnode)) {
           const parentVNode = parentComponent.vnode;
           setScopeId(
             el,
@@ -7002,7 +7199,6 @@ If you want to remount the same app, move your app creation logic into a factory
           return;
         } else {
           instance.next = n2;
-          invalidateJob(instance.update);
           instance.update();
         }
       } else {
@@ -7887,7 +8083,6 @@ If you want to remount the same app, move your app creation logic into a factory
       extend({}, options, { flush: "sync" }) 
     );
   }
-  const INITIAL_WATCHER_VALUE = {};
   function watch(source, cb, options) {
     if (!isFunction(cb)) {
       warn$1(
@@ -7896,21 +8091,8 @@ If you want to remount the same app, move your app creation logic into a factory
     }
     return doWatch(source, cb, options);
   }
-  function doWatch(source, cb, {
-    immediate,
-    deep,
-    flush,
-    once,
-    onTrack,
-    onTrigger
-  } = EMPTY_OBJ) {
-    if (cb && once) {
-      const _cb = cb;
-      cb = (...args) => {
-        _cb(...args);
-        watchHandle();
-      };
-    }
+  function doWatch(source, cb, options = EMPTY_OBJ) {
+    const { immediate, deep, flush, once } = options;
     if (!cb) {
       if (immediate !== void 0) {
         warn$1(
@@ -7928,140 +8110,38 @@ If you want to remount the same app, move your app creation logic into a factory
         );
       }
     }
-    const warnInvalidSource = (s) => {
-      warn$1(
-        `Invalid watch source: `,
-        s,
-        `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`
-      );
-    };
+    const baseWatchOptions = extend({}, options);
+    baseWatchOptions.onWarn = warn$1;
     const instance = currentInstance;
-    const reactiveGetter = (source2) => {
-      if (deep) return source2;
-      if (isShallow(source2) || deep === false || deep === 0)
-        return traverse(source2, 1);
-      return traverse(source2);
-    };
-    let getter;
-    let forceTrigger = false;
-    let isMultiSource = false;
-    if (isRef(source)) {
-      getter = () => source.value;
-      forceTrigger = isShallow(source);
-    } else if (isReactive(source)) {
-      getter = () => reactiveGetter(source);
-      forceTrigger = true;
-    } else if (isArray(source)) {
-      isMultiSource = true;
-      forceTrigger = source.some((s) => isReactive(s) || isShallow(s));
-      getter = () => source.map((s) => {
-        if (isRef(s)) {
-          return s.value;
-        } else if (isReactive(s)) {
-          return reactiveGetter(s);
-        } else if (isFunction(s)) {
-          return callWithErrorHandling(s, instance, 2);
+    baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args);
+    let isPre = false;
+    if (flush === "post") {
+      baseWatchOptions.scheduler = (job) => {
+        queuePostRenderEffect(job, instance && instance.suspense);
+      };
+    } else if (flush !== "sync") {
+      isPre = true;
+      baseWatchOptions.scheduler = (job, isFirstRun) => {
+        if (isFirstRun) {
+          job();
         } else {
-          warnInvalidSource(s);
+          queueJob(job);
         }
-      });
-    } else if (isFunction(source)) {
-      if (cb) {
-        getter = () => callWithErrorHandling(source, instance, 2);
-      } else {
-        getter = () => {
-          if (cleanup) {
-            cleanup();
-          }
-          return callWithAsyncErrorHandling(
-            source,
-            instance,
-            3,
-            [onCleanup]
-          );
-        };
-      }
-    } else {
-      getter = NOOP;
-      warnInvalidSource(source);
-    }
-    if (cb && deep) {
-      const baseGetter = getter;
-      const depth = deep === true ? Infinity : deep;
-      getter = () => traverse(baseGetter(), depth);
-    }
-    let cleanup;
-    let onCleanup = (fn) => {
-      cleanup = effect.onStop = () => {
-        callWithErrorHandling(fn, instance, 4);
-        cleanup = effect.onStop = void 0;
       };
-    };
-    let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
-    const job = (immediateFirstRun) => {
-      if (!(effect.flags & 1) || !effect.dirty && !immediateFirstRun) {
-        return;
-      }
+    }
+    baseWatchOptions.augmentJob = (job) => {
       if (cb) {
-        const newValue = effect.run();
-        if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue)) || false) {
-          if (cleanup) {
-            cleanup();
-          }
-          callWithAsyncErrorHandling(cb, instance, 3, [
-            newValue,
-            // pass undefined as the old value when it's changed for the first time
-            oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
-            onCleanup
-          ]);
-          oldValue = newValue;
-        }
-      } else {
-        effect.run();
+        job.flags |= 4;
       }
-    };
-    if (cb) job.flags |= 4;
-    const effect = new ReactiveEffect(getter);
-    let scheduler;
-    if (flush === "sync") {
-      effect.flags |= 64;
-      scheduler = job;
-    } else if (flush === "post") {
-      scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);
-    } else {
-      job.flags |= 2;
-      if (instance) job.id = instance.uid;
-      scheduler = () => queueJob(job);
-    }
-    effect.scheduler = scheduler;
-    const scope = getCurrentScope();
-    const watchHandle = () => {
-      effect.stop();
-      if (scope) {
-        remove(scope.effects, effect);
+      if (isPre) {
+        job.flags |= 2;
+        if (instance) {
+          job.id = instance.uid;
+          job.i = instance;
+        }
       }
     };
-    watchHandle.pause = effect.pause.bind(effect);
-    watchHandle.resume = effect.resume.bind(effect);
-    watchHandle.stop = watchHandle;
-    {
-      effect.onTrack = onTrack;
-      effect.onTrigger = onTrigger;
-    }
-    if (cb) {
-      if (immediate) {
-        job(true);
-      } else {
-        oldValue = effect.run();
-      }
-    } else if (flush === "post") {
-      queuePostRenderEffect(
-        effect.run.bind(effect),
-        instance && instance.suspense
-      );
-    } else {
-      effect.run();
-    }
+    const watchHandle = watch$1(source, cb, baseWatchOptions);
     return watchHandle;
   }
   function instanceWatch(source, value, options) {
@@ -8089,38 +8169,6 @@ If you want to remount the same app, move your app creation logic into a factory
       return cur;
     };
   }
-  function traverse(value, depth = Infinity, seen) {
-    if (depth <= 0 || !isObject(value) || value["__v_skip"]) {
-      return value;
-    }
-    seen = seen || /* @__PURE__ */ new Set();
-    if (seen.has(value)) {
-      return value;
-    }
-    seen.add(value);
-    depth--;
-    if (isRef(value)) {
-      traverse(value.value, depth, seen);
-    } else if (isArray(value)) {
-      for (let i = 0; i < value.length; i++) {
-        traverse(value[i], depth, seen);
-      }
-    } else if (isSet(value) || isMap(value)) {
-      value.forEach((v) => {
-        traverse(v, depth, seen);
-      });
-    } else if (isPlainObject(value)) {
-      for (const key in value) {
-        traverse(value[key], depth, seen);
-      }
-      for (const key of Object.getOwnPropertySymbols(value)) {
-        if (Object.prototype.propertyIsEnumerable.call(value, key)) {
-          traverse(value[key], depth, seen);
-        }
-      }
-    }
-    return value;
-  }
 
   function useModel(props, name, options = EMPTY_OBJ) {
     const i = getCurrentInstance();
@@ -10254,7 +10302,7 @@ Component that was made reactive: `,
     return true;
   }
 
-  const version = "3.5.0-beta.1";
+  const version = "3.5.0-beta.3";
   const warn = warn$1 ;
   const ErrorTypeStrings = ErrorTypeStrings$1 ;
   const devtools = devtools$1 ;
@@ -11106,7 +11154,6 @@ Expected function or array of functions, received type ${typeof value}.`
       this._ob = null;
       if (this.shadowRoot && _createApp !== createApp) {
         this._root = this.shadowRoot;
-        this._mount(_def);
       } else {
         if (this.shadowRoot) {
           warn(
@@ -11119,9 +11166,9 @@ Expected function or array of functions, received type ${typeof value}.`
         } else {
           this._root = this;
         }
-        if (!this._def.__asyncLoader) {
-          this._resolveProps(this._def);
-        }
+      }
+      if (!this._def.__asyncLoader) {
+        this._resolveProps(this._def);
       }
     }
     connectedCallback() {
@@ -11321,6 +11368,7 @@ Expected function or array of functions, received type ${typeof value}.`
         vnode.ce = (instance) => {
           this._instance = instance;
           instance.ce = this;
+          instance.isCE = true;
           {
             instance.ceReload = (newStyles) => {
               if (this._styles) {
@@ -12079,6 +12127,7 @@ Expected function or array of functions, received type ${typeof value}.`
   exports.effectScope = effectScope;
   exports.getCurrentInstance = getCurrentInstance;
   exports.getCurrentScope = getCurrentScope;
+  exports.getCurrentWatcher = getCurrentWatcher;
   exports.getTransitionRawChildren = getTransitionRawChildren;
   exports.guardReactiveProps = guardReactiveProps;
   exports.h = h;
@@ -12121,6 +12170,7 @@ Expected function or array of functions, received type ${typeof value}.`
   exports.onServerPrefetch = onServerPrefetch;
   exports.onUnmounted = onUnmounted;
   exports.onUpdated = onUpdated;
+  exports.onWatcherCleanup = onWatcherCleanup;
   exports.openBlock = openBlock;
   exports.popScopeId = popScopeId;
   exports.provide = provide;