@vueuse/shared 11.2.0 → 12.0.0-beta.1

package/index.cjs

@@ -1,32 +1,32 @@
 'use strict';
 
-var vueDemi = require('vue-demi');
+var vue = require('vue');
 
 function computedEager(fn, options) {
   var _a;
-  const result = vueDemi.shallowRef();
-  vueDemi.watchEffect(() => {
+  const result = vue.shallowRef();
+  vue.watchEffect(() => {
     result.value = fn();
   }, {
     ...options,
     flush: (_a = options == null ? void 0 : options.flush) != null ? _a : "sync"
   });
-  return vueDemi.readonly(result);
+  return vue.readonly(result);
 }
 
 function computedWithControl(source, fn) {
   let v = void 0;
   let track;
   let trigger;
-  const dirty = vueDemi.ref(true);
+  const dirty = vue.ref(true);
   const update = () => {
     dirty.value = true;
     trigger();
   };
-  vueDemi.watch(source, update, { flush: "sync" });
+  vue.watch(source, update, { flush: "sync" });
   const get = typeof fn === "function" ? fn : fn.get;
   const set = typeof fn === "function" ? void 0 : fn.set;
-  const result = vueDemi.customRef((_track, _trigger) => {
+  const result = vue.customRef((_track, _trigger) => {
     track = _track;
     trigger = _trigger;
     return {
@@ -49,8 +49,8 @@ function computedWithControl(source, fn) {
 }
 
 function tryOnScopeDispose(fn) {
-  if (vueDemi.getCurrentScope()) {
-    vueDemi.onScopeDispose(fn);
+  if (vue.getCurrentScope()) {
+    vue.onScopeDispose(fn);
     return true;
   }
   return false;
@@ -82,7 +82,7 @@ function createEventHook() {
 function createGlobalState(stateFactory) {
   let initialized = false;
   let state;
-  const scope = vueDemi.effectScope(true);
+  const scope = vue.effectScope(true);
   return (...args) => {
     if (!initialized) {
       state = scope.run(() => stateFactory(...args));
@@ -97,24 +97,24 @@ const localProvidedStateMap = /* @__PURE__ */ new WeakMap();
 const injectLocal = (...args) => {
   var _a;
   const key = args[0];
-  const instance = (_a = vueDemi.getCurrentInstance()) == null ? void 0 : _a.proxy;
+  const instance = (_a = vue.getCurrentInstance()) == null ? void 0 : _a.proxy;
   if (instance == null)
     throw new Error("injectLocal must be called in setup");
   if (localProvidedStateMap.has(instance) && key in localProvidedStateMap.get(instance))
     return localProvidedStateMap.get(instance)[key];
-  return vueDemi.inject(...args);
+  return vue.inject(...args);
 };
 
 const provideLocal = (key, value) => {
   var _a;
-  const instance = (_a = vueDemi.getCurrentInstance()) == null ? void 0 : _a.proxy;
+  const instance = (_a = vue.getCurrentInstance()) == null ? void 0 : _a.proxy;
   if (instance == null)
     throw new Error("provideLocal must be called in setup");
   if (!localProvidedStateMap.has(instance))
     localProvidedStateMap.set(instance, /* @__PURE__ */ Object.create(null));
   const localProvidedState = localProvidedStateMap.get(instance);
   localProvidedState[key] = value;
-  vueDemi.provide(key, value);
+  vue.provide(key, value);
 };
 
 function createInjectionState(composable, options) {
@@ -144,7 +144,7 @@ function createSharedComposable(composable) {
   return (...args) => {
     subscribers += 1;
     if (!scope) {
-      scope = vueDemi.effectScope(true);
+      scope = vue.effectScope(true);
       state = scope.run(() => composable(...args));
     }
     tryOnScopeDispose(dispose);
@@ -153,15 +153,10 @@ function createSharedComposable(composable) {
 }
 
 function extendRef(ref, extend, { enumerable = false, unwrap = true } = {}) {
-  if (!vueDemi.isVue3 && !vueDemi.version.startsWith("2.7.")) {
-    if (process.env.NODE_ENV !== "production")
-      throw new Error("[VueUse] extendRef only works in Vue 2.7 or above.");
-    return;
-  }
   for (const [key, value] of Object.entries(extend)) {
     if (key === "value")
       continue;
-    if (vueDemi.isRef(value) && unwrap) {
+    if (vue.isRef(value) && unwrap) {
       Object.defineProperty(ref, key, {
         get() {
           return value.value;
@@ -180,12 +175,12 @@ function extendRef(ref, extend, { enumerable = false, unwrap = true } = {}) {
 
 function get(obj, key) {
   if (key == null)
-    return vueDemi.unref(obj);
-  return vueDemi.unref(obj)[key];
+    return vue.unref(obj);
+  return vue.unref(obj)[key];
 }
 
 function isDefined(v) {
-  return vueDemi.unref(v) != null;
+  return vue.unref(v) != null;
 }
 
 function makeDestructurable(obj, arr) {
@@ -210,14 +205,14 @@ function makeDestructurable(obj, arr) {
 }
 
 function toValue(r) {
-  return typeof r === "function" ? r() : vueDemi.unref(r);
+  return typeof r === "function" ? r() : vue.unref(r);
 }
 const resolveUnref = toValue;
 
 function reactify(fn, options) {
-  const unrefFn = (options == null ? void 0 : options.computedGetter) === false ? vueDemi.unref : toValue;
+  const unrefFn = (options == null ? void 0 : options.computedGetter) === false ? vue.unref : toValue;
   return function(...args) {
-    return vueDemi.computed(() => fn.apply(this, args.map((i) => unrefFn(i))));
+    return vue.computed(() => fn.apply(this, args.map((i) => unrefFn(i))));
   };
 }
 
@@ -245,14 +240,14 @@ function reactifyObject(obj, optionsOrKeys = {}) {
 }
 
 function toReactive(objectRef) {
-  if (!vueDemi.isRef(objectRef))
-    return vueDemi.reactive(objectRef);
+  if (!vue.isRef(objectRef))
+    return vue.reactive(objectRef);
   const proxy = new Proxy({}, {
     get(_, p, receiver) {
-      return vueDemi.unref(Reflect.get(objectRef.value, p, receiver));
+      return vue.unref(Reflect.get(objectRef.value, p, receiver));
     },
     set(_, p, value) {
-      if (vueDemi.isRef(objectRef.value[p]) && !vueDemi.isRef(value))
+      if (vue.isRef(objectRef.value[p]) && !vue.isRef(value))
         objectRef.value[p].value = value;
       else
         objectRef.value[p] = value;
@@ -274,25 +269,19 @@ function toReactive(objectRef) {
       };
     }
   });
-  return vueDemi.reactive(proxy);
+  return vue.reactive(proxy);
 }
 
 function reactiveComputed(fn) {
-  return toReactive(vueDemi.computed(fn));
+  return toReactive(vue.computed(fn));
 }
 
 function reactiveOmit(obj, ...keys) {
   const flatKeys = keys.flat();
   const predicate = flatKeys[0];
-  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(vueDemi.toRefs(obj)).filter(([k, v]) => !predicate(toValue(v), k))) : Object.fromEntries(Object.entries(vueDemi.toRefs(obj)).filter((e) => !flatKeys.includes(e[0]))));
+  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(vue.toRefs(obj)).filter(([k, v]) => !predicate(toValue(v), k))) : Object.fromEntries(Object.entries(vue.toRefs(obj)).filter((e) => !flatKeys.includes(e[0]))));
 }
 
-const directiveHooks = {
-  mounted: vueDemi.isVue3 ? "mounted" : "inserted",
-  updated: vueDemi.isVue3 ? "updated" : "componentUpdated",
-  unmounted: vueDemi.isVue3 ? "unmounted" : "unbind"
-};
-
 const isClient = typeof window !== "undefined" && typeof document !== "undefined";
 const isWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
 const isDef = (val) => typeof val !== "undefined";
@@ -382,7 +371,7 @@ function throttleFilter(...args) {
   let trailing;
   let leading;
   let rejectOnCancel;
-  if (!vueDemi.isRef(args[0]) && typeof args[0] === "object")
+  if (!vue.isRef(args[0]) && typeof args[0] === "object")
     ({ delay: ms, trailing = true, leading = true, rejectOnCancel = false } = args[0]);
   else
     [ms, trailing = true, leading = true, rejectOnCancel = false] = args;
@@ -427,7 +416,7 @@ function throttleFilter(...args) {
   return filter;
 }
 function pausableFilter(extendFilter = bypassFilter) {
-  const isActive = vueDemi.ref(true);
+  const isActive = vue.ref(true);
   function pause() {
     isActive.value = false;
   }
@@ -438,7 +427,7 @@ function pausableFilter(extendFilter = bypassFilter) {
     if (isActive.value)
       extendFilter(...args);
   };
-  return { isActive: vueDemi.readonly(isActive), pause, resume, eventFilter };
+  return { isActive: vue.readonly(isActive), pause, resume, eventFilter };
 }
 
 function cacheStringFunction(fn) {
@@ -516,25 +505,25 @@ function objectEntries(obj) {
   return Object.entries(obj);
 }
 function getLifeCycleTarget(target) {
-  return target || vueDemi.getCurrentInstance();
+  return target || vue.getCurrentInstance();
 }
 
 function toRef(...args) {
   if (args.length !== 1)
-    return vueDemi.toRef(...args);
+    return vue.toRef(...args);
   const r = args[0];
-  return typeof r === "function" ? vueDemi.readonly(vueDemi.customRef(() => ({ get: r, set: noop }))) : vueDemi.ref(r);
+  return typeof r === "function" ? vue.readonly(vue.customRef(() => ({ get: r, set: noop }))) : vue.ref(r);
 }
 const resolveRef = toRef;
 
 function reactivePick(obj, ...keys) {
   const flatKeys = keys.flat();
   const predicate = flatKeys[0];
-  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(vueDemi.toRefs(obj)).filter(([k, v]) => predicate(toValue(v), k))) : Object.fromEntries(flatKeys.map((k) => [k, toRef(obj, k)])));
+  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(vue.toRefs(obj)).filter(([k, v]) => predicate(toValue(v), k))) : Object.fromEntries(flatKeys.map((k) => [k, toRef(obj, k)])));
 }
 
 function refAutoReset(defaultValue, afterMs = 1e4) {
-  return vueDemi.customRef((track, trigger) => {
+  return vue.customRef((track, trigger) => {
     let value = toValue(defaultValue);
     let timer;
     const resetAfter = () => setTimeout(() => {
@@ -567,16 +556,16 @@ function useDebounceFn(fn, ms = 200, options = {}) {
 }
 
 function refDebounced(value, ms = 200, options = {}) {
-  const debounced = vueDemi.ref(value.value);
+  const debounced = vue.ref(value.value);
   const updater = useDebounceFn(() => {
     debounced.value = value.value;
   }, ms, options);
-  vueDemi.watch(value, () => updater());
+  vue.watch(value, () => updater());
   return debounced;
 }
 
 function refDefault(source, defaultValue) {
-  return vueDemi.computed({
+  return vue.computed({
     get() {
       var _a;
       return (_a = source.value) != null ? _a : defaultValue;
@@ -597,11 +586,11 @@ function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnC
 function refThrottled(value, delay = 200, trailing = true, leading = true) {
   if (delay <= 0)
     return value;
-  const throttled = vueDemi.ref(value.value);
+  const throttled = vue.ref(value.value);
   const updater = useThrottleFn(() => {
     throttled.value = value.value;
   }, delay, trailing, leading);
-  vueDemi.watch(value, () => updater());
+  vue.watch(value, () => updater());
   return throttled;
 }
 
@@ -609,7 +598,7 @@ function refWithControl(initial, options = {}) {
   let source = initial;
   let track;
   let trigger;
-  const ref = vueDemi.customRef((_track, _trigger) => {
+  const ref = vue.customRef((_track, _trigger) => {
     track = _track;
     trigger = _trigger;
     return {
@@ -663,12 +652,8 @@ function set(...args) {
     ref.value = value;
   }
   if (args.length === 3) {
-    if (vueDemi.isVue2) {
-      vueDemi.set(...args);
-    } else {
-      const [target, key, value] = args;
-      target[key] = value;
-    }
+    const [target, key, value] = args;
+    target[key] = value;
   }
 }
 
@@ -677,7 +662,7 @@ function watchWithFilter(source, cb, options = {}) {
     eventFilter = bypassFilter,
     ...watchOptions
   } = options;
-  return vueDemi.watch(
+  return vue.watch(
     source,
     createFilterWrapper(
       eventFilter,
@@ -751,7 +736,7 @@ function syncRefs(source, targets, options = {}) {
   } = options;
   if (!Array.isArray(targets))
     targets = [targets];
-  return vueDemi.watch(
+  return vue.watch(
     source,
     (newValue) => targets.forEach((target) => target.value = newValue),
     { flush, deep, immediate }
@@ -759,11 +744,11 @@ function syncRefs(source, targets, options = {}) {
 }
 
 function toRefs(objectRef, options = {}) {
-  if (!vueDemi.isRef(objectRef))
-    return vueDemi.toRefs(objectRef);
+  if (!vue.isRef(objectRef))
+    return vue.toRefs(objectRef);
   const result = Array.isArray(objectRef.value) ? Array.from({ length: objectRef.value.length }) : {};
   for (const key in objectRef.value) {
-    result[key] = vueDemi.customRef(() => ({
+    result[key] = vue.customRef(() => ({
       get() {
         return objectRef.value[key];
       },
@@ -792,47 +777,47 @@ function toRefs(objectRef, options = {}) {
 function tryOnBeforeMount(fn, sync = true, target) {
   const instance = getLifeCycleTarget(target);
   if (instance)
-    vueDemi.onBeforeMount(fn, target);
+    vue.onBeforeMount(fn, target);
   else if (sync)
     fn();
   else
-    vueDemi.nextTick(fn);
+    vue.nextTick(fn);
 }
 
 function tryOnBeforeUnmount(fn, target) {
   const instance = getLifeCycleTarget(target);
   if (instance)
-    vueDemi.onBeforeUnmount(fn, target);
+    vue.onBeforeUnmount(fn, target);
 }
 
 function tryOnMounted(fn, sync = true, target) {
   const instance = getLifeCycleTarget();
   if (instance)
-    vueDemi.onMounted(fn, target);
+    vue.onMounted(fn, target);
   else if (sync)
     fn();
   else
-    vueDemi.nextTick(fn);
+    vue.nextTick(fn);
 }
 
 function tryOnUnmounted(fn, target) {
   const instance = getLifeCycleTarget(target);
   if (instance)
-    vueDemi.onUnmounted(fn, target);
+    vue.onUnmounted(fn, target);
 }
 
 function createUntil(r, isNot = false) {
   function toMatch(condition, { flush = "sync", deep = false, timeout, throwOnTimeout } = {}) {
     let stop = null;
     const watcher = new Promise((resolve) => {
-      stop = vueDemi.watch(
+      stop = vue.watch(
         r,
         (v) => {
           if (condition(v) !== isNot) {
             if (stop)
               stop();
             else
-              vueDemi.nextTick(() => stop == null ? void 0 : stop());
+              vue.nextTick(() => stop == null ? void 0 : stop());
             resolve(v);
           }
         },
@@ -852,19 +837,19 @@ function createUntil(r, isNot = false) {
     return Promise.race(promises);
   }
   function toBe(value, options) {
-    if (!vueDemi.isRef(value))
+    if (!vue.isRef(value))
       return toMatch((v) => v === value, options);
     const { flush = "sync", deep = false, timeout, throwOnTimeout } = options != null ? options : {};
     let stop = null;
     const watcher = new Promise((resolve) => {
-      stop = vueDemi.watch(
+      stop = vue.watch(
         [r, value],
         ([v1, v2]) => {
           if (isNot !== (v1 === v2)) {
             if (stop)
               stop();
             else
-              vueDemi.nextTick(() => stop == null ? void 0 : stop());
+              vue.nextTick(() => stop == null ? void 0 : stop());
             resolve(v1);
           }
         },
@@ -958,25 +943,25 @@ function useArrayDifference(...args) {
     const key = compareFn;
     compareFn = (value, othVal) => value[key] === othVal[key];
   }
-  return vueDemi.computed(() => toValue(list).filter((x) => toValue(values).findIndex((y) => compareFn(x, y)) === -1));
+  return vue.computed(() => toValue(list).filter((x) => toValue(values).findIndex((y) => compareFn(x, y)) === -1));
 }
 
 function useArrayEvery(list, fn) {
-  return vueDemi.computed(() => toValue(list).every((element, index, array) => fn(toValue(element), index, array)));
+  return vue.computed(() => toValue(list).every((element, index, array) => fn(toValue(element), index, array)));
 }
 
 function useArrayFilter(list, fn) {
-  return vueDemi.computed(() => toValue(list).map((i) => toValue(i)).filter(fn));
+  return vue.computed(() => toValue(list).map((i) => toValue(i)).filter(fn));
 }
 
 function useArrayFind(list, fn) {
-  return vueDemi.computed(() => toValue(
+  return vue.computed(() => toValue(
     toValue(list).find((element, index, array) => fn(toValue(element), index, array))
   ));
 }
 
 function useArrayFindIndex(list, fn) {
-  return vueDemi.computed(() => toValue(list).findIndex((element, index, array) => fn(toValue(element), index, array)));
+  return vue.computed(() => toValue(list).findIndex((element, index, array) => fn(toValue(element), index, array)));
 }
 
 function findLast(arr, cb) {
@@ -988,7 +973,7 @@ function findLast(arr, cb) {
   return void 0;
 }
 function useArrayFindLast(list, fn) {
-  return vueDemi.computed(() => toValue(
+  return vue.computed(() => toValue(
     !Array.prototype.findLast ? findLast(toValue(list), (element, index, array) => fn(toValue(element), index, array)) : toValue(list).findLast((element, index, array) => fn(toValue(element), index, array))
   ));
 }
@@ -1011,7 +996,7 @@ function useArrayIncludes(...args) {
     comparator = (element, value2) => element[key] === toValue(value2);
   }
   comparator = comparator != null ? comparator : (element, value2) => element === toValue(value2);
-  return vueDemi.computed(() => toValue(list).slice(formIndex).some((element, index, array) => comparator(
+  return vue.computed(() => toValue(list).slice(formIndex).some((element, index, array) => comparator(
     toValue(element),
     toValue(value),
     index,
@@ -1020,23 +1005,23 @@ function useArrayIncludes(...args) {
 }
 
 function useArrayJoin(list, separator) {
-  return vueDemi.computed(() => toValue(list).map((i) => toValue(i)).join(toValue(separator)));
+  return vue.computed(() => toValue(list).map((i) => toValue(i)).join(toValue(separator)));
 }
 
 function useArrayMap(list, fn) {
-  return vueDemi.computed(() => toValue(list).map((i) => toValue(i)).map(fn));
+  return vue.computed(() => toValue(list).map((i) => toValue(i)).map(fn));
 }
 
 function useArrayReduce(list, reducer, ...args) {
   const reduceCallback = (sum, value, index) => reducer(toValue(sum), toValue(value), index);
-  return vueDemi.computed(() => {
+  return vue.computed(() => {
     const resolved = toValue(list);
     return args.length ? resolved.reduce(reduceCallback, typeof args[0] === "function" ? toValue(args[0]()) : toValue(args[0])) : resolved.reduce(reduceCallback);
   });
 }
 
 function useArraySome(list, fn) {
-  return vueDemi.computed(() => toValue(list).some((element, index, array) => fn(toValue(element), index, array)));
+  return vue.computed(() => toValue(list).some((element, index, array) => fn(toValue(element), index, array)));
 }
 
 function uniq(array) {
@@ -1050,15 +1035,15 @@ function uniqueElementsBy(array, fn) {
   }, []);
 }
 function useArrayUnique(list, compareFn) {
-  return vueDemi.computed(() => {
+  return vue.computed(() => {
     const resolvedList = toValue(list).map((element) => toValue(element));
     return compareFn ? uniqueElementsBy(resolvedList, compareFn) : uniq(resolvedList);
   });
 }
 
 function useCounter(initialValue = 0, options = {}) {
-  let _initialValue = vueDemi.unref(initialValue);
-  const count = vueDemi.ref(initialValue);
+  let _initialValue = vue.unref(initialValue);
+  const count = vue.ref(initialValue);
   const {
     max = Number.POSITIVE_INFINITY,
     min = Number.NEGATIVE_INFINITY
@@ -1155,7 +1140,7 @@ function normalizeDate(date) {
   return new Date(date);
 }
 function useDateFormat(date, formatStr = "HH:mm:ss", options = {}) {
-  return vueDemi.computed(() => formatDate(normalizeDate(toValue(date)), toValue(formatStr), options));
+  return vue.computed(() => formatDate(normalizeDate(toValue(date)), toValue(formatStr), options));
 }
 
 function useIntervalFn(cb, interval = 1e3, options = {}) {
@@ -1164,7 +1149,7 @@ function useIntervalFn(cb, interval = 1e3, options = {}) {
     immediateCallback = false
   } = options;
   let timer = null;
-  const isActive = vueDemi.ref(false);
+  const isActive = vue.ref(false);
   function clean() {
     if (timer) {
       clearInterval(timer);
@@ -1188,8 +1173,8 @@ function useIntervalFn(cb, interval = 1e3, options = {}) {
   }
   if (immediate && isClient)
     resume();
-  if (vueDemi.isRef(interval) || typeof interval === "function") {
-    const stopWatch = vueDemi.watch(interval, () => {
+  if (vue.isRef(interval) || typeof interval === "function") {
+    const stopWatch = vue.watch(interval, () => {
       if (isActive.value && isClient)
         resume();
     });
@@ -1209,7 +1194,7 @@ function useInterval(interval = 1e3, options = {}) {
     immediate = true,
     callback
   } = options;
-  const counter = vueDemi.ref(0);
+  const counter = vue.ref(0);
   const update = () => counter.value += 1;
   const reset = () => {
     counter.value = 0;
@@ -1235,8 +1220,8 @@ function useInterval(interval = 1e3, options = {}) {
 
 function useLastChanged(source, options = {}) {
   var _a;
-  const ms = vueDemi.ref((_a = options.initialValue) != null ? _a : null);
-  vueDemi.watch(
+  const ms = vue.ref((_a = options.initialValue) != null ? _a : null);
+  vue.watch(
     source,
     () => ms.value = timestamp(),
     options
@@ -1248,7 +1233,7 @@ function useTimeoutFn(cb, interval, options = {}) {
   const {
     immediate = true
   } = options;
-  const isPending = vueDemi.ref(false);
+  const isPending = vue.ref(false);
   let timer = null;
   function clear() {
     if (timer) {
@@ -1276,7 +1261,7 @@ function useTimeoutFn(cb, interval, options = {}) {
   }
   tryOnScopeDispose(stop);
   return {
-    isPending: vueDemi.readonly(isPending),
+    isPending: vue.readonly(isPending),
     start,
     stop
   };
@@ -1292,7 +1277,7 @@ function useTimeout(interval = 1e3, options = {}) {
     interval,
     options
   );
-  const ready = vueDemi.computed(() => !controls.isPending.value);
+  const ready = vue.computed(() => !controls.isPending.value);
   if (exposeControls) {
     return {
       ready,
@@ -1309,7 +1294,7 @@ function useToNumber(value, options = {}) {
     radix,
     nanToZero
   } = options;
-  return vueDemi.computed(() => {
+  return vue.computed(() => {
     let resolved = toValue(value);
     if (typeof resolved === "string")
       resolved = Number[method](resolved, radix);
@@ -1320,7 +1305,7 @@ function useToNumber(value, options = {}) {
 }
 
 function useToString(value) {
-  return vueDemi.computed(() => `${toValue(value)}`);
+  return vue.computed(() => `${toValue(value)}`);
 }
 
 function useToggle(initialValue = false, options = {}) {
@@ -1328,8 +1313,8 @@ function useToggle(initialValue = false, options = {}) {
     truthyValue = true,
     falsyValue = false
   } = options;
-  const valueIsRef = vueDemi.isRef(initialValue);
-  const _value = vueDemi.ref(initialValue);
+  const valueIsRef = vue.isRef(initialValue);
+  const _value = vue.ref(initialValue);
   function toggle(value) {
     if (arguments.length) {
       _value.value = value;
@@ -1348,7 +1333,7 @@ function useToggle(initialValue = false, options = {}) {
 
 function watchArray(source, cb, options) {
   let oldList = (options == null ? void 0 : options.immediate) ? [] : [...source instanceof Function ? source() : Array.isArray(source) ? source : toValue(source)];
-  return vueDemi.watch(source, (newList, _, onCleanup) => {
+  return vue.watch(source, (newList, _, onCleanup) => {
     const oldListRemains = Array.from({ length: oldList.length });
     const added = [];
     for (const obj of newList) {
@@ -1374,13 +1359,13 @@ function watchAtMost(source, cb, options) {
     count,
     ...watchOptions
   } = options;
-  const current = vueDemi.ref(0);
+  const current = vue.ref(0);
   const stop = watchWithFilter(
     source,
     (...args) => {
       current.value += 1;
       if (current.value >= toValue(count))
-        vueDemi.nextTick(() => stop());
+        vue.nextTick(() => stop());
       cb(...args);
     },
     watchOptions
@@ -1405,7 +1390,7 @@ function watchDebounced(source, cb, options = {}) {
 }
 
 function watchDeep(source, cb, options) {
-  return vueDemi.watch(
+  return vue.watch(
     source,
     cb,
     {
@@ -1428,7 +1413,7 @@ function watchIgnorable(source, cb, options = {}) {
   let ignorePrevAsyncUpdates;
   let stop;
   if (watchOptions.flush === "sync") {
-    const ignore = vueDemi.ref(false);
+    const ignore = vue.ref(false);
     ignorePrevAsyncUpdates = () => {
     };
     ignoreUpdates = (updater) => {
@@ -1436,7 +1421,7 @@ function watchIgnorable(source, cb, options = {}) {
       updater();
       ignore.value = false;
     };
-    stop = vueDemi.watch(
+    stop = vue.watch(
       source,
       (...args) => {
         if (!ignore.value)
@@ -1446,13 +1431,13 @@ function watchIgnorable(source, cb, options = {}) {
     );
   } else {
     const disposables = [];
-    const ignoreCounter = vueDemi.ref(0);
-    const syncCounter = vueDemi.ref(0);
+    const ignoreCounter = vue.ref(0);
+    const syncCounter = vue.ref(0);
     ignorePrevAsyncUpdates = () => {
       ignoreCounter.value = syncCounter.value;
     };
     disposables.push(
-      vueDemi.watch(
+      vue.watch(
         source,
         () => {
           syncCounter.value++;
@@ -1466,7 +1451,7 @@ function watchIgnorable(source, cb, options = {}) {
       ignoreCounter.value += syncCounter.value - syncCounterPrev;
     };
     disposables.push(
-      vueDemi.watch(
+      vue.watch(
         source,
         (...args) => {
           const ignore = ignoreCounter.value > 0 && ignoreCounter.value === syncCounter.value;
@@ -1487,7 +1472,7 @@ function watchIgnorable(source, cb, options = {}) {
 }
 
 function watchImmediate(source, cb, options) {
-  return vueDemi.watch(
+  return vue.watch(
     source,
     cb,
     {
@@ -1498,8 +1483,8 @@ function watchImmediate(source, cb, options) {
 }
 
 function watchOnce(source, cb, options) {
-  const stop = vueDemi.watch(source, (...args) => {
-    vueDemi.nextTick(() => stop());
+  const stop = vue.watch(source, (...args) => {
+    vue.nextTick(() => stop());
     return cb(...args);
   }, options);
   return stop;
@@ -1553,7 +1538,7 @@ function watchTriggerable(source, cb, options = {}) {
   };
 }
 function getWatchSources(sources) {
-  if (vueDemi.isReactive(sources))
+  if (vue.isReactive(sources))
     return sources;
   if (Array.isArray(sources))
     return sources.map((item) => toValue(item));
@@ -1564,12 +1549,12 @@ function getOldValue(source) {
 }
 
 function whenever(source, cb, options) {
-  const stop = vueDemi.watch(
+  const stop = vue.watch(
     source,
     (v, ov, onInvalidate) => {
       if (v) {
         if (options == null ? void 0 : options.once)
-          vueDemi.nextTick(() => stop());
+          vue.nextTick(() => stop());
         cb(v, ov, onInvalidate);
       }
     },
@@ -1601,7 +1586,6 @@ exports.createSingletonPromise = createSingletonPromise;
 exports.debounceFilter = debounceFilter;
 exports.debouncedRef = refDebounced;
 exports.debouncedWatch = watchDebounced;
-exports.directiveHooks = directiveHooks;
 exports.eagerComputed = computedEager;
 exports.extendRef = extendRef;
 exports.formatDate = formatDate;