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

package/index.cjs

@@ -56,12 +56,13 @@ const rand = (min, max) => {
   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) {
@@ -84,8 +85,8 @@ function debounceFilter(ms, options = {}) {
     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) {
@@ -130,7 +131,7 @@ function throttleFilter(ms, trailing = true, leading = true, rejectOnCancel = fa
     }
   };
   const filter = (_invoke) => {
-    const duration = resolveUnref(ms);
+    const duration = toValue(ms);
     const elapsed = Date.now() - lastExec;
     const invoke = () => {
       return lastValue = _invoke();
@@ -244,6 +245,11 @@ function objectPick(obj, keys, omitUndefined = false) {
     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);
 }
@@ -291,7 +297,7 @@ function tryOnScopeDispose(fn) {
 }
 
 function createEventHook() {
-  const fns = new Set();
+  const fns = /* @__PURE__ */ new Set();
   const off = (fn) => {
     fns.delete(fn);
   };
@@ -430,7 +436,7 @@ function makeDestructurable(obj, arr) {
 }
 
 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))));
   };
@@ -448,13 +454,15 @@ function reactifyObject(obj, optionsOrKeys = {}) {
     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) {
@@ -497,13 +505,23 @@ function reactiveComputed(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(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) {
@@ -513,7 +531,7 @@ function refAutoReset(defaultValue, afterMs = 1e4) {
     const resetAfter = () => setTimeout(() => {
       value = defaultValue;
       trigger();
-    }, resolveUnref(afterMs));
+    }, toValue(afterMs));
     tryOnScopeDispose(() => {
       clearTimeout(timer);
     });
@@ -533,7 +551,10 @@ function refAutoReset(defaultValue, afterMs = 1e4) {
 }
 
 function useDebounceFn(fn, ms = 200, options = {}) {
-  return createFilterWrapper(debounceFilter(ms, options), fn);
+  return createFilterWrapper(
+    debounceFilter(ms, options),
+    fn
+  );
 }
 
 function refDebounced(value, ms = 200, options = {}) {
@@ -558,7 +579,10 @@ function refDefault(source, defaultValue) {
 }
 
 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) {
@@ -609,21 +633,21 @@ function refWithControl(initial, options = {}) {
   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;
@@ -653,10 +677,18 @@ function syncRef(left, right, options = {}) {
   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();
@@ -672,7 +704,11 @@ function syncRefs(source, targets, options = {}) {
   } = 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;
@@ -751,20 +787,26 @@ 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(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);
   }
@@ -774,23 +816,29 @@ function createUntil(r, isNot = false) {
     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);
   }
@@ -809,7 +857,7 @@ function createUntil(r, isNot = false) {
   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) {
@@ -822,7 +870,7 @@ function createUntil(r, isNot = false) {
       return count >= n;
     }, options);
   }
-  if (Array.isArray(resolveUnref(r))) {
+  if (Array.isArray(toValue(r))) {
     const instance = {
       toMatch,
       toContains,
@@ -854,7 +902,9 @@ function until(r) {
   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];
@@ -864,23 +914,27 @@ function useArrayDifference(...args) {
     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) {
@@ -892,7 +946,11 @@ function findLast(arr, cb) {
   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) {
@@ -910,30 +968,34 @@ function useArrayIncludes(...args) {
   }
   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) {
@@ -948,7 +1010,7 @@ function uniqueElementsBy(array, fn) {
 }
 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);
   });
 }
@@ -972,13 +1034,13 @@ function useCounter(initialValue = 0, options = {}) {
 
 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();
@@ -1017,12 +1079,12 @@ const formatDate = (date, formatStr, options = {}) => {
     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)) {
@@ -1034,9 +1096,9 @@ const normalizeDate = (date) => {
     }
   }
   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 = {}) {
@@ -1057,7 +1119,7 @@ function useIntervalFn(cb, interval = 1e3, options = {}) {
     clean();
   }
   function resume() {
-    const intervalValue = resolveUnref(interval);
+    const intervalValue = toValue(interval);
     if (intervalValue <= 0)
       return;
     isActive.value = true;
@@ -1110,10 +1172,14 @@ function useInterval(interval = 1e3, options = {}) {
   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,
@@ -1127,7 +1193,11 @@ function useInterval(interval = 1e3, options = {}) {
 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;
 }
 
@@ -1154,7 +1224,7 @@ function useTimeoutFn(cb, interval, options = {}) {
       isPending.value = false;
       timer = null;
       cb(...args);
-    }, resolveUnref(interval));
+    }, toValue(interval));
   }
   if (immediate) {
     isPending.value = true;
@@ -1190,7 +1260,11 @@ function useTimeout(interval = 1e3, options = {}) {
     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({
@@ -1208,7 +1282,7 @@ function useToNumber(value, options = {}) {
     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))
@@ -1218,7 +1292,7 @@ function useToNumber(value, options = {}) {
 }
 
 function useToString(value) {
-  return vueDemi.computed(() => `${resolveUnref(value)}`);
+  return vueDemi.computed(() => `${toValue(value)}`);
 }
 
 function useToggle(initialValue = false, options = {}) {
@@ -1233,8 +1307,8 @@ function useToggle(initialValue = false, options = {}) {
       _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;
     }
   }
@@ -1246,7 +1320,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 : 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);
@@ -1290,7 +1364,14 @@ function watchWithFilter(source, cb, options = {}) {
   } = _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;
@@ -1315,12 +1396,16 @@ function watchAtMost(source, cb, options) {
     "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 };
 }
 
@@ -1363,9 +1448,13 @@ function watchDebounced(source, cb, options = {}) {
     "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;
@@ -1388,12 +1477,13 @@ var __spreadValues$5 = (a, b) => {
 };
 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;
@@ -1433,7 +1523,10 @@ function watchIgnorable(source, cb, options = {}) {
   } = _a, watchOptions = __objRest$2(_a, [
     "eventFilter"
   ]);
-  const filteredCb = createFilterWrapper(eventFilter, cb);
+  const filteredCb = createFilterWrapper(
+    eventFilter,
+    cb
+  );
   let ignoreUpdates;
   let ignorePrevAsyncUpdates;
   let stop;
@@ -1446,10 +1539,14 @@ function watchIgnorable(source, cb, options = {}) {
       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);
@@ -1457,22 +1554,34 @@ function watchIgnorable(source, cb, options = {}) {
     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());
     };
@@ -1500,12 +1609,13 @@ var __spreadValues$3 = (a, b) => {
 };
 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) {
@@ -1553,9 +1663,13 @@ function watchPausable(source, cb, options = {}) {
     "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 };
 }
 
@@ -1600,9 +1714,13 @@ function watchThrottled(source, cb, options = {}) {
     "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;
@@ -1657,21 +1775,22 @@ function getWatchSources(sources) {
   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;
@@ -1720,6 +1839,7 @@ exports.noop = noop;
 exports.normalizeDate = normalizeDate;
 exports.now = now;
 exports.objectEntries = objectEntries;
+exports.objectOmit = objectOmit;
 exports.objectPick = objectPick;
 exports.pausableFilter = pausableFilter;
 exports.pausableWatch = watchPausable;
@@ -1745,7 +1865,9 @@ exports.throttledRef = refThrottled;
 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;