@vue/runtime-core 3.5.0-beta.2 → 3.5.0-rc.1

package/dist/runtime-core.cjs.prod.js

@@ -1,5 +1,5 @@
 /**
-* @vue/runtime-core v3.5.0-beta.2
+* @vue/runtime-core v3.5.0-rc.1
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -19,12 +19,6 @@ const ErrorCodes = {
   "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,
@@ -161,7 +155,7 @@ function nextTick(fn) {
   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;
@@ -177,15 +171,13 @@ function findInsertionIndex(id) {
 }
 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;
@@ -199,12 +191,6 @@ function queueFlush() {
     currentFlushPromise = resolvedPromise.then(flushJobs);
   }
 }
-function invalidateJob(job) {
-  const i = queue.indexOf(job);
-  if (i > flushIndex) {
-    queue.splice(i, 1);
-  }
-}
 function queuePostFlushCb(cb) {
   if (!shared.isArray(cb)) {
     if (activePostFlushCbs && cb.id === -1) {
@@ -254,21 +240,10 @@ function flushPostFlushCbs(seen) {
     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;
-  queue.sort(comparator);
   try {
     for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
       const job = queue[flushIndex];
@@ -352,7 +327,7 @@ function withDirectives(vnode, directives) {
         };
       }
       if (dir.deep) {
-        traverse(value);
+        reactivity.traverse(value);
       }
       bindings.push({
         dir,
@@ -1013,7 +988,7 @@ function getTransitionRawChildren(children, keepComment = false, parentKey) {
 // @__NO_SIDE_EFFECTS__
 function defineComponent(options, extraOptions) {
   return shared.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__ */ (() => shared.extend({ name: options.name }, extraOptions, { setup: options }))()
   ) : options;
@@ -1941,6 +1916,7 @@ const KeepAliveImpl = {
       );
       const { include, exclude, max } = props;
       if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) {
+        vnode.shapeFlag &= ~256;
         current = vnode;
         return rawVNode;
       }
@@ -2642,14 +2618,18 @@ function callHook(hook, instance, type) {
   );
 }
 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 (shared.isString(raw)) {
     const handler = ctx[raw];
     if (shared.isFunction(handler)) {
-      watch(getter, handler);
+      {
+        watch(getter, handler);
+      }
     }
   } else if (shared.isFunction(raw)) {
-    watch(getter, raw.bind(publicThis));
+    {
+      watch(getter, raw.bind(publicThis));
+    }
   } else if (shared.isObject(raw)) {
     if (shared.isArray(raw)) {
       raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
@@ -3583,7 +3563,7 @@ function baseCreateRenderer(options, createHydrationFns) {
     }
     if (parentComponent) {
       let subTree = parentComponent.subTree;
-      if (vnode === subTree) {
+      if (vnode === subTree || isSuspense(subTree.type) && (subTree.ssContent === vnode || subTree.ssFallback === vnode)) {
         const parentVNode = parentComponent.vnode;
         setScopeId(
           el,
@@ -3881,7 +3861,6 @@ function baseCreateRenderer(options, createHydrationFns) {
         return;
       } else {
         instance.next = n2;
-        invalidateJob(instance.update);
         instance.update();
       }
     } else {
@@ -4691,168 +4670,57 @@ function watchSyncEffect(effect, options) {
     { flush: "sync" }
   );
 }
-const INITIAL_WATCHER_VALUE = {};
 function watch(source, cb, options) {
   return doWatch(source, cb, options);
 }
-function doWatch(source, cb, {
-  immediate,
-  deep,
-  flush,
-  once,
-  onTrack,
-  onTrigger
-} = shared.EMPTY_OBJ) {
-  if (cb && once) {
-    const _cb = cb;
-    cb = (...args) => {
-      _cb(...args);
-      watchHandle();
-    };
-  }
-  const instance = currentInstance;
-  const reactiveGetter = (source2) => {
-    if (deep) return source2;
-    if (reactivity.isShallow(source2) || deep === false || deep === 0)
-      return traverse(source2, 1);
-    return traverse(source2);
-  };
-  let getter;
-  let forceTrigger = false;
-  let isMultiSource = false;
-  if (reactivity.isRef(source)) {
-    getter = () => source.value;
-    forceTrigger = reactivity.isShallow(source);
-  } else if (reactivity.isReactive(source)) {
-    getter = () => reactiveGetter(source);
-    forceTrigger = true;
-  } else if (shared.isArray(source)) {
-    isMultiSource = true;
-    forceTrigger = source.some((s) => reactivity.isReactive(s) || reactivity.isShallow(s));
-    getter = () => source.map((s) => {
-      if (reactivity.isRef(s)) {
-        return s.value;
-      } else if (reactivity.isReactive(s)) {
-        return reactiveGetter(s);
-      } else if (shared.isFunction(s)) {
-        return callWithErrorHandling(s, instance, 2);
-      } else ;
-    });
-  } else if (shared.isFunction(source)) {
-    if (cb) {
-      getter = () => callWithErrorHandling(source, instance, 2);
-    } else {
-      getter = () => {
-        if (cleanup) {
-          cleanup();
-        }
-        return callWithAsyncErrorHandling(
-          source,
-          instance,
-          3,
-          [onCleanup]
-        );
-      };
-    }
-  } else {
-    getter = shared.NOOP;
-  }
-  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;
-    };
-  };
+function doWatch(source, cb, options = shared.EMPTY_OBJ) {
+  const { immediate, deep, flush, once } = options;
+  const baseWatchOptions = shared.extend({}, options);
   let ssrCleanup;
   if (isInSSRComponentSetup) {
-    onCleanup = shared.NOOP;
-    if (!cb) {
-      getter();
-    } else if (immediate) {
-      callWithAsyncErrorHandling(cb, instance, 3, [
-        getter(),
-        isMultiSource ? [] : void 0,
-        onCleanup
-      ]);
-    }
     if (flush === "sync") {
       const ctx = useSSRContext();
       ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
+    } else if (!cb || immediate) {
+      baseWatchOptions.once = true;
     } else {
-      const watchHandle2 = () => {
+      return {
+        stop: shared.NOOP,
+        resume: shared.NOOP,
+        pause: shared.NOOP
       };
-      watchHandle2.stop = shared.NOOP;
-      watchHandle2.resume = shared.NOOP;
-      watchHandle2.pause = shared.NOOP;
-      return watchHandle2;
     }
   }
-  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) => shared.hasChanged(v, oldValue[i])) : shared.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;
+  const instance = currentInstance;
+  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 {
+        queueJob(job);
       }
-    } else {
-      effect.run();
-    }
-  };
-  if (cb) job.flags |= 4;
-  const effect = new reactivity.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 = reactivity.getCurrentScope();
-  const watchHandle = () => {
-    effect.stop();
-    if (scope) {
-      shared.remove(scope.effects, effect);
+  baseWatchOptions.augmentJob = (job) => {
+    if (cb) {
+      job.flags |= 4;
     }
-  };
-  watchHandle.pause = effect.pause.bind(effect);
-  watchHandle.resume = effect.resume.bind(effect);
-  watchHandle.stop = watchHandle;
-  if (cb) {
-    if (immediate) {
-      job(true);
-    } else {
-      oldValue = effect.run();
+    if (isPre) {
+      job.flags |= 2;
+      if (instance) {
+        job.id = instance.uid;
+        job.i = instance;
+      }
     }
-  } else if (flush === "post") {
-    queuePostRenderEffect(
-      effect.run.bind(effect),
-      instance && instance.suspense
-    );
-  } else {
-    effect.run();
-  }
+  };
+  const watchHandle = reactivity.watch(source, cb, baseWatchOptions);
   if (ssrCleanup) ssrCleanup.push(watchHandle);
   return watchHandle;
 }
@@ -4881,38 +4749,6 @@ function createPathGetter(ctx, path) {
     return cur;
   };
 }
-function traverse(value, depth = Infinity, seen) {
-  if (depth <= 0 || !shared.isObject(value) || value["__v_skip"]) {
-    return value;
-  }
-  seen = seen || /* @__PURE__ */ new Set();
-  if (seen.has(value)) {
-    return value;
-  }
-  seen.add(value);
-  depth--;
-  if (reactivity.isRef(value)) {
-    traverse(value.value, depth, seen);
-  } else if (shared.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      traverse(value[i], depth, seen);
-    }
-  } else if (shared.isSet(value) || shared.isMap(value)) {
-    value.forEach((v) => {
-      traverse(v, depth, seen);
-    });
-  } else if (shared.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 = shared.EMPTY_OBJ) {
   const i = getCurrentInstance();
@@ -6540,7 +6376,7 @@ function isMemoSame(cached, memo) {
   return true;
 }
 
-const version = "3.5.0-beta.2";
+const version = "3.5.0-rc.1";
 const warn$1 = shared.NOOP;
 const ErrorTypeStrings = ErrorTypeStrings$1 ;
 const devtools = void 0;
@@ -6568,6 +6404,7 @@ exports.customRef = reactivity.customRef;
 exports.effect = reactivity.effect;
 exports.effectScope = reactivity.effectScope;
 exports.getCurrentScope = reactivity.getCurrentScope;
+exports.getCurrentWatcher = reactivity.getCurrentWatcher;
 exports.isProxy = reactivity.isProxy;
 exports.isReactive = reactivity.isReactive;
 exports.isReadonly = reactivity.isReadonly;
@@ -6575,6 +6412,7 @@ exports.isRef = reactivity.isRef;
 exports.isShallow = reactivity.isShallow;
 exports.markRaw = reactivity.markRaw;
 exports.onScopeDispose = reactivity.onScopeDispose;
+exports.onWatcherCleanup = reactivity.onWatcherCleanup;
 exports.proxyRefs = reactivity.proxyRefs;
 exports.reactive = reactivity.reactive;
 exports.readonly = reactivity.readonly;

package/dist/runtime-core.d.ts

@@ -1,5 +1,5 @@
-import { computed as computed$1, Ref, ShallowUnwrapRef, UnwrapNestedRefs, DebuggerEvent, ComputedGetter, WritableComputedOptions, ReactiveEffect, ComputedRef, DebuggerOptions, ReactiveMarker, ShallowRef, reactive } from '@vue/reactivity';
-export { ComputedGetter, ComputedRef, ComputedSetter, CustomRefFactory, DebuggerEvent, DebuggerEventExtraInfo, DebuggerOptions, DeepReadonly, EffectScheduler, EffectScope, MaybeRef, MaybeRefOrGetter, Raw, Reactive, ReactiveEffect, ReactiveEffectOptions, ReactiveEffectRunner, ReactiveFlags, Ref, ShallowReactive, ShallowRef, ShallowUnwrapRef, ToRef, ToRefs, TrackOpTypes, TriggerOpTypes, UnwrapNestedRefs, UnwrapRef, WritableComputedOptions, WritableComputedRef, customRef, effect, effectScope, getCurrentScope, isProxy, isReactive, isReadonly, isRef, isShallow, markRaw, onScopeDispose, proxyRefs, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, toValue, triggerRef, unref } from '@vue/reactivity';
+import { computed as computed$1, Ref, OnCleanup, WatchStopHandle, ShallowUnwrapRef, UnwrapNestedRefs, DebuggerEvent, ComputedGetter, WritableComputedOptions, WatchCallback, ReactiveEffect, DebuggerOptions, WatchEffect, WatchHandle, WatchSource, ReactiveMarker, ShallowRef, WatchErrorCodes, reactive } from '@vue/reactivity';
+export { ComputedGetter, ComputedRef, ComputedSetter, CustomRefFactory, DebuggerEvent, DebuggerEventExtraInfo, DebuggerOptions, DeepReadonly, EffectScheduler, EffectScope, MaybeRef, MaybeRefOrGetter, Raw, Reactive, ReactiveEffect, ReactiveEffectOptions, ReactiveEffectRunner, ReactiveFlags, Ref, ShallowReactive, ShallowRef, ShallowUnwrapRef, ToRef, ToRefs, TrackOpTypes, TriggerOpTypes, UnwrapNestedRefs, UnwrapRef, WatchCallback, WatchEffect, WatchHandle, WatchSource, WatchStopHandle, WritableComputedOptions, WritableComputedRef, 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 { IfAny, Prettify, Awaited, LooseRequired, UnionToIntersection, OverloadParameters } from '@vue/shared';
 export { camelize, capitalize, normalizeClass, normalizeProps, normalizeStyle, toDisplayString, toHandlerKey } from '@vue/shared';
 
@@ -334,7 +334,7 @@ type InferDefaults<T> = {
 type NativeType = null | number | string | boolean | symbol | Function;
 type InferDefault<P, T> = ((props: P) => T & {}) | (T extends NativeType ? T : never);
 type PropsWithDefaults<T, Defaults extends InferDefaults<T>, BKeys extends keyof T> = Readonly<MappedOmit<T, keyof Defaults>> & {
-    readonly [K in keyof Defaults]-?: K extends keyof T ? Defaults[K] extends undefined ? IfAny<Defaults[K], NotUndefined<T[K]>, T[K]> : NotUndefined<T[K]> : never;
+    readonly [K in keyof Defaults as K extends keyof T ? K : never]-?: K extends keyof T ? Defaults[K] extends undefined ? IfAny<Defaults[K], NotUndefined<T[K]>, T[K]> : NotUndefined<T[K]> : never;
 } & {
     readonly [K in BKeys]-?: K extends keyof Defaults ? Defaults[K] extends undefined ? boolean | undefined : boolean : boolean;
 };
@@ -367,7 +367,7 @@ export type EmitsOptions = ObjectEmitsOptions | string[];
 export type EmitsToProps<T extends EmitsOptions | ComponentTypeEmits> = T extends string[] ? {
     [K in `on${Capitalize<T[number]>}`]?: (...args: any[]) => any;
 } : T extends ObjectEmitsOptions ? {
-    [K in `on${Capitalize<string & keyof T>}`]?: K extends `on${infer C}` ? (...args: T[Uncapitalize<C>] extends (...args: infer P) => any ? P : T[Uncapitalize<C>] extends null ? any[] : never) => any : never;
+    [K in string & keyof T as `on${Capitalize<K>}`]?: (...args: T[K] extends (...args: infer P) => any ? P : T[K] extends null ? any[] : never) => any;
 } : {};
 type TypeEmitsToOptions<T extends ComponentTypeEmits> = T extends Record<string, any[]> ? {
     [K in keyof T]: T[K] extends [...args: infer Args] ? (...args: Args) => any : () => any;
@@ -1334,7 +1334,7 @@ export interface ComponentCustomProps {
  * }
  * ```
  */
-export interface GlobalDirectives extends Record<string, Directive> {
+export interface GlobalDirectives {
 }
 /**
  * For globally defined Components
@@ -1351,7 +1351,7 @@ export interface GlobalDirectives extends Record<string, Directive> {
  * }
  * ```
  */
-export interface GlobalComponents extends Record<string, Component> {
+export interface GlobalComponents {
     Teleport: DefineComponent<TeleportProps>;
     Suspense: DefineComponent<SuspenseProps>;
     KeepAlive: DefineComponent<KeepAliveProps>;
@@ -1463,31 +1463,21 @@ export declare const isRuntimeOnly: () => boolean;
 export interface ComponentCustomElementInterface {
 }
 
-export type WatchEffect = (onCleanup: OnCleanup) => void;
-export type WatchSource<T = any> = Ref<T, any> | ComputedRef<T> | (() => T);
-export type WatchCallback<V = any, OV = any> = (value: V, oldValue: OV, onCleanup: OnCleanup) => any;
 type MaybeUndefined<T, I> = I extends true ? T | undefined : T;
 type MapSources<T, Immediate> = {
     [K in keyof T]: T[K] extends WatchSource<infer V> ? MaybeUndefined<V, Immediate> : T[K] extends object ? MaybeUndefined<T[K], Immediate> : never;
 };
-type OnCleanup = (cleanupFn: () => void) => void;
-export interface WatchOptionsBase extends DebuggerOptions {
+export interface WatchEffectOptions extends DebuggerOptions {
     flush?: 'pre' | 'post' | 'sync';
 }
-export interface WatchOptions<Immediate = boolean> extends WatchOptionsBase {
+export interface WatchOptions<Immediate = boolean> extends WatchEffectOptions {
     immediate?: Immediate;
     deep?: boolean | number;
     once?: boolean;
 }
-export type WatchStopHandle = () => void;
-export interface WatchHandle extends WatchStopHandle {
-    pause: () => void;
-    resume: () => void;
-    stop: () => void;
-}
-export declare function watchEffect(effect: WatchEffect, options?: WatchOptionsBase): WatchHandle;
-export declare function watchPostEffect(effect: WatchEffect, options?: DebuggerOptions): WatchStopHandle;
-export declare function watchSyncEffect(effect: WatchEffect, options?: DebuggerOptions): WatchStopHandle;
+export declare function watchEffect(effect: WatchEffect, options?: WatchEffectOptions): WatchHandle;
+export declare function watchPostEffect(effect: WatchEffect, options?: DebuggerOptions): WatchHandle;
+export declare function watchSyncEffect(effect: WatchEffect, options?: DebuggerOptions): WatchHandle;
 export type MultiWatchSources = (WatchSource<unknown> | object)[];
 export declare function watch<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, MaybeUndefined<T, Immediate>>, options?: WatchOptions<Immediate>): WatchHandle;
 export declare function watch<T extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: readonly [...T] | T, cb: [T] extends [ReactiveMarker] ? WatchCallback<T, MaybeUndefined<T, Immediate>> : WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>, options?: WatchOptions<Immediate>): WatchHandle;
@@ -1583,9 +1573,6 @@ declare function warn$1(msg: string, ...args: any[]): void;
 export declare enum ErrorCodes {
     SETUP_FUNCTION = 0,
     RENDER_FUNCTION = 1,
-    WATCH_GETTER = 2,
-    WATCH_CALLBACK = 3,
-    WATCH_CLEANUP = 4,
     NATIVE_EVENT_HANDLER = 5,
     COMPONENT_EVENT_HANDLER = 6,
     VNODE_HOOK = 7,
@@ -1599,7 +1586,7 @@ export declare enum ErrorCodes {
     COMPONENT_UPDATE = 15,
     APP_UNMOUNT_CLEANUP = 16
 }
-type ErrorTypes = LifecycleHooks | ErrorCodes;
+type ErrorTypes = LifecycleHooks | ErrorCodes | WatchErrorCodes;
 export declare function callWithErrorHandling(fn: Function, instance: ComponentInternalInstance | null | undefined, type: ErrorTypes, args?: unknown[]): any;
 export declare function callWithAsyncErrorHandling(fn: Function | Function[], instance: ComponentInternalInstance | null, type: ErrorTypes, args?: unknown[]): any;
 export declare function handleError(err: unknown, instance: ComponentInternalInstance | null | undefined, type: ErrorTypes, throwInDev?: boolean): void;
@@ -1807,7 +1794,7 @@ declare module '@vue/reactivity' {
 
 export declare const DeprecationTypes: typeof DeprecationTypes$1;
 
-export { createBaseVNode as createElementVNode,  };
+export { type WatchEffectOptions as WatchOptionsBase, createBaseVNode as createElementVNode,  };
 // Note: this file is auto concatenated to the end of the bundled d.ts during
 // build.