@vue/compat 3.5.0-beta.2 → 3.5.0-rc.1

package/dist/vue.runtime.global.js

@@ -1,5 +1,5 @@
 /**
-* @vue/compat v3.5.0-beta.2
+* @vue/compat v3.5.0-rc.1
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -340,12 +340,13 @@ var Vue = (function () {
     pause() {
       if (this._active) {
         this._isPaused = true;
+        let i, l;
         if (this.scopes) {
-          for (let i = 0, l = this.scopes.length; i < l; i++) {
+          for (i = 0, l = this.scopes.length; i < l; i++) {
             this.scopes[i].pause();
           }
         }
-        for (let i = 0, l = this.effects.length; i < l; i++) {
+        for (i = 0, l = this.effects.length; i < l; i++) {
           this.effects[i].pause();
         }
       }
@@ -357,12 +358,13 @@ var Vue = (function () {
       if (this._active) {
         if (this._isPaused) {
           this._isPaused = false;
+          let i, l;
           if (this.scopes) {
-            for (let i = 0, l = this.scopes.length; i < l; i++) {
+            for (i = 0, l = this.scopes.length; i < l; i++) {
               this.scopes[i].resume();
             }
           }
-          for (let i = 0, l = this.effects.length; i < l; i++) {
+          for (i = 0, l = this.effects.length; i < l; i++) {
             this.effects[i].resume();
           }
         }
@@ -555,11 +557,9 @@ var Vue = (function () {
     batchDepth++;
   }
   function endBatch() {
-    if (batchDepth > 1) {
-      batchDepth--;
+    if (--batchDepth > 0) {
       return;
     }
-    batchDepth--;
     let error;
     while (batchedEffect) {
       let e = batchedEffect;
@@ -1073,14 +1073,14 @@ var Vue = (function () {
   const arrayProto = Array.prototype;
   function apply(self, method, fn, thisArg, wrappedRetFn, args) {
     const arr = shallowReadArray(self);
-    let methodFn;
-    if ((methodFn = arr[method]) !== arrayProto[method]) {
-      return methodFn.apply(arr, args);
+    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 needsWrap = false;
     let wrappedFn = fn;
     if (arr !== self) {
-      needsWrap = !isShallow(self);
       if (needsWrap) {
         wrappedFn = function(item, index) {
           return fn.call(this, toReactive(item), index, self);
@@ -1218,7 +1218,12 @@ var Vue = (function () {
         }
       }
       const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
-      const result = Reflect.set(target, key, value, receiver);
+      const result = Reflect.set(
+        target,
+        key,
+        value,
+        isRef(target) ? target : receiver
+      );
       if (target === toRaw(receiver)) {
         if (!hadKey) {
           trigger(target, "add", key, value);
@@ -1942,6 +1947,220 @@ var Vue = (function () {
     "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);
+    }
+    const scope = getCurrentScope();
+    const watchHandle = () => {
+      effect.stop();
+      if (scope) {
+        remove(scope.effects, effect);
+      }
+    };
+    if (once) {
+      if (cb) {
+        const _cb = cb;
+        cb = (...args) => {
+          _cb(...args);
+          watchHandle();
+        };
+      } else {
+        const _getter = getter;
+        getter = () => {
+          _getter();
+          watchHandle();
+        };
+      }
+    }
+    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();
+    }
+    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);
@@ -2069,12 +2288,6 @@ var Vue = (function () {
     "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,
@@ -2226,7 +2439,7 @@ var Vue = (function () {
     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;
@@ -2242,15 +2455,13 @@ var Vue = (function () {
   }
   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;
@@ -2264,12 +2475,6 @@ var Vue = (function () {
       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) {
@@ -2331,24 +2536,13 @@ var Vue = (function () {
       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++) {
@@ -2989,7 +3183,7 @@ Details: https://v3-migration.vuejs.org/breaking-changes/migration-build.html`
   function once(instance, event, fn) {
     const wrapped = (...args) => {
       off(instance, event, wrapped);
-      fn.call(instance.proxy, ...args);
+      fn.apply(instance.proxy, args);
     };
     wrapped.fn = fn;
     on(instance, event, wrapped);
@@ -3908,7 +4102,7 @@ Details: https://v3-migration.vuejs.org/breaking-changes/migration-build.html`
   // @__NO_SIDE_EFFECTS__
   function defineComponent(options, extraOptions) {
     return isFunction(options) ? (
-      // #8326: extend call and options.name access are considered side-effects
+      // #8236: extend call and options.name access are considered side-effects
       // by Rollup, so we have to wrap it in a pure-annotated IIFE.
       /* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))()
     ) : options;
@@ -5029,6 +5223,7 @@ Server rendered element contains fewer child nodes than client vdom.`
         );
         const { include, exclude, max } = props;
         if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) {
+          vnode.shapeFlag &= ~256;
           current = vnode;
           return rawVNode;
         }
@@ -6514,23 +6709,43 @@ 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];
+    const options = {};
+    {
+      const instance = currentInstance && getCurrentScope() === currentInstance.scope ? currentInstance : null;
+      const newValue = getter();
+      if (isArray(newValue) && isCompatEnabled("WATCH_ARRAY", instance)) {
+        options.deep = true;
+      }
+      const baseGetter = getter;
+      getter = () => {
+        const val = baseGetter();
+        if (isArray(val) && checkCompatEnabled("WATCH_ARRAY", instance)) {
+          traverse(val);
+        }
+        return val;
+      };
+    }
     if (isString(raw)) {
       const handler = ctx[raw];
       if (isFunction(handler)) {
-        watch(getter, handler);
+        {
+          watch(getter, handler, options);
+        }
       } 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), options);
+      }
     } else if (isObject(raw)) {
       if (isArray(raw)) {
         raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
       } else {
         const handler = isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
         if (isFunction(handler)) {
-          watch(getter, handler, raw);
+          watch(getter, handler, extend(raw, options) );
         } else {
           warn$1(`Invalid watch handler specified by key "${raw.handler}"`, handler);
         }
@@ -6754,7 +6969,7 @@ If this is a native custom element, make sure to exclude it from component resol
         return vm;
       }
     }
-    Vue.version = `2.6.14-compat:${"3.5.0-beta.2"}`;
+    Vue.version = `2.6.14-compat:${"3.5.0-rc.1"}`;
     Vue.config = singletonApp.config;
     Vue.use = (plugin, ...options) => {
       if (plugin && isFunction(plugin.install)) {
@@ -7086,7 +7301,7 @@ If this is a native custom element, make sure to exclude it from component resol
       if (isArray(val)) {
         methodsToPatch.forEach((m) => {
           val[m] = (...args) => {
-            Array.prototype[m].call(reactiveVal, ...args);
+            Array.prototype[m].apply(reactiveVal, args);
           };
         });
       } else {
@@ -8281,7 +8496,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,
@@ -8611,7 +8826,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 {
@@ -9529,7 +9743,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(
@@ -9538,21 +9751,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(
@@ -9570,149 +9770,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);
-        }
-      });
-    } 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;
-      getter = () => {
-        const val = baseGetter();
-        if (isArray(val) && checkCompatEnabled("WATCH_ARRAY", instance)) {
-          traverse(val);
+          queueJob(job);
         }
-        return val;
       };
     }
-    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)) || isArray(newValue) && isCompatEnabled("WATCH_ARRAY", instance)) {
-          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") {
-      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) {
@@ -9740,38 +9829,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();
@@ -12012,7 +12069,7 @@ Component that was made reactive: `,
     return true;
   }
 
-  const version = "3.5.0-beta.2";
+  const version = "3.5.0-rc.1";
   const warn = warn$1 ;
   const ErrorTypeStrings = ErrorTypeStrings$1 ;
   const devtools = devtools$1 ;
@@ -12694,8 +12751,9 @@ Component that was made reactive: `,
 
   function patchDOMProp(el, key, value, parentComponent) {
     if (key === "innerHTML" || key === "textContent") {
-      if (value == null) return;
-      el[key] = value;
+      if (value != null) {
+        el[key] = key === "innerHTML" ? unsafeToTrustedHTML(value) : value;
+      }
       return;
     }
     const tag = el.tagName;
@@ -13138,6 +13196,9 @@ Expected function or array of functions, received type ${typeof value}.`
           delete this._props[key];
         } else {
           this._props[key] = val;
+          if (key === "key" && this._app) {
+            this._app._ceVNode.key = val;
+          }
         }
         if (shouldUpdate && this._instance) {
           this._update();
@@ -13984,6 +14045,7 @@ Expected function or array of functions, received type ${typeof value}.`
     effectScope: effectScope,
     getCurrentInstance: getCurrentInstance,
     getCurrentScope: getCurrentScope,
+    getCurrentWatcher: getCurrentWatcher,
     getTransitionRawChildren: getTransitionRawChildren,
     guardReactiveProps: guardReactiveProps,
     h: h,
@@ -14026,6 +14088,7 @@ Expected function or array of functions, received type ${typeof value}.`
     onServerPrefetch: onServerPrefetch,
     onUnmounted: onUnmounted,
     onUpdated: onUpdated,
+    onWatcherCleanup: onWatcherCleanup,
     openBlock: openBlock,
     popScopeId: popScopeId,
     provide: provide,