@vueuse/shared 10.0.0-beta.2 → 10.0.0-beta.4

package/index.iife.js

@@ -169,12 +169,13 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     max = Math.floor(max);
     return Math.floor(Math.random() * (max - min + 1)) + min;
   };
-  const isIOS = isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && /iP(ad|hone|od)/.test(window.navigator.userAgent);
   const hasOwn = (val, key) => Object.prototype.hasOwnProperty.call(val, key);
+  const isIOS = isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && /iP(ad|hone|od)/.test(window.navigator.userAgent);
 
-  function resolveUnref(r) {
+  function toValue(r) {
     return typeof r === "function" ? r() : vueDemi.unref(r);
   }
+  const resolveUnref = toValue;
 
   function createFilterWrapper(filter, fn) {
     function wrapper(...args) {
@@ -197,8 +198,8 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       lastRejector = noop;
     };
     const filter = (invoke) => {
-      const duration = resolveUnref(ms);
-      const maxDuration = resolveUnref(options.maxWait);
+      const duration = toValue(ms);
+      const maxDuration = toValue(options.maxWait);
       if (timer)
         _clearTimeout(timer);
       if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
@@ -243,7 +244,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       }
     };
     const filter = (_invoke) => {
-      const duration = resolveUnref(ms);
+      const duration = toValue(ms);
       const elapsed = Date.now() - lastExec;
       const invoke = () => {
         return lastValue = _invoke();
@@ -357,6 +358,11 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       return n;
     }, {});
   }
+  function objectOmit(obj, keys, omitUndefined = false) {
+    return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {
+      return (!omitUndefined || value !== void 0) && !keys.includes(key);
+    }));
+  }
   function objectEntries(obj) {
     return Object.entries(obj);
   }
@@ -404,7 +410,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
 
   function createEventHook() {
-    const fns = new Set();
+    const fns = /* @__PURE__ */ new Set();
     const off = (fn) => {
       fns.delete(fn);
     };
@@ -543,7 +549,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
 
   function reactify(fn, options) {
-    const unrefFn = (options == null ? void 0 : options.computedGetter) === false ? vueDemi.unref : resolveUnref;
+    const unrefFn = (options == null ? void 0 : options.computedGetter) === false ? vueDemi.unref : toValue;
     return function(...args) {
       return vueDemi.computed(() => fn.apply(this, args.map((i) => unrefFn(i))));
     };
@@ -561,13 +567,15 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       if (includeOwnProperties)
         keys.push(...Object.getOwnPropertyNames(obj));
     }
-    return Object.fromEntries(keys.map((key) => {
-      const value = obj[key];
-      return [
-        key,
-        typeof value === "function" ? reactify(value.bind(obj), options) : value
-      ];
-    }));
+    return Object.fromEntries(
+      keys.map((key) => {
+        const value = obj[key];
+        return [
+          key,
+          typeof value === "function" ? reactify(value.bind(obj), options) : value
+        ];
+      })
+    );
   }
 
   function toReactive(objectRef) {
@@ -610,13 +618,23 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   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(resolveUnref(v), k))) : Object.fromEntries(Object.entries(vueDemi.toRefs(obj)).filter((e) => !flatKeys.includes(e[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])))
+    );
   }
 
+  function toRef(...args) {
+    if (args.length !== 1)
+      return vueDemi.toRef(...args);
+    const r = args[0];
+    return typeof r === "function" ? vueDemi.readonly(vueDemi.customRef(() => ({ get: r, set: noop }))) : vueDemi.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(resolveUnref(v), k))) : Object.fromEntries(flatKeys.map((k) => [k, vueDemi.toRef(obj, k)])));
+    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)])));
   }
 
   function refAutoReset(defaultValue, afterMs = 1e4) {
@@ -626,7 +644,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       const resetAfter = () => setTimeout(() => {
         value = defaultValue;
         trigger();
-      }, resolveUnref(afterMs));
+      }, toValue(afterMs));
       tryOnScopeDispose(() => {
         clearTimeout(timer);
       });
@@ -646,7 +664,10 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
 
   function useDebounceFn(fn, ms = 200, options = {}) {
-    return createFilterWrapper(debounceFilter(ms, options), fn);
+    return createFilterWrapper(
+      debounceFilter(ms, options),
+      fn
+    );
   }
 
   function refDebounced(value, ms = 200, options = {}) {
@@ -671,7 +692,10 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
 
   function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
-    return createFilterWrapper(throttleFilter(ms, trailing, leading, rejectOnCancel), fn);
+    return createFilterWrapper(
+      throttleFilter(ms, trailing, leading, rejectOnCancel),
+      fn
+    );
   }
 
   function refThrottled(value, delay = 200, trailing = true, leading = true) {
@@ -722,21 +746,21 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     const silentSet = (v) => set(v, false);
     const peek = () => get(false);
     const lay = (v) => set(v, false);
-    return extendRef(ref, {
-      get,
-      set,
-      untrackedGet,
-      silentSet,
-      peek,
-      lay
-    }, { enumerable: true });
+    return extendRef(
+      ref,
+      {
+        get,
+        set,
+        untrackedGet,
+        silentSet,
+        peek,
+        lay
+      },
+      { enumerable: true }
+    );
   }
   const controlledRef = refWithControl;
 
-  function resolveRef(r) {
-    return typeof r === "function" ? vueDemi.computed(r) : vueDemi.ref(r);
-  }
-
   function set(...args) {
     if (args.length === 2) {
       const [ref, value] = args;
@@ -766,10 +790,18 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     const transformLTR = (_a = transform.ltr) != null ? _a : (v) => v;
     const transformRTL = (_b = transform.rtl) != null ? _b : (v) => v;
     if (direction === "both" || direction === "ltr") {
-      watchLeft = vueDemi.watch(left, (newValue) => right.value = transformLTR(newValue), { flush, deep, immediate });
+      watchLeft = vueDemi.watch(
+        left,
+        (newValue) => right.value = transformLTR(newValue),
+        { flush, deep, immediate }
+      );
     }
     if (direction === "both" || direction === "rtl") {
-      watchRight = vueDemi.watch(right, (newValue) => left.value = transformRTL(newValue), { flush, deep, immediate });
+      watchRight = vueDemi.watch(
+        right,
+        (newValue) => left.value = transformRTL(newValue),
+        { flush, deep, immediate }
+      );
     }
     return () => {
       watchLeft == null ? void 0 : watchLeft();
@@ -785,7 +817,11 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     } = options;
     if (!Array.isArray(targets))
       targets = [targets];
-    return vueDemi.watch(source, (newValue) => targets.forEach((target) => target.value = newValue), { flush, deep, immediate });
+    return vueDemi.watch(
+      source,
+      (newValue) => targets.forEach((target) => target.value = newValue),
+      { flush, deep, immediate }
+    );
   }
 
   var __defProp$9 = Object.defineProperty;
@@ -864,20 +900,26 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     function toMatch(condition, { flush = "sync", deep = false, timeout, throwOnTimeout } = {}) {
       let stop = null;
       const watcher = new Promise((resolve) => {
-        stop = vueDemi.watch(r, (v) => {
-          if (condition(v) !== isNot) {
-            stop == null ? void 0 : stop();
-            resolve(v);
+        stop = vueDemi.watch(
+          r,
+          (v) => {
+            if (condition(v) !== isNot) {
+              stop == null ? void 0 : stop();
+              resolve(v);
+            }
+          },
+          {
+            flush,
+            deep,
+            immediate: true
           }
-        }, {
-          flush,
-          deep,
-          immediate: true
-        });
+        );
       });
       const promises = [watcher];
       if (timeout != null) {
-        promises.push(promiseTimeout(timeout, throwOnTimeout).then(() => resolveUnref(r)).finally(() => stop == null ? void 0 : stop()));
+        promises.push(
+          promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => stop == null ? void 0 : stop())
+        );
       }
       return Promise.race(promises);
     }
@@ -887,23 +929,29 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       const { flush = "sync", deep = false, timeout, throwOnTimeout } = options != null ? options : {};
       let stop = null;
       const watcher = new Promise((resolve) => {
-        stop = vueDemi.watch([r, value], ([v1, v2]) => {
-          if (isNot !== (v1 === v2)) {
-            stop == null ? void 0 : stop();
-            resolve(v1);
+        stop = vueDemi.watch(
+          [r, value],
+          ([v1, v2]) => {
+            if (isNot !== (v1 === v2)) {
+              stop == null ? void 0 : stop();
+              resolve(v1);
+            }
+          },
+          {
+            flush,
+            deep,
+            immediate: true
           }
-        }, {
-          flush,
-          deep,
-          immediate: true
-        });
+        );
       });
       const promises = [watcher];
       if (timeout != null) {
-        promises.push(promiseTimeout(timeout, throwOnTimeout).then(() => resolveUnref(r)).finally(() => {
-          stop == null ? void 0 : stop();
-          return resolveUnref(r);
-        }));
+        promises.push(
+          promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => {
+            stop == null ? void 0 : stop();
+            return toValue(r);
+          })
+        );
       }
       return Promise.race(promises);
     }
@@ -922,7 +970,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     function toContains(value, options) {
       return toMatch((v) => {
         const array = Array.from(v);
-        return array.includes(value) || array.includes(resolveUnref(value));
+        return array.includes(value) || array.includes(toValue(value));
       }, options);
     }
     function changed(options) {
@@ -935,7 +983,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
         return count >= n;
       }, options);
     }
-    if (Array.isArray(resolveUnref(r))) {
+    if (Array.isArray(toValue(r))) {
       const instance = {
         toMatch,
         toContains,
@@ -967,7 +1015,9 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     return createUntil(r);
   }
 
-  const defaultComparator = (value, othVal) => value === othVal;
+  function defaultComparator(value, othVal) {
+    return value === othVal;
+  }
   function useArrayDifference(...args) {
     var _a;
     const list = args[0];
@@ -977,23 +1027,27 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       const key = compareFn;
       compareFn = (value, othVal) => value[key] === othVal[key];
     }
-    return vueDemi.computed(() => resolveUnref(list).filter((x) => resolveUnref(values).findIndex((y) => compareFn(x, y)) === -1));
+    return vueDemi.computed(() => toValue(list).filter((x) => toValue(values).findIndex((y) => compareFn(x, y)) === -1));
   }
 
   function useArrayEvery(list, fn) {
-    return vueDemi.computed(() => resolveUnref(list).every((element, index, array) => fn(resolveUnref(element), index, array)));
+    return vueDemi.computed(() => toValue(list).every((element, index, array) => fn(toValue(element), index, array)));
   }
 
   function useArrayFilter(list, fn) {
-    return vueDemi.computed(() => resolveUnref(list).map((i) => resolveUnref(i)).filter(fn));
+    return vueDemi.computed(() => toValue(list).map((i) => toValue(i)).filter(fn));
   }
 
   function useArrayFind(list, fn) {
-    return vueDemi.computed(() => resolveUnref(resolveUnref(list).find((element, index, array) => fn(resolveUnref(element), index, array))));
+    return vueDemi.computed(
+      () => toValue(
+        toValue(list).find((element, index, array) => fn(toValue(element), index, array))
+      )
+    );
   }
 
   function useArrayFindIndex(list, fn) {
-    return vueDemi.computed(() => resolveUnref(list).findIndex((element, index, array) => fn(resolveUnref(element), index, array)));
+    return vueDemi.computed(() => toValue(list).findIndex((element, index, array) => fn(toValue(element), index, array)));
   }
 
   function findLast(arr, cb) {
@@ -1005,7 +1059,11 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     return void 0;
   }
   function useArrayFindLast(list, fn) {
-    return vueDemi.computed(() => resolveUnref(!Array.prototype.findLast ? findLast(resolveUnref(list), (element, index, array) => fn(resolveUnref(element), index, array)) : resolveUnref(list).findLast((element, index, array) => fn(resolveUnref(element), index, array))));
+    return vueDemi.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))
+      )
+    );
   }
 
   function isArrayIncludesOptions(obj) {
@@ -1023,30 +1081,34 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     }
     if (typeof comparator === "string") {
       const key = comparator;
-      comparator = (element, value2) => element[key] === resolveUnref(value2);
+      comparator = (element, value2) => element[key] === toValue(value2);
     }
-    comparator = comparator != null ? comparator : (element, value2) => element === resolveUnref(value2);
-    return vueDemi.computed(() => resolveUnref(list).slice(formIndex).some((element, index, array) => comparator(resolveUnref(element), resolveUnref(value), index, resolveUnref(array))));
+    comparator = comparator != null ? comparator : (element, value2) => element === toValue(value2);
+    return vueDemi.computed(
+      () => toValue(list).slice(formIndex).some(
+        (element, index, array) => comparator(toValue(element), toValue(value), index, toValue(array))
+      )
+    );
   }
 
   function useArrayJoin(list, separator) {
-    return vueDemi.computed(() => resolveUnref(list).map((i) => resolveUnref(i)).join(resolveUnref(separator)));
+    return vueDemi.computed(() => toValue(list).map((i) => toValue(i)).join(toValue(separator)));
   }
 
   function useArrayMap(list, fn) {
-    return vueDemi.computed(() => resolveUnref(list).map((i) => resolveUnref(i)).map(fn));
+    return vueDemi.computed(() => toValue(list).map((i) => toValue(i)).map(fn));
   }
 
   function useArrayReduce(list, reducer, ...args) {
-    const reduceCallback = (sum, value, index) => reducer(resolveUnref(sum), resolveUnref(value), index);
+    const reduceCallback = (sum, value, index) => reducer(toValue(sum), toValue(value), index);
     return vueDemi.computed(() => {
-      const resolved = resolveUnref(list);
-      return args.length ? resolved.reduce(reduceCallback, resolveUnref(args[0])) : resolved.reduce(reduceCallback);
+      const resolved = toValue(list);
+      return args.length ? resolved.reduce(reduceCallback, toValue(args[0])) : resolved.reduce(reduceCallback);
     });
   }
 
   function useArraySome(list, fn) {
-    return vueDemi.computed(() => resolveUnref(list).some((element, index, array) => fn(resolveUnref(element), index, array)));
+    return vueDemi.computed(() => toValue(list).some((element, index, array) => fn(toValue(element), index, array)));
   }
 
   function uniq(array) {
@@ -1061,7 +1123,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
   function useArrayUnique(list, compareFn) {
     return vueDemi.computed(() => {
-      const resolvedList = resolveUnref(list).map((element) => resolveUnref(element));
+      const resolvedList = toValue(list).map((element) => toValue(element));
       return compareFn ? uniqueElementsBy(resolvedList, compareFn) : uniq(resolvedList);
     });
   }
@@ -1085,13 +1147,13 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
 
   const REGEX_PARSE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/;
   const REGEX_FORMAT = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a{1,2}|A{1,2}|m{1,2}|s{1,2}|Z{1,2}|SSS/g;
-  const defaultMeridiem = (hours, minutes, isLowercase, hasPeriod) => {
+  function defaultMeridiem(hours, minutes, isLowercase, hasPeriod) {
     let m = hours < 12 ? "AM" : "PM";
     if (hasPeriod)
       m = m.split("").reduce((acc, curr) => acc += `${curr}.`, "");
     return isLowercase ? m.toLowerCase() : m;
-  };
-  const formatDate = (date, formatStr, options = {}) => {
+  }
+  function formatDate(date, formatStr, options = {}) {
     var _a;
     const years = date.getFullYear();
     const month = date.getMonth();
@@ -1130,12 +1192,12 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       aa: () => meridiem(hours, minutes, true, true)
     };
     return formatStr.replace(REGEX_FORMAT, (match, $1) => $1 || matches[match]());
-  };
-  const normalizeDate = (date) => {
+  }
+  function normalizeDate(date) {
     if (date === null)
-      return new Date(NaN);
+      return /* @__PURE__ */ new Date(NaN);
     if (date === void 0)
-      return new Date();
+      return /* @__PURE__ */ new Date();
     if (date instanceof Date)
       return new Date(date);
     if (typeof date === "string" && !/Z$/i.test(date)) {
@@ -1147,9 +1209,9 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       }
     }
     return new Date(date);
-  };
+  }
   function useDateFormat(date, formatStr = "HH:mm:ss", options = {}) {
-    return vueDemi.computed(() => formatDate(normalizeDate(resolveUnref(date)), resolveUnref(formatStr), options));
+    return vueDemi.computed(() => formatDate(normalizeDate(toValue(date)), toValue(formatStr), options));
   }
 
   function useIntervalFn(cb, interval = 1e3, options = {}) {
@@ -1170,7 +1232,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       clean();
     }
     function resume() {
-      const intervalValue = resolveUnref(interval);
+      const intervalValue = toValue(interval);
       if (intervalValue <= 0)
         return;
       isActive.value = true;
@@ -1223,10 +1285,14 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     const reset = () => {
       counter.value = 0;
     };
-    const controls = useIntervalFn(callback ? () => {
-      update();
-      callback(counter.value);
-    } : update, interval, { immediate });
+    const controls = useIntervalFn(
+      callback ? () => {
+        update();
+        callback(counter.value);
+      } : update,
+      interval,
+      { immediate }
+    );
     if (exposeControls) {
       return __spreadValues$8({
         counter,
@@ -1240,7 +1306,11 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   function useLastChanged(source, options = {}) {
     var _a;
     const ms = vueDemi.ref((_a = options.initialValue) != null ? _a : null);
-    vueDemi.watch(source, () => ms.value = timestamp(), options);
+    vueDemi.watch(
+      source,
+      () => ms.value = timestamp(),
+      options
+    );
     return ms;
   }
 
@@ -1267,7 +1337,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
         isPending.value = false;
         timer = null;
         cb(...args);
-      }, resolveUnref(interval));
+      }, toValue(interval));
     }
     if (immediate) {
       isPending.value = true;
@@ -1303,7 +1373,11 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       controls: exposeControls = false,
       callback
     } = options;
-    const controls = useTimeoutFn(callback != null ? callback : noop, interval, options);
+    const controls = useTimeoutFn(
+      callback != null ? callback : noop,
+      interval,
+      options
+    );
     const ready = vueDemi.computed(() => !controls.isPending.value);
     if (exposeControls) {
       return __spreadValues$7({
@@ -1321,7 +1395,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       nanToZero
     } = options;
     return vueDemi.computed(() => {
-      let resolved = resolveUnref(value);
+      let resolved = toValue(value);
       if (typeof resolved === "string")
         resolved = Number[method](resolved, radix);
       if (nanToZero && isNaN(resolved))
@@ -1331,7 +1405,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   }
 
   function useToString(value) {
-    return vueDemi.computed(() => `${resolveUnref(value)}`);
+    return vueDemi.computed(() => `${toValue(value)}`);
   }
 
   function useToggle(initialValue = false, options = {}) {
@@ -1346,8 +1420,8 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
         _value.value = value;
         return _value.value;
       } else {
-        const truthy = resolveUnref(truthyValue);
-        _value.value = _value.value === truthy ? resolveUnref(falsyValue) : truthy;
+        const truthy = toValue(truthyValue);
+        _value.value = _value.value === truthy ? toValue(falsyValue) : truthy;
         return _value.value;
       }
     }
@@ -1359,7 +1433,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 : vueDemi.unref(source)
+      ...source instanceof Function ? source() : Array.isArray(source) ? source : toValue(source)
     ];
     return vueDemi.watch(source, (newList, _, onCleanup) => {
       const oldListRemains = new Array(oldList.length);
@@ -1403,7 +1477,14 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     } = _a, watchOptions = __objRest$5(_a, [
       "eventFilter"
     ]);
-    return vueDemi.watch(source, createFilterWrapper(eventFilter, cb), watchOptions);
+    return vueDemi.watch(
+      source,
+      createFilterWrapper(
+        eventFilter,
+        cb
+      ),
+      watchOptions
+    );
   }
 
   var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
@@ -1428,12 +1509,16 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       "count"
     ]);
     const current = vueDemi.ref(0);
-    const stop = watchWithFilter(source, (...args) => {
-      current.value += 1;
-      if (current.value >= resolveUnref(count))
-        vueDemi.nextTick(() => stop());
-      cb(...args);
-    }, watchOptions);
+    const stop = watchWithFilter(
+      source,
+      (...args) => {
+        current.value += 1;
+        if (current.value >= toValue(count))
+          vueDemi.nextTick(() => stop());
+        cb(...args);
+      },
+      watchOptions
+    );
     return { count: current, stop };
   }
 
@@ -1476,9 +1561,13 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       "debounce",
       "maxWait"
     ]);
-    return watchWithFilter(source, cb, __spreadProps$6(__spreadValues$6({}, watchOptions), {
-      eventFilter: debounceFilter(debounce, { maxWait })
-    }));
+    return watchWithFilter(
+      source,
+      cb,
+      __spreadProps$6(__spreadValues$6({}, watchOptions), {
+        eventFilter: debounceFilter(debounce, { maxWait })
+      })
+    );
   }
 
   var __defProp$5 = Object.defineProperty;
@@ -1501,12 +1590,13 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   };
   var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
   function watchDeep(source, cb, options) {
-    return vueDemi.watch(source, (v, ov, onInvalidate) => {
-      if (v)
-        cb(v, ov, onInvalidate);
-    }, __spreadProps$5(__spreadValues$5({}, options), {
-      deep: true
-    }));
+    return vueDemi.watch(
+      source,
+      cb,
+      __spreadProps$5(__spreadValues$5({}, options), {
+        deep: true
+      })
+    );
   }
 
   var __defProp$4 = Object.defineProperty;
@@ -1546,7 +1636,10 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     } = _a, watchOptions = __objRest$2(_a, [
       "eventFilter"
     ]);
-    const filteredCb = createFilterWrapper(eventFilter, cb);
+    const filteredCb = createFilterWrapper(
+      eventFilter,
+      cb
+    );
     let ignoreUpdates;
     let ignorePrevAsyncUpdates;
     let stop;
@@ -1559,10 +1652,14 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
         updater();
         ignore.value = false;
       };
-      stop = vueDemi.watch(source, (...args) => {
-        if (!ignore.value)
-          filteredCb(...args);
-      }, watchOptions);
+      stop = vueDemi.watch(
+        source,
+        (...args) => {
+          if (!ignore.value)
+            filteredCb(...args);
+        },
+        watchOptions
+      );
     } else {
       const disposables = [];
       const ignoreCounter = vueDemi.ref(0);
@@ -1570,22 +1667,34 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       ignorePrevAsyncUpdates = () => {
         ignoreCounter.value = syncCounter.value;
       };
-      disposables.push(vueDemi.watch(source, () => {
-        syncCounter.value++;
-      }, __spreadProps$4(__spreadValues$4({}, watchOptions), { flush: "sync" })));
+      disposables.push(
+        vueDemi.watch(
+          source,
+          () => {
+            syncCounter.value++;
+          },
+          __spreadProps$4(__spreadValues$4({}, watchOptions), { flush: "sync" })
+        )
+      );
       ignoreUpdates = (updater) => {
         const syncCounterPrev = syncCounter.value;
         updater();
         ignoreCounter.value += syncCounter.value - syncCounterPrev;
       };
-      disposables.push(vueDemi.watch(source, (...args) => {
-        const ignore = ignoreCounter.value > 0 && ignoreCounter.value === syncCounter.value;
-        ignoreCounter.value = 0;
-        syncCounter.value = 0;
-        if (ignore)
-          return;
-        filteredCb(...args);
-      }, watchOptions));
+      disposables.push(
+        vueDemi.watch(
+          source,
+          (...args) => {
+            const ignore = ignoreCounter.value > 0 && ignoreCounter.value === syncCounter.value;
+            ignoreCounter.value = 0;
+            syncCounter.value = 0;
+            if (ignore)
+              return;
+            filteredCb(...args);
+          },
+          watchOptions
+        )
+      );
       stop = () => {
         disposables.forEach((fn) => fn());
       };
@@ -1613,12 +1722,13 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   };
   var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
   function watchImmediate(source, cb, options) {
-    return vueDemi.watch(source, (v, ov, onInvalidate) => {
-      if (v)
-        cb(v, ov, onInvalidate);
-    }, __spreadProps$3(__spreadValues$3({}, options), {
-      immediate: true
-    }));
+    return vueDemi.watch(
+      source,
+      cb,
+      __spreadProps$3(__spreadValues$3({}, options), {
+        immediate: true
+      })
+    );
   }
 
   function watchOnce(source, cb, options) {
@@ -1666,9 +1776,13 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       "eventFilter"
     ]);
     const { eventFilter, pause, resume, isActive } = pausableFilter(filter);
-    const stop = watchWithFilter(source, cb, __spreadProps$2(__spreadValues$2({}, watchOptions), {
-      eventFilter
-    }));
+    const stop = watchWithFilter(
+      source,
+      cb,
+      __spreadProps$2(__spreadValues$2({}, watchOptions), {
+        eventFilter
+      })
+    );
     return { stop, pause, resume, isActive };
   }
 
@@ -1713,9 +1827,13 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
       "trailing",
       "leading"
     ]);
-    return watchWithFilter(source, cb, __spreadProps$1(__spreadValues$1({}, watchOptions), {
-      eventFilter: throttleFilter(throttle, trailing, leading)
-    }));
+    return watchWithFilter(
+      source,
+      cb,
+      __spreadProps$1(__spreadValues$1({}, watchOptions), {
+        eventFilter: throttleFilter(throttle, trailing, leading)
+      })
+    );
   }
 
   var __defProp = Object.defineProperty;
@@ -1770,21 +1888,22 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
     if (vueDemi.isReactive(sources))
       return sources;
     if (Array.isArray(sources))
-      return sources.map((item) => getOneWatchSource(item));
-    return getOneWatchSource(sources);
-  }
-  function getOneWatchSource(source) {
-    return typeof source === "function" ? source() : vueDemi.unref(source);
+      return sources.map((item) => toValue(item));
+    return toValue(sources);
   }
   function getOldValue(source) {
     return Array.isArray(source) ? source.map(() => void 0) : void 0;
   }
 
   function whenever(source, cb, options) {
-    return vueDemi.watch(source, (v, ov, onInvalidate) => {
-      if (v)
-        cb(v, ov, onInvalidate);
-    }, options);
+    return vueDemi.watch(
+      source,
+      (v, ov, onInvalidate) => {
+        if (v)
+          cb(v, ov, onInvalidate);
+      },
+      options
+    );
   }
 
   exports.__onlyVue27Plus = __onlyVue27Plus;
@@ -1833,6 +1952,7 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   exports.normalizeDate = normalizeDate;
   exports.now = now;
   exports.objectEntries = objectEntries;
+  exports.objectOmit = objectOmit;
   exports.objectPick = objectPick;
   exports.pausableFilter = pausableFilter;
   exports.pausableWatch = watchPausable;
@@ -1858,7 +1978,9 @@ var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
   exports.throttledWatch = watchThrottled;
   exports.timestamp = timestamp;
   exports.toReactive = toReactive;
+  exports.toRef = toRef;
   exports.toRefs = toRefs;
+  exports.toValue = toValue;
   exports.tryOnBeforeMount = tryOnBeforeMount;
   exports.tryOnBeforeUnmount = tryOnBeforeUnmount;
   exports.tryOnMounted = tryOnMounted;