@vueuse/shared 11.3.0 → 12.0.0

package/index.iife.js

@@ -1,158 +1,31 @@
-var _VueDemiGlobal = typeof globalThis !== 'undefined' 
-  ? globalThis
-  : typeof global !== 'undefined'
-    ? global
-    : typeof self !== 'undefined'
-      ? self
-      : this
-var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
-  if (VueDemi.install) {
-    return VueDemi
-  }
-  if (!Vue) {
-    console.error('[vue-demi] no Vue instance found, please be sure to import `vue` before `vue-demi`.')
-    return VueDemi
-  }
-
-  // Vue 2.7
-  if (Vue.version.slice(0, 4) === '2.7.') {
-    for (var key in Vue) {
-      VueDemi[key] = Vue[key]
-    }
-    VueDemi.isVue2 = true
-    VueDemi.isVue3 = false
-    VueDemi.install = function () {}
-    VueDemi.Vue = Vue
-    VueDemi.Vue2 = Vue
-    VueDemi.version = Vue.version
-    VueDemi.warn = Vue.util.warn
-    VueDemi.hasInjectionContext = function() {
-      return !!VueDemi.getCurrentInstance()
-    }
-    function createApp(rootComponent, rootProps) {
-      var vm
-      var provide = {}
-      var app = {
-        config: Vue.config,
-        use: Vue.use.bind(Vue),
-        mixin: Vue.mixin.bind(Vue),
-        component: Vue.component.bind(Vue),
-        provide: function (key, value) {
-          provide[key] = value
-          return this
-        },
-        directive: function (name, dir) {
-          if (dir) {
-            Vue.directive(name, dir)
-            return app
-          } else {
-            return Vue.directive(name)
-          }
-        },
-        mount: function (el, hydrating) {
-          if (!vm) {
-            vm = new Vue(Object.assign({ propsData: rootProps }, rootComponent, { provide: Object.assign(provide, rootComponent.provide) }))
-            vm.$mount(el, hydrating)
-            return vm
-          } else {
-            return vm
-          }
-        },
-        unmount: function () {
-          if (vm) {
-            vm.$destroy()
-            vm = undefined
-          }
-        },
-      }
-      return app
-    }
-    VueDemi.createApp = createApp
-  }
-  // Vue 2.6.x
-  else if (Vue.version.slice(0, 2) === '2.') {
-    if (VueCompositionAPI) {
-      for (var key in VueCompositionAPI) {
-        VueDemi[key] = VueCompositionAPI[key]
-      }
-      VueDemi.isVue2 = true
-      VueDemi.isVue3 = false
-      VueDemi.install = function () {}
-      VueDemi.Vue = Vue
-      VueDemi.Vue2 = Vue
-      VueDemi.version = Vue.version
-      VueDemi.hasInjectionContext = function() {
-        return !!VueDemi.getCurrentInstance()
-      }
-    } else {
-      console.error('[vue-demi] no VueCompositionAPI instance found, please be sure to import `@vue/composition-api` before `vue-demi`.')
-    }
-  }
-  // Vue 3
-  else if (Vue.version.slice(0, 2) === '3.') {
-    for (var key in Vue) {
-      VueDemi[key] = Vue[key]
-    }
-    VueDemi.isVue2 = false
-    VueDemi.isVue3 = true
-    VueDemi.install = function () {}
-    VueDemi.Vue = Vue
-    VueDemi.Vue2 = undefined
-    VueDemi.version = Vue.version
-    VueDemi.set = function (target, key, val) {
-      if (Array.isArray(target)) {
-        target.length = Math.max(target.length, key)
-        target.splice(key, 1, val)
-        return val
-      }
-      target[key] = val
-      return val
-    }
-    VueDemi.del = function (target, key) {
-      if (Array.isArray(target)) {
-        target.splice(key, 1)
-        return
-      }
-      delete target[key]
-    }
-  } else {
-    console.error('[vue-demi] Vue version ' + Vue.version + ' is unsupported.')
-  }
-  return VueDemi
-})(
-  (_VueDemiGlobal.VueDemi = _VueDemiGlobal.VueDemi || (typeof VueDemi !== 'undefined' ? VueDemi : {})),
-  _VueDemiGlobal.Vue || (typeof Vue !== 'undefined' ? Vue : undefined),
-  _VueDemiGlobal.VueCompositionAPI || (typeof VueCompositionAPI !== 'undefined' ? VueCompositionAPI : undefined)
-);
-;
-;(function (exports, vueDemi) {
+(function (exports, vue) {
   'use strict';
 
   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 {
@@ -175,8 +48,8 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
 
   function tryOnScopeDispose(fn) {
-    if (vueDemi.getCurrentScope()) {
-      vueDemi.onScopeDispose(fn);
+    if (vue.getCurrentScope()) {
+      vue.onScopeDispose(fn);
       return true;
     }
     return false;
@@ -208,7 +81,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   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));
@@ -223,24 +96,24 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   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) {
@@ -270,7 +143,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     return (...args) => {
       subscribers += 1;
       if (!scope) {
-        scope = vueDemi.effectScope(true);
+        scope = vue.effectScope(true);
         state = scope.run(() => composable(...args));
       }
       tryOnScopeDispose(dispose);
@@ -279,15 +152,10 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
 
   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;
@@ -306,12 +174,12 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
 
   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) {
@@ -336,14 +204,14 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
 
   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))));
     };
   }
 
@@ -371,14 +239,14 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
 
   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;
@@ -400,25 +268,19 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
         };
       }
     });
-    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";
@@ -508,7 +370,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     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;
@@ -553,7 +415,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     return filter;
   }
   function pausableFilter(extendFilter = bypassFilter) {
-    const isActive = vueDemi.ref(true);
+    const isActive = vue.ref(true);
     function pause() {
       isActive.value = false;
     }
@@ -564,7 +426,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       if (isActive.value)
         extendFilter(...args);
     };
-    return { isActive: vueDemi.readonly(isActive), pause, resume, eventFilter };
+    return { isActive: vue.readonly(isActive), pause, resume, eventFilter };
   }
 
   function cacheStringFunction(fn) {
@@ -642,25 +504,25 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     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(() => {
@@ -693,16 +555,16 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
 
   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;
@@ -723,11 +585,11 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   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;
   }
 
@@ -735,7 +597,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     let source = initial;
     let track;
     let trigger;
-    const ref = vueDemi.customRef((_track, _trigger) => {
+    const ref = vue.customRef((_track, _trigger) => {
       track = _track;
       trigger = _trigger;
       return {
@@ -789,12 +651,8 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       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;
     }
   }
 
@@ -803,7 +661,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       eventFilter = bypassFilter,
       ...watchOptions
     } = options;
-    return vueDemi.watch(
+    return vue.watch(
       source,
       createFilterWrapper(
         eventFilter,
@@ -877,7 +735,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     } = options;
     if (!Array.isArray(targets))
       targets = [targets];
-    return vueDemi.watch(
+    return vue.watch(
       source,
       (newValue) => targets.forEach((target) => target.value = newValue),
       { flush, deep, immediate }
@@ -885,11 +743,11 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
 
   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];
         },
@@ -918,47 +776,47 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   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);
             }
           },
@@ -978,19 +836,19 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       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);
             }
           },
@@ -1084,25 +942,25 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       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) {
@@ -1114,7 +972,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     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))
     ));
   }
@@ -1137,7 +995,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       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,
@@ -1146,23 +1004,23 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
 
   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) {
@@ -1176,15 +1034,15 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     }, []);
   }
   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
@@ -1281,7 +1139,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     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 = {}) {
@@ -1290,7 +1148,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       immediateCallback = false
     } = options;
     let timer = null;
-    const isActive = vueDemi.ref(false);
+    const isActive = vue.ref(false);
     function clean() {
       if (timer) {
         clearInterval(timer);
@@ -1314,8 +1172,8 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     }
     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();
       });
@@ -1335,7 +1193,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       immediate = true,
       callback
     } = options;
-    const counter = vueDemi.ref(0);
+    const counter = vue.ref(0);
     const update = () => counter.value += 1;
     const reset = () => {
       counter.value = 0;
@@ -1361,8 +1219,8 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
 
   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
@@ -1374,7 +1232,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     const {
       immediate = true
     } = options;
-    const isPending = vueDemi.ref(false);
+    const isPending = vue.ref(false);
     let timer = null;
     function clear() {
       if (timer) {
@@ -1402,7 +1260,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     }
     tryOnScopeDispose(stop);
     return {
-      isPending: vueDemi.readonly(isPending),
+      isPending: vue.readonly(isPending),
       start,
       stop
     };
@@ -1418,7 +1276,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       interval,
       options
     );
-    const ready = vueDemi.computed(() => !controls.isPending.value);
+    const ready = vue.computed(() => !controls.isPending.value);
     if (exposeControls) {
       return {
         ready,
@@ -1435,7 +1293,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       radix,
       nanToZero
     } = options;
-    return vueDemi.computed(() => {
+    return vue.computed(() => {
       let resolved = toValue(value);
       if (typeof resolved === "string")
         resolved = Number[method](resolved, radix);
@@ -1446,7 +1304,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
 
   function useToString(value) {
-    return vueDemi.computed(() => `${toValue(value)}`);
+    return vue.computed(() => `${toValue(value)}`);
   }
 
   function useToggle(initialValue = false, options = {}) {
@@ -1454,8 +1312,8 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       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;
@@ -1474,7 +1332,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
 
   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) {
@@ -1500,13 +1358,13 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       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
@@ -1531,7 +1389,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
 
   function watchDeep(source, cb, options) {
-    return vueDemi.watch(
+    return vue.watch(
       source,
       cb,
       {
@@ -1554,7 +1412,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     let ignorePrevAsyncUpdates;
     let stop;
     if (watchOptions.flush === "sync") {
-      const ignore = vueDemi.ref(false);
+      const ignore = vue.ref(false);
       ignorePrevAsyncUpdates = () => {
       };
       ignoreUpdates = (updater) => {
@@ -1562,7 +1420,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
         updater();
         ignore.value = false;
       };
-      stop = vueDemi.watch(
+      stop = vue.watch(
         source,
         (...args) => {
           if (!ignore.value)
@@ -1572,13 +1430,13 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       );
     } 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++;
@@ -1592,7 +1450,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
         ignoreCounter.value += syncCounter.value - syncCounterPrev;
       };
       disposables.push(
-        vueDemi.watch(
+        vue.watch(
           source,
           (...args) => {
             const ignore = ignoreCounter.value > 0 && ignoreCounter.value === syncCounter.value;
@@ -1613,7 +1471,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
 
   function watchImmediate(source, cb, options) {
-    return vueDemi.watch(
+    return vue.watch(
       source,
       cb,
       {
@@ -1624,8 +1482,8 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
 
   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;
@@ -1679,7 +1537,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     };
   }
   function getWatchSources(sources) {
-    if (vueDemi.isReactive(sources))
+    if (vue.isReactive(sources))
       return sources;
     if (Array.isArray(sources))
       return sources.map((item) => toValue(item));
@@ -1690,12 +1548,12 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
 
   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);
         }
       },
@@ -1727,7 +1585,6 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   exports.debounceFilter = debounceFilter;
   exports.debouncedRef = refDebounced;
   exports.debouncedWatch = watchDebounced;
-  exports.directiveHooks = directiveHooks;
   exports.eagerComputed = computedEager;
   exports.extendRef = extendRef;
   exports.formatDate = formatDate;
@@ -1827,4 +1684,4 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   exports.watchWithFilter = watchWithFilter;
   exports.whenever = whenever;
 
-})(this.VueUse = this.VueUse || {}, VueDemi);
+})(this.VueUse = this.VueUse || {}, Vue);