@vueuse/shared 12.2.0 → 12.3.0

package/index.cjs

@@ -208,13 +208,8 @@ function makeDestructurable(obj, arr) {
   }
 }
 
-function toValue(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 ? vue.unref : toValue;
+  const unrefFn = (options == null ? void 0 : options.computedGetter) === false ? vue.unref : vue.toValue;
   return function(...args) {
     return vue.computed(() => fn.apply(this, args.map((i) => unrefFn(i))));
   };
@@ -283,7 +278,7 @@ function reactiveComputed(fn) {
 function reactiveOmit(obj, ...keys) {
   const flatKeys = keys.flat();
   const predicate = flatKeys[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]))));
+  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(vue.toRefs(obj)).filter(([k, v]) => !predicate(vue.toValue(v), k))) : Object.fromEntries(Object.entries(vue.toRefs(obj)).filter((e) => !flatKeys.includes(e[0]))));
 }
 
 const isClient = typeof window !== "undefined" && typeof document !== "undefined";
@@ -334,8 +329,8 @@ function debounceFilter(ms, options = {}) {
     lastRejector = noop;
   };
   const filter = (invoke) => {
-    const duration = toValue(ms);
-    const maxDuration = toValue(options.maxWait);
+    const duration = vue.toValue(ms);
+    const maxDuration = vue.toValue(options.maxWait);
     if (timer)
       _clearTimeout(timer);
     if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
@@ -388,7 +383,7 @@ function throttleFilter(...args) {
     }
   };
   const filter = (_invoke) => {
-    const duration = toValue(ms);
+    const duration = vue.toValue(ms);
     const elapsed = Date.now() - lastExec;
     const invoke = () => {
       return lastValue = _invoke();
@@ -514,6 +509,9 @@ function objectEntries(obj) {
 function getLifeCycleTarget(target) {
   return target || vue.getCurrentInstance();
 }
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
 
 function toRef(...args) {
   if (args.length !== 1)
@@ -526,17 +524,17 @@ const resolveRef = toRef;
 function reactivePick(obj, ...keys) {
   const flatKeys = keys.flat();
   const predicate = flatKeys[0];
-  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)])));
+  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(vue.toRefs(obj)).filter(([k, v]) => predicate(vue.toValue(v), k))) : Object.fromEntries(flatKeys.map((k) => [k, toRef(obj, k)])));
 }
 
 function refAutoReset(defaultValue, afterMs = 1e4) {
   return vue.customRef((track, trigger) => {
-    let value = toValue(defaultValue);
+    let value = vue.toValue(defaultValue);
     let timer;
     const resetAfter = () => setTimeout(() => {
-      value = toValue(defaultValue);
+      value = vue.toValue(defaultValue);
       trigger();
-    }, toValue(afterMs));
+    }, vue.toValue(afterMs));
     tryOnScopeDispose(() => {
       clearTimeout(timer);
     });
@@ -741,8 +739,7 @@ function syncRefs(source, targets, options = {}) {
     deep = false,
     immediate = true
   } = options;
-  if (!Array.isArray(targets))
-    targets = [targets];
+  targets = toArray(targets);
   return vue.watch(
     source,
     (newValue) => targets.forEach((target) => target.value = newValue),
@@ -761,7 +758,7 @@ function toRefs(objectRef, options = {}) {
       },
       set(v) {
         var _a;
-        const replaceRef = (_a = toValue(options.replaceRef)) != null ? _a : true;
+        const replaceRef = (_a = vue.toValue(options.replaceRef)) != null ? _a : true;
         if (replaceRef) {
           if (Array.isArray(objectRef.value)) {
             const copy = [...objectRef.value];
@@ -781,6 +778,9 @@ function toRefs(objectRef, options = {}) {
   return result;
 }
 
+const toValue = vue.toValue;
+const resolveUnref = vue.toValue;
+
 function tryOnBeforeMount(fn, sync = true, target) {
   const instance = getLifeCycleTarget(target);
   if (instance)
@@ -838,7 +838,7 @@ function createUntil(r, isNot = false) {
     const promises = [watcher];
     if (timeout != null) {
       promises.push(
-        promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => stop == null ? void 0 : stop())
+        promiseTimeout(timeout, throwOnTimeout).then(() => vue.toValue(r)).finally(() => stop == null ? void 0 : stop())
       );
     }
     return Promise.race(promises);
@@ -870,9 +870,9 @@ function createUntil(r, isNot = false) {
     const promises = [watcher];
     if (timeout != null) {
       promises.push(
-        promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => {
+        promiseTimeout(timeout, throwOnTimeout).then(() => vue.toValue(r)).finally(() => {
           stop == null ? void 0 : stop();
-          return toValue(r);
+          return vue.toValue(r);
         })
       );
     }
@@ -893,7 +893,7 @@ function createUntil(r, isNot = false) {
   function toContains(value, options) {
     return toMatch((v) => {
       const array = Array.from(v);
-      return array.includes(value) || array.includes(toValue(value));
+      return array.includes(value) || array.includes(vue.toValue(value));
     }, options);
   }
   function changed(options) {
@@ -906,7 +906,7 @@ function createUntil(r, isNot = false) {
       return count >= n;
     }, options);
   }
-  if (Array.isArray(toValue(r))) {
+  if (Array.isArray(vue.toValue(r))) {
     const instance = {
       toMatch,
       toContains,
@@ -953,31 +953,31 @@ function useArrayDifference(...args) {
     const key = compareFn;
     compareFn = (value, othVal) => value[key] === othVal[key];
   }
-  const diff1 = vue.computed(() => toValue(list).filter((x) => toValue(values).findIndex((y) => compareFn(x, y)) === -1));
+  const diff1 = vue.computed(() => vue.toValue(list).filter((x) => vue.toValue(values).findIndex((y) => compareFn(x, y)) === -1));
   if (symmetric) {
-    const diff2 = vue.computed(() => toValue(values).filter((x) => toValue(list).findIndex((y) => compareFn(x, y)) === -1));
-    return vue.computed(() => symmetric ? [...toValue(diff1), ...toValue(diff2)] : toValue(diff1));
+    const diff2 = vue.computed(() => vue.toValue(values).filter((x) => vue.toValue(list).findIndex((y) => compareFn(x, y)) === -1));
+    return vue.computed(() => symmetric ? [...vue.toValue(diff1), ...vue.toValue(diff2)] : vue.toValue(diff1));
   } else {
     return diff1;
   }
 }
 
 function useArrayEvery(list, fn) {
-  return vue.computed(() => toValue(list).every((element, index, array) => fn(toValue(element), index, array)));
+  return vue.computed(() => vue.toValue(list).every((element, index, array) => fn(vue.toValue(element), index, array)));
 }
 
 function useArrayFilter(list, fn) {
-  return vue.computed(() => toValue(list).map((i) => toValue(i)).filter(fn));
+  return vue.computed(() => vue.toValue(list).map((i) => vue.toValue(i)).filter(fn));
 }
 
 function useArrayFind(list, fn) {
-  return vue.computed(() => toValue(
-    toValue(list).find((element, index, array) => fn(toValue(element), index, array))
+  return vue.computed(() => vue.toValue(
+    vue.toValue(list).find((element, index, array) => fn(vue.toValue(element), index, array))
   ));
 }
 
 function useArrayFindIndex(list, fn) {
-  return vue.computed(() => toValue(list).findIndex((element, index, array) => fn(toValue(element), index, array)));
+  return vue.computed(() => vue.toValue(list).findIndex((element, index, array) => fn(vue.toValue(element), index, array)));
 }
 
 function findLast(arr, cb) {
@@ -989,8 +989,8 @@ function findLast(arr, cb) {
   return void 0;
 }
 function useArrayFindLast(list, fn) {
-  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))
+  return vue.computed(() => vue.toValue(
+    !Array.prototype.findLast ? findLast(vue.toValue(list), (element, index, array) => fn(vue.toValue(element), index, array)) : vue.toValue(list).findLast((element, index, array) => fn(vue.toValue(element), index, array))
   ));
 }
 
@@ -1009,35 +1009,35 @@ function useArrayIncludes(...args) {
   }
   if (typeof comparator === "string") {
     const key = comparator;
-    comparator = (element, value2) => element[key] === toValue(value2);
+    comparator = (element, value2) => element[key] === vue.toValue(value2);
   }
-  comparator = comparator != null ? comparator : (element, value2) => element === toValue(value2);
-  return vue.computed(() => toValue(list).slice(formIndex).some((element, index, array) => comparator(
-    toValue(element),
-    toValue(value),
+  comparator = comparator != null ? comparator : (element, value2) => element === vue.toValue(value2);
+  return vue.computed(() => vue.toValue(list).slice(formIndex).some((element, index, array) => comparator(
+    vue.toValue(element),
+    vue.toValue(value),
     index,
-    toValue(array)
+    vue.toValue(array)
   )));
 }
 
 function useArrayJoin(list, separator) {
-  return vue.computed(() => toValue(list).map((i) => toValue(i)).join(toValue(separator)));
+  return vue.computed(() => vue.toValue(list).map((i) => vue.toValue(i)).join(vue.toValue(separator)));
 }
 
 function useArrayMap(list, fn) {
-  return vue.computed(() => toValue(list).map((i) => toValue(i)).map(fn));
+  return vue.computed(() => vue.toValue(list).map((i) => vue.toValue(i)).map(fn));
 }
 
 function useArrayReduce(list, reducer, ...args) {
-  const reduceCallback = (sum, value, index) => reducer(toValue(sum), toValue(value), index);
+  const reduceCallback = (sum, value, index) => reducer(vue.toValue(sum), vue.toValue(value), index);
   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);
+    const resolved = vue.toValue(list);
+    return args.length ? resolved.reduce(reduceCallback, typeof args[0] === "function" ? vue.toValue(args[0]()) : vue.toValue(args[0])) : resolved.reduce(reduceCallback);
   });
 }
 
 function useArraySome(list, fn) {
-  return vue.computed(() => toValue(list).some((element, index, array) => fn(toValue(element), index, array)));
+  return vue.computed(() => vue.toValue(list).some((element, index, array) => fn(vue.toValue(element), index, array)));
 }
 
 function uniq(array) {
@@ -1052,7 +1052,7 @@ function uniqueElementsBy(array, fn) {
 }
 function useArrayUnique(list, compareFn) {
   return vue.computed(() => {
-    const resolvedList = toValue(list).map((element) => toValue(element));
+    const resolvedList = vue.toValue(list).map((element) => vue.toValue(element));
     return compareFn ? uniqueElementsBy(resolvedList, compareFn) : uniq(resolvedList);
   });
 }
@@ -1106,8 +1106,8 @@ function formatDate(date, formatStr, options = {}) {
     M: () => month + 1,
     Mo: () => formatOrdinal(month + 1),
     MM: () => `${month + 1}`.padStart(2, "0"),
-    MMM: () => date.toLocaleDateString(toValue(options.locales), { month: "short" }),
-    MMMM: () => date.toLocaleDateString(toValue(options.locales), { month: "long" }),
+    MMM: () => date.toLocaleDateString(vue.toValue(options.locales), { month: "short" }),
+    MMMM: () => date.toLocaleDateString(vue.toValue(options.locales), { month: "long" }),
     D: () => String(days),
     Do: () => formatOrdinal(days),
     DD: () => `${days}`.padStart(2, "0"),
@@ -1125,9 +1125,9 @@ function formatDate(date, formatStr, options = {}) {
     ss: () => `${seconds}`.padStart(2, "0"),
     SSS: () => `${milliseconds}`.padStart(3, "0"),
     d: () => day,
-    dd: () => date.toLocaleDateString(toValue(options.locales), { weekday: "narrow" }),
-    ddd: () => date.toLocaleDateString(toValue(options.locales), { weekday: "short" }),
-    dddd: () => date.toLocaleDateString(toValue(options.locales), { weekday: "long" }),
+    dd: () => date.toLocaleDateString(vue.toValue(options.locales), { weekday: "narrow" }),
+    ddd: () => date.toLocaleDateString(vue.toValue(options.locales), { weekday: "short" }),
+    dddd: () => date.toLocaleDateString(vue.toValue(options.locales), { weekday: "long" }),
     A: () => meridiem(hours, minutes),
     AA: () => meridiem(hours, minutes, false, true),
     a: () => meridiem(hours, minutes, true),
@@ -1156,7 +1156,7 @@ function normalizeDate(date) {
   return new Date(date);
 }
 function useDateFormat(date, formatStr = "HH:mm:ss", options = {}) {
-  return vue.computed(() => formatDate(normalizeDate(toValue(date)), toValue(formatStr), options));
+  return vue.computed(() => formatDate(normalizeDate(vue.toValue(date)), vue.toValue(formatStr), options));
 }
 
 function useIntervalFn(cb, interval = 1e3, options = {}) {
@@ -1177,7 +1177,7 @@ function useIntervalFn(cb, interval = 1e3, options = {}) {
     clean();
   }
   function resume() {
-    const intervalValue = toValue(interval);
+    const intervalValue = vue.toValue(interval);
     if (intervalValue <= 0)
       return;
     isActive.value = true;
@@ -1268,7 +1268,7 @@ function useTimeoutFn(cb, interval, options = {}) {
       isPending.value = false;
       timer = null;
       cb(...args);
-    }, toValue(interval));
+    }, vue.toValue(interval));
   }
   if (immediate) {
     isPending.value = true;
@@ -1311,8 +1311,10 @@ function useToNumber(value, options = {}) {
     nanToZero
   } = options;
   return vue.computed(() => {
-    let resolved = toValue(value);
-    if (typeof resolved === "string")
+    let resolved = vue.toValue(value);
+    if (typeof method === "function")
+      resolved = method(resolved);
+    else if (typeof resolved === "string")
       resolved = Number[method](resolved, radix);
     if (nanToZero && Number.isNaN(resolved))
       resolved = 0;
@@ -1321,7 +1323,7 @@ function useToNumber(value, options = {}) {
 }
 
 function useToString(value) {
-  return vue.computed(() => `${toValue(value)}`);
+  return vue.computed(() => `${vue.toValue(value)}`);
 }
 
 function useToggle(initialValue = false, options = {}) {
@@ -1336,8 +1338,8 @@ function useToggle(initialValue = false, options = {}) {
       _value.value = value;
       return _value.value;
     } else {
-      const truthy = toValue(truthyValue);
-      _value.value = _value.value === truthy ? toValue(falsyValue) : truthy;
+      const truthy = vue.toValue(truthyValue);
+      _value.value = _value.value === truthy ? vue.toValue(falsyValue) : truthy;
       return _value.value;
     }
   }
@@ -1348,7 +1350,7 @@ function useToggle(initialValue = false, options = {}) {
 }
 
 function watchArray(source, cb, options) {
-  let oldList = (options == null ? void 0 : options.immediate) ? [] : [...source instanceof Function ? source() : Array.isArray(source) ? source : toValue(source)];
+  let oldList = (options == null ? void 0 : options.immediate) ? [] : [...source instanceof Function ? source() : Array.isArray(source) ? source : vue.toValue(source)];
   return vue.watch(source, (newList, _, onCleanup) => {
     const oldListRemains = Array.from({ length: oldList.length });
     const added = [];
@@ -1380,7 +1382,7 @@ function watchAtMost(source, cb, options) {
     source,
     (...args) => {
       current.value += 1;
-      if (current.value >= toValue(count))
+      if (current.value >= vue.toValue(count))
         vue.nextTick(() => stop());
       cb(...args);
     },
@@ -1557,8 +1559,8 @@ function getWatchSources(sources) {
   if (vue.isReactive(sources))
     return sources;
   if (Array.isArray(sources))
-    return sources.map((item) => toValue(item));
-  return toValue(sources);
+    return sources.map((item) => vue.toValue(item));
+  return vue.toValue(sources);
 }
 function getOldValue(source) {
   return Array.isArray(source) ? source.map(() => void 0) : void 0;
@@ -1653,6 +1655,7 @@ exports.throttleFilter = throttleFilter;
 exports.throttledRef = refThrottled;
 exports.throttledWatch = watchThrottled;
 exports.timestamp = timestamp;
+exports.toArray = toArray;
 exports.toReactive = toReactive;
 exports.toRef = toRef;
 exports.toRefs = toRefs;

package/index.d.cts

@@ -1,5 +1,5 @@
 import * as vue from 'vue';
-import { WatchOptionsBase, Ref, ComputedRef, WritableComputedRef, WatchSource, ComputedGetter, WritableComputedOptions, MaybeRef, WatchOptions, MaybeRefOrGetter, InjectionKey, ShallowUnwrapRef as ShallowUnwrapRef$1, inject, provide, UnwrapNestedRefs, UnwrapRef, ToRef, ToRefs, WatchCallback, WatchStopHandle } from 'vue';
+import { WatchOptionsBase, Ref, ComputedRef, WritableComputedRef, WatchSource, ComputedGetter, WritableComputedOptions, MaybeRef, WatchOptions, MaybeRefOrGetter, InjectionKey, ShallowUnwrapRef as ShallowUnwrapRef$1, inject, provide, UnwrapNestedRefs, UnwrapRef, ToRef, ToRefs, toValue as toValue$1, WatchCallback, WatchStopHandle } from 'vue';
 export { MaybeRef, MaybeRefOrGetter } from 'vue';
 
 /**
@@ -301,6 +301,7 @@ declare function objectPick<O extends object, T extends keyof O>(obj: O, keys: T
 declare function objectOmit<O extends object, T extends keyof O>(obj: O, keys: T[], omitUndefined?: boolean): Omit<O, T>;
 declare function objectEntries<T extends object>(obj: T): Array<[keyof T, T[keyof T]]>;
 declare function getLifeCycleTarget(target?: any): any;
+declare function toArray<T>(value: T): T extends readonly any[] ? T : [T];
 
 /**
  * Keep states in the global scope to be reusable across Vue instances.
@@ -644,12 +645,14 @@ declare function toRefs<T extends object>(objectRef: MaybeRef<T>, options?: ToRe
 
 /**
  * Get the value of value/ref/getter.
+ *
+ * @deprecated use `toValue` from `vue` instead
  */
-declare function toValue<T>(r: MaybeRefOrGetter<T>): T;
+declare const toValue: typeof toValue$1;
 /**
  * @deprecated use `toValue` instead
  */
-declare const resolveUnref: typeof toValue;
+declare const resolveUnref: typeof toValue$1;
 
 /**
  * Call onBeforeMount() if it's inside a component lifecycle, if not, just call the function
@@ -1091,9 +1094,11 @@ interface UseToNumberOptions {
     /**
      * Method to use to convert the value to a number.
      *
+     * Or a custom function for the conversion.
+     *
      * @default 'parseFloat'
      */
-    method?: 'parseFloat' | 'parseInt';
+    method?: 'parseFloat' | 'parseInt' | ((value: string | number) => number);
     /**
      * The base in mathematical numeral systems passed to `parseInt`.
      * Only works with `method: 'parseInt'`
@@ -1220,4 +1225,4 @@ interface WheneverOptions extends WatchOptions {
  */
 declare function whenever<T>(source: WatchSource<T | false | null | undefined>, cb: WatchCallback<T>, options?: WheneverOptions): vue.WatchHandle;
 
-export { type AnyFn, type ArgumentsType, type Arrayable, type Awaitable, type Awaited, type ComputedRefWithControl, type ComputedWithControlRefExtra, type ConfigurableEventFilter, type ConfigurableFlush, type ConfigurableFlushSync, type ControlledRefOptions, type CreateInjectionStateOptions, type DateLike, type DebounceFilterOptions, type DeepMaybeRef, type ElementOf, type EventFilter, type EventHook, type EventHookOff, type EventHookOn, type EventHookTrigger, type ExtendRefOptions, type Fn, type FunctionArgs, type FunctionWrapperOptions, type IfAny, type IgnoredUpdater, type IsAny, type MapOldSources, type MapSources, type MultiWatchSources, type Mutable, type Pausable, type Promisify, type PromisifyFn, type Reactified, type ReactifyNested, type ReactifyObjectOptions, type ReactifyOptions, type ReactiveOmitPredicate, type ReactivePickPredicate, type ReadonlyRefOrGetter, type RemovableRef, type ShallowUnwrapRef, type SingletonPromiseReturn, type Stoppable, type SyncRefOptions, type SyncRefsOptions, type ThrottleFilterOptions, type ToRefsOptions, type UntilArrayInstance, type UntilBaseInstance, type UntilToMatchOptions, type UntilValueInstance, type UseArrayDifferenceOptions, type UseArrayIncludesComparatorFn, type UseArrayIncludesOptions, type UseArrayReducer, type UseCounterOptions, type UseDateFormatOptions, type UseDateFormatReturn, type UseIntervalControls, type UseIntervalFnOptions, type UseIntervalOptions, type UseLastChangedOptions, type UseTimeoutFnOptions, type UseTimeoutOptions, type UseToNumberOptions, type UseToggleOptions, type WatchArrayCallback, type WatchAtMostOptions, type WatchAtMostReturn, type WatchDebouncedOptions, type WatchIgnorableReturn, type WatchPausableReturn, type WatchThrottledOptions, type WatchTriggerableCallback, type WatchTriggerableReturn, type WatchWithFilterOptions, type WheneverOptions, type WritableComputedRefWithControl, assert, refAutoReset as autoResetRef, bypassFilter, camelize, clamp, computedEager, computedWithControl, containsProp, computedWithControl as controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, reactify as createReactiveFn, createSharedComposable, createSingletonPromise, debounceFilter, refDebounced as debouncedRef, watchDebounced as debouncedWatch, computedEager as eagerComputed, extendRef, formatDate, get, getLifeCycleTarget, hasOwn, hyphenate, identity, watchIgnorable as ignorableWatch, increaseWithUnit, injectLocal, invoke, isClient, isDef, isDefined, isIOS, isObject, isWorker, makeDestructurable, noop, normalizeDate, notNullish, now, objectEntries, objectOmit, objectPick, pausableFilter, watchPausable as pausableWatch, promiseTimeout, provideLocal, pxValue, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refThrottled, refWithControl, resolveRef, resolveUnref, set, syncRef, syncRefs, throttleFilter, refThrottled as throttledRef, watchThrottled as throttledWatch, timestamp, toReactive, toRef, toRefs, toValue, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayDifference, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayFindLast, useArrayIncludes, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useArrayUnique, useCounter, useDateFormat, refDebounced as useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, refThrottled as useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToNumber, useToString, useToggle, watchArray, watchAtMost, watchDebounced, watchDeep, watchIgnorable, watchImmediate, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };
+export { type AnyFn, type ArgumentsType, type Arrayable, type Awaitable, type Awaited, type ComputedRefWithControl, type ComputedWithControlRefExtra, type ConfigurableEventFilter, type ConfigurableFlush, type ConfigurableFlushSync, type ControlledRefOptions, type CreateInjectionStateOptions, type DateLike, type DebounceFilterOptions, type DeepMaybeRef, type ElementOf, type EventFilter, type EventHook, type EventHookOff, type EventHookOn, type EventHookTrigger, type ExtendRefOptions, type Fn, type FunctionArgs, type FunctionWrapperOptions, type IfAny, type IgnoredUpdater, type IsAny, type MapOldSources, type MapSources, type MultiWatchSources, type Mutable, type Pausable, type Promisify, type PromisifyFn, type Reactified, type ReactifyNested, type ReactifyObjectOptions, type ReactifyOptions, type ReactiveOmitPredicate, type ReactivePickPredicate, type ReadonlyRefOrGetter, type RemovableRef, type ShallowUnwrapRef, type SingletonPromiseReturn, type Stoppable, type SyncRefOptions, type SyncRefsOptions, type ThrottleFilterOptions, type ToRefsOptions, type UntilArrayInstance, type UntilBaseInstance, type UntilToMatchOptions, type UntilValueInstance, type UseArrayDifferenceOptions, type UseArrayIncludesComparatorFn, type UseArrayIncludesOptions, type UseArrayReducer, type UseCounterOptions, type UseDateFormatOptions, type UseDateFormatReturn, type UseIntervalControls, type UseIntervalFnOptions, type UseIntervalOptions, type UseLastChangedOptions, type UseTimeoutFnOptions, type UseTimeoutOptions, type UseToNumberOptions, type UseToggleOptions, type WatchArrayCallback, type WatchAtMostOptions, type WatchAtMostReturn, type WatchDebouncedOptions, type WatchIgnorableReturn, type WatchPausableReturn, type WatchThrottledOptions, type WatchTriggerableCallback, type WatchTriggerableReturn, type WatchWithFilterOptions, type WheneverOptions, type WritableComputedRefWithControl, assert, refAutoReset as autoResetRef, bypassFilter, camelize, clamp, computedEager, computedWithControl, containsProp, computedWithControl as controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, reactify as createReactiveFn, createSharedComposable, createSingletonPromise, debounceFilter, refDebounced as debouncedRef, watchDebounced as debouncedWatch, computedEager as eagerComputed, extendRef, formatDate, get, getLifeCycleTarget, hasOwn, hyphenate, identity, watchIgnorable as ignorableWatch, increaseWithUnit, injectLocal, invoke, isClient, isDef, isDefined, isIOS, isObject, isWorker, makeDestructurable, noop, normalizeDate, notNullish, now, objectEntries, objectOmit, objectPick, pausableFilter, watchPausable as pausableWatch, promiseTimeout, provideLocal, pxValue, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refThrottled, refWithControl, resolveRef, resolveUnref, set, syncRef, syncRefs, throttleFilter, refThrottled as throttledRef, watchThrottled as throttledWatch, timestamp, toArray, toReactive, toRef, toRefs, toValue, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayDifference, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayFindLast, useArrayIncludes, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useArrayUnique, useCounter, useDateFormat, refDebounced as useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, refThrottled as useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToNumber, useToString, useToggle, watchArray, watchAtMost, watchDebounced, watchDeep, watchIgnorable, watchImmediate, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };

package/index.d.mts

@@ -1,5 +1,5 @@
 import * as vue from 'vue';
-import { WatchOptionsBase, Ref, ComputedRef, WritableComputedRef, WatchSource, ComputedGetter, WritableComputedOptions, MaybeRef, WatchOptions, MaybeRefOrGetter, InjectionKey, ShallowUnwrapRef as ShallowUnwrapRef$1, inject, provide, UnwrapNestedRefs, UnwrapRef, ToRef, ToRefs, WatchCallback, WatchStopHandle } from 'vue';
+import { WatchOptionsBase, Ref, ComputedRef, WritableComputedRef, WatchSource, ComputedGetter, WritableComputedOptions, MaybeRef, WatchOptions, MaybeRefOrGetter, InjectionKey, ShallowUnwrapRef as ShallowUnwrapRef$1, inject, provide, UnwrapNestedRefs, UnwrapRef, ToRef, ToRefs, toValue as toValue$1, WatchCallback, WatchStopHandle } from 'vue';
 export { MaybeRef, MaybeRefOrGetter } from 'vue';
 
 /**
@@ -301,6 +301,7 @@ declare function objectPick<O extends object, T extends keyof O>(obj: O, keys: T
 declare function objectOmit<O extends object, T extends keyof O>(obj: O, keys: T[], omitUndefined?: boolean): Omit<O, T>;
 declare function objectEntries<T extends object>(obj: T): Array<[keyof T, T[keyof T]]>;
 declare function getLifeCycleTarget(target?: any): any;
+declare function toArray<T>(value: T): T extends readonly any[] ? T : [T];
 
 /**
  * Keep states in the global scope to be reusable across Vue instances.
@@ -644,12 +645,14 @@ declare function toRefs<T extends object>(objectRef: MaybeRef<T>, options?: ToRe
 
 /**
  * Get the value of value/ref/getter.
+ *
+ * @deprecated use `toValue` from `vue` instead
  */
-declare function toValue<T>(r: MaybeRefOrGetter<T>): T;
+declare const toValue: typeof toValue$1;
 /**
  * @deprecated use `toValue` instead
  */
-declare const resolveUnref: typeof toValue;
+declare const resolveUnref: typeof toValue$1;
 
 /**
  * Call onBeforeMount() if it's inside a component lifecycle, if not, just call the function
@@ -1091,9 +1094,11 @@ interface UseToNumberOptions {
     /**
      * Method to use to convert the value to a number.
      *
+     * Or a custom function for the conversion.
+     *
      * @default 'parseFloat'
      */
-    method?: 'parseFloat' | 'parseInt';
+    method?: 'parseFloat' | 'parseInt' | ((value: string | number) => number);
     /**
      * The base in mathematical numeral systems passed to `parseInt`.
      * Only works with `method: 'parseInt'`
@@ -1220,4 +1225,4 @@ interface WheneverOptions extends WatchOptions {
  */
 declare function whenever<T>(source: WatchSource<T | false | null | undefined>, cb: WatchCallback<T>, options?: WheneverOptions): vue.WatchHandle;
 
-export { type AnyFn, type ArgumentsType, type Arrayable, type Awaitable, type Awaited, type ComputedRefWithControl, type ComputedWithControlRefExtra, type ConfigurableEventFilter, type ConfigurableFlush, type ConfigurableFlushSync, type ControlledRefOptions, type CreateInjectionStateOptions, type DateLike, type DebounceFilterOptions, type DeepMaybeRef, type ElementOf, type EventFilter, type EventHook, type EventHookOff, type EventHookOn, type EventHookTrigger, type ExtendRefOptions, type Fn, type FunctionArgs, type FunctionWrapperOptions, type IfAny, type IgnoredUpdater, type IsAny, type MapOldSources, type MapSources, type MultiWatchSources, type Mutable, type Pausable, type Promisify, type PromisifyFn, type Reactified, type ReactifyNested, type ReactifyObjectOptions, type ReactifyOptions, type ReactiveOmitPredicate, type ReactivePickPredicate, type ReadonlyRefOrGetter, type RemovableRef, type ShallowUnwrapRef, type SingletonPromiseReturn, type Stoppable, type SyncRefOptions, type SyncRefsOptions, type ThrottleFilterOptions, type ToRefsOptions, type UntilArrayInstance, type UntilBaseInstance, type UntilToMatchOptions, type UntilValueInstance, type UseArrayDifferenceOptions, type UseArrayIncludesComparatorFn, type UseArrayIncludesOptions, type UseArrayReducer, type UseCounterOptions, type UseDateFormatOptions, type UseDateFormatReturn, type UseIntervalControls, type UseIntervalFnOptions, type UseIntervalOptions, type UseLastChangedOptions, type UseTimeoutFnOptions, type UseTimeoutOptions, type UseToNumberOptions, type UseToggleOptions, type WatchArrayCallback, type WatchAtMostOptions, type WatchAtMostReturn, type WatchDebouncedOptions, type WatchIgnorableReturn, type WatchPausableReturn, type WatchThrottledOptions, type WatchTriggerableCallback, type WatchTriggerableReturn, type WatchWithFilterOptions, type WheneverOptions, type WritableComputedRefWithControl, assert, refAutoReset as autoResetRef, bypassFilter, camelize, clamp, computedEager, computedWithControl, containsProp, computedWithControl as controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, reactify as createReactiveFn, createSharedComposable, createSingletonPromise, debounceFilter, refDebounced as debouncedRef, watchDebounced as debouncedWatch, computedEager as eagerComputed, extendRef, formatDate, get, getLifeCycleTarget, hasOwn, hyphenate, identity, watchIgnorable as ignorableWatch, increaseWithUnit, injectLocal, invoke, isClient, isDef, isDefined, isIOS, isObject, isWorker, makeDestructurable, noop, normalizeDate, notNullish, now, objectEntries, objectOmit, objectPick, pausableFilter, watchPausable as pausableWatch, promiseTimeout, provideLocal, pxValue, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refThrottled, refWithControl, resolveRef, resolveUnref, set, syncRef, syncRefs, throttleFilter, refThrottled as throttledRef, watchThrottled as throttledWatch, timestamp, toReactive, toRef, toRefs, toValue, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayDifference, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayFindLast, useArrayIncludes, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useArrayUnique, useCounter, useDateFormat, refDebounced as useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, refThrottled as useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToNumber, useToString, useToggle, watchArray, watchAtMost, watchDebounced, watchDeep, watchIgnorable, watchImmediate, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };
+export { type AnyFn, type ArgumentsType, type Arrayable, type Awaitable, type Awaited, type ComputedRefWithControl, type ComputedWithControlRefExtra, type ConfigurableEventFilter, type ConfigurableFlush, type ConfigurableFlushSync, type ControlledRefOptions, type CreateInjectionStateOptions, type DateLike, type DebounceFilterOptions, type DeepMaybeRef, type ElementOf, type EventFilter, type EventHook, type EventHookOff, type EventHookOn, type EventHookTrigger, type ExtendRefOptions, type Fn, type FunctionArgs, type FunctionWrapperOptions, type IfAny, type IgnoredUpdater, type IsAny, type MapOldSources, type MapSources, type MultiWatchSources, type Mutable, type Pausable, type Promisify, type PromisifyFn, type Reactified, type ReactifyNested, type ReactifyObjectOptions, type ReactifyOptions, type ReactiveOmitPredicate, type ReactivePickPredicate, type ReadonlyRefOrGetter, type RemovableRef, type ShallowUnwrapRef, type SingletonPromiseReturn, type Stoppable, type SyncRefOptions, type SyncRefsOptions, type ThrottleFilterOptions, type ToRefsOptions, type UntilArrayInstance, type UntilBaseInstance, type UntilToMatchOptions, type UntilValueInstance, type UseArrayDifferenceOptions, type UseArrayIncludesComparatorFn, type UseArrayIncludesOptions, type UseArrayReducer, type UseCounterOptions, type UseDateFormatOptions, type UseDateFormatReturn, type UseIntervalControls, type UseIntervalFnOptions, type UseIntervalOptions, type UseLastChangedOptions, type UseTimeoutFnOptions, type UseTimeoutOptions, type UseToNumberOptions, type UseToggleOptions, type WatchArrayCallback, type WatchAtMostOptions, type WatchAtMostReturn, type WatchDebouncedOptions, type WatchIgnorableReturn, type WatchPausableReturn, type WatchThrottledOptions, type WatchTriggerableCallback, type WatchTriggerableReturn, type WatchWithFilterOptions, type WheneverOptions, type WritableComputedRefWithControl, assert, refAutoReset as autoResetRef, bypassFilter, camelize, clamp, computedEager, computedWithControl, containsProp, computedWithControl as controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, reactify as createReactiveFn, createSharedComposable, createSingletonPromise, debounceFilter, refDebounced as debouncedRef, watchDebounced as debouncedWatch, computedEager as eagerComputed, extendRef, formatDate, get, getLifeCycleTarget, hasOwn, hyphenate, identity, watchIgnorable as ignorableWatch, increaseWithUnit, injectLocal, invoke, isClient, isDef, isDefined, isIOS, isObject, isWorker, makeDestructurable, noop, normalizeDate, notNullish, now, objectEntries, objectOmit, objectPick, pausableFilter, watchPausable as pausableWatch, promiseTimeout, provideLocal, pxValue, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refThrottled, refWithControl, resolveRef, resolveUnref, set, syncRef, syncRefs, throttleFilter, refThrottled as throttledRef, watchThrottled as throttledWatch, timestamp, toArray, toReactive, toRef, toRefs, toValue, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayDifference, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayFindLast, useArrayIncludes, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useArrayUnique, useCounter, useDateFormat, refDebounced as useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, refThrottled as useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToNumber, useToString, useToggle, watchArray, watchAtMost, watchDebounced, watchDeep, watchIgnorable, watchImmediate, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };

package/index.d.ts

@@ -1,5 +1,5 @@
 import * as vue from 'vue';
-import { WatchOptionsBase, Ref, ComputedRef, WritableComputedRef, WatchSource, ComputedGetter, WritableComputedOptions, MaybeRef, WatchOptions, MaybeRefOrGetter, InjectionKey, ShallowUnwrapRef as ShallowUnwrapRef$1, inject, provide, UnwrapNestedRefs, UnwrapRef, ToRef, ToRefs, WatchCallback, WatchStopHandle } from 'vue';
+import { WatchOptionsBase, Ref, ComputedRef, WritableComputedRef, WatchSource, ComputedGetter, WritableComputedOptions, MaybeRef, WatchOptions, MaybeRefOrGetter, InjectionKey, ShallowUnwrapRef as ShallowUnwrapRef$1, inject, provide, UnwrapNestedRefs, UnwrapRef, ToRef, ToRefs, toValue as toValue$1, WatchCallback, WatchStopHandle } from 'vue';
 export { MaybeRef, MaybeRefOrGetter } from 'vue';
 
 /**
@@ -301,6 +301,7 @@ declare function objectPick<O extends object, T extends keyof O>(obj: O, keys: T
 declare function objectOmit<O extends object, T extends keyof O>(obj: O, keys: T[], omitUndefined?: boolean): Omit<O, T>;
 declare function objectEntries<T extends object>(obj: T): Array<[keyof T, T[keyof T]]>;
 declare function getLifeCycleTarget(target?: any): any;
+declare function toArray<T>(value: T): T extends readonly any[] ? T : [T];
 
 /**
  * Keep states in the global scope to be reusable across Vue instances.
@@ -644,12 +645,14 @@ declare function toRefs<T extends object>(objectRef: MaybeRef<T>, options?: ToRe
 
 /**
  * Get the value of value/ref/getter.
+ *
+ * @deprecated use `toValue` from `vue` instead
  */
-declare function toValue<T>(r: MaybeRefOrGetter<T>): T;
+declare const toValue: typeof toValue$1;
 /**
  * @deprecated use `toValue` instead
  */
-declare const resolveUnref: typeof toValue;
+declare const resolveUnref: typeof toValue$1;
 
 /**
  * Call onBeforeMount() if it's inside a component lifecycle, if not, just call the function
@@ -1091,9 +1094,11 @@ interface UseToNumberOptions {
     /**
      * Method to use to convert the value to a number.
      *
+     * Or a custom function for the conversion.
+     *
      * @default 'parseFloat'
      */
-    method?: 'parseFloat' | 'parseInt';
+    method?: 'parseFloat' | 'parseInt' | ((value: string | number) => number);
     /**
      * The base in mathematical numeral systems passed to `parseInt`.
      * Only works with `method: 'parseInt'`
@@ -1220,4 +1225,4 @@ interface WheneverOptions extends WatchOptions {
  */
 declare function whenever<T>(source: WatchSource<T | false | null | undefined>, cb: WatchCallback<T>, options?: WheneverOptions): vue.WatchHandle;
 
-export { type AnyFn, type ArgumentsType, type Arrayable, type Awaitable, type Awaited, type ComputedRefWithControl, type ComputedWithControlRefExtra, type ConfigurableEventFilter, type ConfigurableFlush, type ConfigurableFlushSync, type ControlledRefOptions, type CreateInjectionStateOptions, type DateLike, type DebounceFilterOptions, type DeepMaybeRef, type ElementOf, type EventFilter, type EventHook, type EventHookOff, type EventHookOn, type EventHookTrigger, type ExtendRefOptions, type Fn, type FunctionArgs, type FunctionWrapperOptions, type IfAny, type IgnoredUpdater, type IsAny, type MapOldSources, type MapSources, type MultiWatchSources, type Mutable, type Pausable, type Promisify, type PromisifyFn, type Reactified, type ReactifyNested, type ReactifyObjectOptions, type ReactifyOptions, type ReactiveOmitPredicate, type ReactivePickPredicate, type ReadonlyRefOrGetter, type RemovableRef, type ShallowUnwrapRef, type SingletonPromiseReturn, type Stoppable, type SyncRefOptions, type SyncRefsOptions, type ThrottleFilterOptions, type ToRefsOptions, type UntilArrayInstance, type UntilBaseInstance, type UntilToMatchOptions, type UntilValueInstance, type UseArrayDifferenceOptions, type UseArrayIncludesComparatorFn, type UseArrayIncludesOptions, type UseArrayReducer, type UseCounterOptions, type UseDateFormatOptions, type UseDateFormatReturn, type UseIntervalControls, type UseIntervalFnOptions, type UseIntervalOptions, type UseLastChangedOptions, type UseTimeoutFnOptions, type UseTimeoutOptions, type UseToNumberOptions, type UseToggleOptions, type WatchArrayCallback, type WatchAtMostOptions, type WatchAtMostReturn, type WatchDebouncedOptions, type WatchIgnorableReturn, type WatchPausableReturn, type WatchThrottledOptions, type WatchTriggerableCallback, type WatchTriggerableReturn, type WatchWithFilterOptions, type WheneverOptions, type WritableComputedRefWithControl, assert, refAutoReset as autoResetRef, bypassFilter, camelize, clamp, computedEager, computedWithControl, containsProp, computedWithControl as controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, reactify as createReactiveFn, createSharedComposable, createSingletonPromise, debounceFilter, refDebounced as debouncedRef, watchDebounced as debouncedWatch, computedEager as eagerComputed, extendRef, formatDate, get, getLifeCycleTarget, hasOwn, hyphenate, identity, watchIgnorable as ignorableWatch, increaseWithUnit, injectLocal, invoke, isClient, isDef, isDefined, isIOS, isObject, isWorker, makeDestructurable, noop, normalizeDate, notNullish, now, objectEntries, objectOmit, objectPick, pausableFilter, watchPausable as pausableWatch, promiseTimeout, provideLocal, pxValue, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refThrottled, refWithControl, resolveRef, resolveUnref, set, syncRef, syncRefs, throttleFilter, refThrottled as throttledRef, watchThrottled as throttledWatch, timestamp, toReactive, toRef, toRefs, toValue, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayDifference, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayFindLast, useArrayIncludes, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useArrayUnique, useCounter, useDateFormat, refDebounced as useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, refThrottled as useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToNumber, useToString, useToggle, watchArray, watchAtMost, watchDebounced, watchDeep, watchIgnorable, watchImmediate, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };
+export { type AnyFn, type ArgumentsType, type Arrayable, type Awaitable, type Awaited, type ComputedRefWithControl, type ComputedWithControlRefExtra, type ConfigurableEventFilter, type ConfigurableFlush, type ConfigurableFlushSync, type ControlledRefOptions, type CreateInjectionStateOptions, type DateLike, type DebounceFilterOptions, type DeepMaybeRef, type ElementOf, type EventFilter, type EventHook, type EventHookOff, type EventHookOn, type EventHookTrigger, type ExtendRefOptions, type Fn, type FunctionArgs, type FunctionWrapperOptions, type IfAny, type IgnoredUpdater, type IsAny, type MapOldSources, type MapSources, type MultiWatchSources, type Mutable, type Pausable, type Promisify, type PromisifyFn, type Reactified, type ReactifyNested, type ReactifyObjectOptions, type ReactifyOptions, type ReactiveOmitPredicate, type ReactivePickPredicate, type ReadonlyRefOrGetter, type RemovableRef, type ShallowUnwrapRef, type SingletonPromiseReturn, type Stoppable, type SyncRefOptions, type SyncRefsOptions, type ThrottleFilterOptions, type ToRefsOptions, type UntilArrayInstance, type UntilBaseInstance, type UntilToMatchOptions, type UntilValueInstance, type UseArrayDifferenceOptions, type UseArrayIncludesComparatorFn, type UseArrayIncludesOptions, type UseArrayReducer, type UseCounterOptions, type UseDateFormatOptions, type UseDateFormatReturn, type UseIntervalControls, type UseIntervalFnOptions, type UseIntervalOptions, type UseLastChangedOptions, type UseTimeoutFnOptions, type UseTimeoutOptions, type UseToNumberOptions, type UseToggleOptions, type WatchArrayCallback, type WatchAtMostOptions, type WatchAtMostReturn, type WatchDebouncedOptions, type WatchIgnorableReturn, type WatchPausableReturn, type WatchThrottledOptions, type WatchTriggerableCallback, type WatchTriggerableReturn, type WatchWithFilterOptions, type WheneverOptions, type WritableComputedRefWithControl, assert, refAutoReset as autoResetRef, bypassFilter, camelize, clamp, computedEager, computedWithControl, containsProp, computedWithControl as controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, reactify as createReactiveFn, createSharedComposable, createSingletonPromise, debounceFilter, refDebounced as debouncedRef, watchDebounced as debouncedWatch, computedEager as eagerComputed, extendRef, formatDate, get, getLifeCycleTarget, hasOwn, hyphenate, identity, watchIgnorable as ignorableWatch, increaseWithUnit, injectLocal, invoke, isClient, isDef, isDefined, isIOS, isObject, isWorker, makeDestructurable, noop, normalizeDate, notNullish, now, objectEntries, objectOmit, objectPick, pausableFilter, watchPausable as pausableWatch, promiseTimeout, provideLocal, pxValue, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refThrottled, refWithControl, resolveRef, resolveUnref, set, syncRef, syncRefs, throttleFilter, refThrottled as throttledRef, watchThrottled as throttledWatch, timestamp, toArray, toReactive, toRef, toRefs, toValue, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayDifference, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayFindLast, useArrayIncludes, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useArrayUnique, useCounter, useDateFormat, refDebounced as useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, refThrottled as useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToNumber, useToString, useToggle, watchArray, watchAtMost, watchDebounced, watchDeep, watchIgnorable, watchImmediate, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };