@vueuse/shared 6.3.2 → 6.5.3

package/index.cjs

@@ -4,1102 +4,1103 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var vueDemi = require('vue-demi');
 
-/**
- * `AND` conditions for refs.
- *
- * @see https://vueuse.org/and
- */
-function and(...args) {
-    return vueDemi.computed(() => args.every(i => vueDemi.unref(i)));
+function and(...args) {
+  return vueDemi.computed(() => args.every((i) => vueDemi.unref(i)));
 }
 
-/**
- * Two-way refs synchronization.
- *
- * @param a
- * @param b
- */
-function biSyncRef(a, b) {
-    const flush = 'sync';
-    const stop1 = vueDemi.watch(a, (newValue) => {
-        b.value = newValue;
-    }, {
-        flush,
-        immediate: true,
-    });
-    const stop2 = vueDemi.watch(b, (newValue) => {
-        a.value = newValue;
-    }, {
-        flush,
-        immediate: true,
-    });
-    return () => {
-        stop1();
-        stop2();
-    };
+function biSyncRef(a, b) {
+  const flush = "sync";
+  const stop1 = vueDemi.watch(a, (newValue) => {
+    b.value = newValue;
+  }, {
+    flush,
+    immediate: true
+  });
+  const stop2 = vueDemi.watch(b, (newValue) => {
+    a.value = newValue;
+  }, {
+    flush,
+    immediate: true
+  });
+  return () => {
+    stop1();
+    stop2();
+  };
 }
 
-/**
- * Explicitly define the deps of computed.
- *
- * @param source
- * @param fn
- */
-function controlledComputed(source, fn) {
-    let v = undefined;
-    let track;
-    let trigger;
-    const dirty = vueDemi.ref(true);
-    vueDemi.watch(source, () => {
-        dirty.value = true;
-        trigger();
-    }, { flush: 'sync' });
-    return vueDemi.customRef((_track, _trigger) => {
-        track = _track;
-        trigger = _trigger;
-        return {
-            get() {
-                if (dirty.value) {
-                    v = fn();
-                    dirty.value = false;
-                }
-                track();
-                return v;
-            },
-            set() { },
-        };
-    });
+function controlledComputed(source, fn) {
+  let v = void 0;
+  let track;
+  let trigger;
+  const dirty = vueDemi.ref(true);
+  vueDemi.watch(source, () => {
+    dirty.value = true;
+    trigger();
+  }, { flush: "sync" });
+  return vueDemi.customRef((_track, _trigger) => {
+    track = _track;
+    trigger = _trigger;
+    return {
+      get() {
+        if (dirty.value) {
+          v = fn();
+          dirty.value = false;
+        }
+        track();
+        return v;
+      },
+      set() {
+      }
+    };
+  });
 }
 
-function __onlyVue3(name = 'this function') {
-    if (vueDemi.isVue3)
-        return;
-    throw new Error(`[VueUse] ${name} is only works on Vue 3.`);
+function __onlyVue3(name = "this function") {
+  if (vueDemi.isVue3)
+    return;
+  throw new Error(`[VueUse] ${name} is only works on Vue 3.`);
 }
 
-// implementation
-function extendRef(ref, extend, { enumerable = false, unwrap = true } = {}) {
-    __onlyVue3();
-    for (const [key, value] of Object.entries(extend)) {
-        if (key === 'value')
-            continue;
-        if (vueDemi.isRef(value) && unwrap) {
-            Object.defineProperty(ref, key, {
-                get() {
-                    return value.value;
-                },
-                set(v) {
-                    value.value = v;
-                },
-                enumerable,
-            });
-        }
-        else {
-            Object.defineProperty(ref, key, { value, enumerable });
-        }
-    }
-    return ref;
+function extendRef(ref, extend, { enumerable = false, unwrap = true } = {}) {
+  __onlyVue3();
+  for (const [key, value] of Object.entries(extend)) {
+    if (key === "value")
+      continue;
+    if (vueDemi.isRef(value) && unwrap) {
+      Object.defineProperty(ref, key, {
+        get() {
+          return value.value;
+        },
+        set(v) {
+          value.value = v;
+        },
+        enumerable
+      });
+    } else {
+      Object.defineProperty(ref, key, { value, enumerable });
+    }
+  }
+  return ref;
 }
 
-/**
- * Explicitly define the deps of computed.
- *
- * @param source
- * @param fn
- */
-function controlledRef(initial, options = {}) {
-    let source = initial;
-    let track;
-    let trigger;
-    const ref = vueDemi.customRef((_track, _trigger) => {
-        track = _track;
-        trigger = _trigger;
-        return {
-            get() {
-                return get();
-            },
-            set(v) {
-                set(v);
-            },
-        };
-    });
-    function get(tracking = true) {
-        if (tracking)
-            track();
-        return source;
-    }
-    function set(value, triggering = true) {
-        var _a, _b;
-        if (value === source)
-            return;
-        const old = source;
-        if (((_a = options.onBeforeChange) === null || _a === void 0 ? void 0 : _a.call(options, value, old)) === false)
-            return; // dismissed
-        source = value;
-        (_b = options.onChanged) === null || _b === void 0 ? void 0 : _b.call(options, value, old);
-        if (triggering)
-            trigger();
-    }
-    /**
-     * Get the value without tracked in the reactivity system
-     */
-    const untrackedGet = () => get(false);
-    /**
-     * Set the value without triggering the reactivity system
-     */
-    const silentSet = (v) => set(v, false);
-    /**
-     * Get the value without tracked in the reactivity system.
-     *
-     * Alias for `untrackedGet()`
-     */
-    const peek = () => get(false);
-    /**
-     * Set the value without triggering the reactivity system
-     *
-     * Alias for `silentSet(v)`
-     */
-    const lay = (v) => set(v, false);
-    return extendRef(ref, {
-        get,
-        set,
-        untrackedGet,
-        silentSet,
-        peek,
-        lay,
-    }, { enumerable: true });
+function controlledRef(initial, options = {}) {
+  let source = initial;
+  let track;
+  let trigger;
+  const ref = vueDemi.customRef((_track, _trigger) => {
+    track = _track;
+    trigger = _trigger;
+    return {
+      get() {
+        return get();
+      },
+      set(v) {
+        set(v);
+      }
+    };
+  });
+  function get(tracking = true) {
+    if (tracking)
+      track();
+    return source;
+  }
+  function set(value, triggering = true) {
+    var _a, _b;
+    if (value === source)
+      return;
+    const old = source;
+    if (((_a = options.onBeforeChange) == null ? void 0 : _a.call(options, value, old)) === false)
+      return;
+    source = value;
+    (_b = options.onChanged) == null ? void 0 : _b.call(options, value, old);
+    if (triggering)
+      trigger();
+  }
+  const untrackedGet = () => get(false);
+  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 });
 }
 
-/**
- * The source code for this function was inspired by vue-apollo's `useEventHook` util
- * https://github.com/vuejs/vue-apollo/blob/v4/packages/vue-apollo-composable/src/util/useEventHook.ts
- */
-/**
- * Utility for creating event hooks
- *
- * @see https://vueuse.org/createEventHook
- */
-function createEventHook() {
-    const fns = [];
-    const off = (fn) => {
-        const index = fns.indexOf(fn);
-        if (index !== -1)
-            fns.splice(index, 1);
-    };
-    const on = (fn) => {
-        fns.push(fn);
-        return {
-            off: () => off(fn),
-        };
-    };
-    const trigger = (param) => {
-        fns.forEach(fn => fn(param));
-    };
-    return {
-        on,
-        off,
-        trigger,
-    };
+function createEventHook() {
+  const fns = [];
+  const off = (fn) => {
+    const index = fns.indexOf(fn);
+    if (index !== -1)
+      fns.splice(index, 1);
+  };
+  const on = (fn) => {
+    fns.push(fn);
+    return {
+      off: () => off(fn)
+    };
+  };
+  const trigger = (param) => {
+    fns.forEach((fn) => fn(param));
+  };
+  return {
+    on,
+    off,
+    trigger
+  };
 }
 
-/**
- * Keep states in the global scope to be reusable across Vue instances.
- *
- * @see https://vueuse.org/createGlobalState
- * @param stateFactory A factory function to create the state
- */
-function createGlobalState(stateFactory) {
-    let initialized = false;
-    let state;
-    const scope = vueDemi.effectScope(true);
-    return () => {
-        if (!initialized) {
-            state = scope.run(stateFactory);
-            initialized = true;
-        }
-        return state;
-    };
+function createGlobalState(stateFactory) {
+  let initialized = false;
+  let state;
+  const scope = vueDemi.effectScope(true);
+  return () => {
+    if (!initialized) {
+      state = scope.run(stateFactory);
+      initialized = true;
+    }
+    return state;
+  };
 }
 
-/**
- * Call onScopeDispose() if it's inside a effect scope lifecycle, if not, do nothing
- *
- * @param fn
- */
-function tryOnScopeDispose(fn) {
-    if (vueDemi.getCurrentScope()) {
-        vueDemi.onScopeDispose(fn);
-        return true;
-    }
-    return false;
+function tryOnScopeDispose(fn) {
+  if (vueDemi.getCurrentScope()) {
+    vueDemi.onScopeDispose(fn);
+    return true;
+  }
+  return false;
 }
 
-/**
- * Make a composable function usable with multiple Vue instances.
- *
- * @see https://vueuse.org/createSharedComposable
- */
-function createSharedComposable(composable) {
-    let subscribers = 0;
-    let state;
-    let scope;
-    const dispose = () => {
-        subscribers -= 1;
-        if (scope && subscribers <= 0) {
-            scope.stop();
-            state = undefined;
-            scope = undefined;
-        }
-    };
-    return ((...args) => {
-        subscribers += 1;
-        if (!state) {
-            scope = vueDemi.effectScope(true);
-            state = scope.run(() => composable(...args));
-        }
-        tryOnScopeDispose(dispose);
-        return state;
-    });
+function createSharedComposable(composable) {
+  let subscribers = 0;
+  let state;
+  let scope;
+  const dispose = () => {
+    subscribers -= 1;
+    if (scope && subscribers <= 0) {
+      scope.stop();
+      state = void 0;
+      scope = void 0;
+    }
+  };
+  return (...args) => {
+    subscribers += 1;
+    if (!state) {
+      scope = vueDemi.effectScope(true);
+      state = scope.run(() => composable(...args));
+    }
+    tryOnScopeDispose(dispose);
+    return state;
+  };
 }
 
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
+const isClient = typeof window !== "undefined";
+const isDef = (val) => typeof val !== "undefined";
+const assert = (condition, ...infos) => {
+  if (!condition)
+    console.warn(...infos);
+};
+const toString = Object.prototype.toString;
+const isBoolean = (val) => typeof val === "boolean";
+const isFunction = (val) => typeof val === "function";
+const isNumber = (val) => typeof val === "number";
+const isString = (val) => typeof val === "string";
+const isObject = (val) => toString.call(val) === "[object Object]";
+const isWindow = (val) => typeof window !== "undefined" && toString.call(val) === "[object Window]";
+const now = () => Date.now();
+const timestamp = () => +Date.now();
+const clamp = (n, min, max) => Math.min(max, Math.max(min, n));
+const noop = () => {
+};
+const rand = (min, max) => {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+};
 
-const isClient = typeof window !== 'undefined';
-const isDef = (val) => typeof val !== 'undefined';
-const assert = (condition, ...infos) => {
-    // eslint-disable-next-line no-console
-    if (!condition)
-        console.warn(...infos);
-};
-const toString = Object.prototype.toString;
-const isBoolean = (val) => typeof val === 'boolean';
-const isFunction = (val) => typeof val === 'function';
-const isNumber = (val) => typeof val === 'number';
-const isString = (val) => typeof val === 'string';
-const isObject = (val) => toString.call(val) === '[object Object]';
-const isWindow = (val) => typeof window !== 'undefined' && toString.call(val) === '[object Window]';
-const now = () => Date.now();
-const timestamp = () => +Date.now();
-const clamp = (n, min, max) => Math.min(max, Math.max(min, n));
-const noop = () => { };
-const rand = (min, max) => {
-    min = Math.ceil(min);
-    max = Math.floor(max);
-    return Math.floor(Math.random() * (max - min + 1)) + min;
+function createFilterWrapper(filter, fn) {
+  function wrapper(...args) {
+    filter(() => fn.apply(this, args), { fn, thisArg: this, args });
+  }
+  return wrapper;
+}
+const bypassFilter = (invoke) => {
+  return invoke();
 };
+function debounceFilter(ms) {
+  let timer;
+  const filter = (invoke) => {
+    const duration = vueDemi.unref(ms);
+    if (timer)
+      clearTimeout(timer);
+    if (duration <= 0)
+      return invoke();
+    timer = setTimeout(invoke, duration);
+  };
+  return filter;
+}
+function throttleFilter(ms, trailing = true, leading = true) {
+  let lastExec = 0;
+  let timer;
+  let preventLeading = !leading;
+  const clear = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  };
+  const filter = (invoke) => {
+    const duration = vueDemi.unref(ms);
+    const elapsed = Date.now() - lastExec;
+    clear();
+    if (duration <= 0) {
+      lastExec = Date.now();
+      return invoke();
+    }
+    if (elapsed > duration) {
+      lastExec = Date.now();
+      if (preventLeading)
+        preventLeading = false;
+      else
+        invoke();
+    } else if (trailing) {
+      timer = setTimeout(() => {
+        lastExec = Date.now();
+        if (!leading)
+          preventLeading = true;
+        clear();
+        invoke();
+      }, duration);
+    }
+    if (!leading && !timer)
+      timer = setTimeout(() => preventLeading = true, duration);
+  };
+  return filter;
+}
+function pausableFilter(extendFilter = bypassFilter) {
+  const isActive = vueDemi.ref(true);
+  function pause() {
+    isActive.value = false;
+  }
+  function resume() {
+    isActive.value = true;
+  }
+  const eventFilter = (...args) => {
+    if (isActive.value)
+      extendFilter(...args);
+  };
+  return { isActive, pause, resume, eventFilter };
+}
 
-/**
- * @internal
- */
-function createFilterWrapper(filter, fn) {
-    function wrapper(...args) {
-        filter(() => fn.apply(this, args), { fn, thisArg: this, args });
-    }
-    return wrapper;
-}
-const bypassFilter = (invoke) => {
-    return invoke();
-};
-/**
- * Create an EventFilter that debounce the events
- *
- * @param ms
- */
-function debounceFilter(ms) {
-    let timer;
-    const filter = (invoke) => {
-        const duration = vueDemi.unref(ms);
-        if (timer)
-            clearTimeout(timer);
-        if (duration <= 0)
-            return invoke();
-        timer = setTimeout(invoke, duration);
-    };
-    return filter;
-}
-/**
- * Create an EventFilter that throttle the events
- *
- * @param ms
- * @param [trailing=true]
- */
-function throttleFilter(ms, trailing = true) {
-    let lastExec = 0;
-    let timer;
-    const clear = () => {
-        if (timer) {
-            clearTimeout(timer);
-            timer = undefined;
-        }
-    };
-    const filter = (invoke) => {
-        const duration = vueDemi.unref(ms);
-        const elapsed = Date.now() - lastExec;
-        clear();
-        if (duration <= 0) {
-            lastExec = Date.now();
-            return invoke();
-        }
-        if (elapsed > duration) {
-            lastExec = Date.now();
-            invoke();
-        }
-        else if (trailing) {
-            timer = setTimeout(() => {
-                lastExec = Date.now();
-                clear();
-                invoke();
-            }, duration);
-        }
-    };
-    return filter;
-}
-/**
- * EventFilter that gives extra controls to pause and resume the filter
- *
- * @param extendFilter  Extra filter to apply when the PauseableFilter is active, default to none
- *
- */
-function pausableFilter(extendFilter = bypassFilter) {
-    const isActive = vueDemi.ref(true);
-    function pause() {
-        isActive.value = false;
-    }
-    function resume() {
-        isActive.value = true;
-    }
-    const eventFilter = (...args) => {
-        if (isActive.value)
-            extendFilter(...args);
-    };
-    return { isActive, pause, resume, eventFilter };
+function promiseTimeout(ms, throwOnTimeout = false, reason = "Timeout") {
+  return new Promise((resolve, reject) => {
+    if (throwOnTimeout)
+      setTimeout(() => reject(reason), ms);
+    else
+      setTimeout(resolve, ms);
+  });
+}
+function identity(arg) {
+  return arg;
+}
+function createSingletonPromise(fn) {
+  let _promise;
+  function wrapper() {
+    if (!_promise)
+      _promise = fn();
+    return _promise;
+  }
+  wrapper.reset = async () => {
+    const _prev = _promise;
+    _promise = void 0;
+    if (_prev)
+      await _prev;
+  };
+  return wrapper;
+}
+function invoke(fn) {
+  return fn();
+}
+function containsProp(obj, ...props) {
+  return props.some((k) => k in obj);
+}
+function increaseWithUnit(target, delta) {
+  var _a;
+  if (typeof target === "number")
+    return target + delta;
+  const value = ((_a = target.match(/^-?[0-9]+\.?[0-9]*/)) == null ? void 0 : _a[0]) || "";
+  const unit = target.slice(value.length);
+  const result = parseFloat(value) + delta;
+  if (Number.isNaN(result))
+    return target;
+  return result + unit;
+}
+function objectPick(obj, keys, omitUndefined = false) {
+  return keys.reduce((n, k) => {
+    if (k in obj) {
+      if (!omitUndefined || !obj[k] === void 0)
+        n[k] = obj[k];
+    }
+    return n;
+  }, {});
 }
 
-function promiseTimeout(ms, throwOnTimeout = false, reason = 'Timeout') {
-    return new Promise((resolve, reject) => {
-        if (throwOnTimeout)
-            setTimeout(() => reject(reason), ms);
-        else
-            setTimeout(resolve, ms);
-    });
-}
-function identity(arg) {
-    return arg;
-}
-/**
- * Create singleton promise function
- *
- * @example
- * ```
- * const promise = createSingletonPromise(async () => { ... })
- *
- * await promise()
- * await promise() // all of them will be bind to a single promise instance
- * await promise() // and be resolved together
- * ```
- */
-function createSingletonPromise(fn) {
-    let _promise;
-    function wrapper() {
-        if (!_promise)
-            _promise = fn();
-        return _promise;
-    }
-    wrapper.reset = async () => {
-        const _prev = _promise;
-        _promise = undefined;
-        if (_prev)
-            await _prev;
-    };
-    return wrapper;
-}
-function invoke(fn) {
-    return fn();
-}
-function containsProp(obj, ...props) {
-    return props.some(k => k in obj);
-}
-function increaseWithUnit(target, delta) {
-    var _a;
-    if (typeof target === 'number')
-        return target + delta;
-    const value = ((_a = target.match(/^-?[0-9]+\.?[0-9]*/)) === null || _a === void 0 ? void 0 : _a[0]) || '';
-    const unit = target.slice(value.length);
-    const result = (parseFloat(value) + delta);
-    if (Number.isNaN(result))
-        return target;
-    return result + unit;
-}
-/**
- * Create a new subset object by giving keys
- *
- * @category Object
- */
-function objectPick(obj, keys, omitUndefined = false) {
-    return keys.reduce((n, k) => {
-        if (k in obj)
-            if (!omitUndefined || !obj[k] === undefined)
-                n[k] = obj[k];
-        return n;
-    }, {});
+var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
+var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
+var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
+var __objRest$5 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$8.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$8)
+    for (var prop of __getOwnPropSymbols$8(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$8.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function watchWithFilter(source, cb, options = {}) {
+  const _a = options, {
+    eventFilter = bypassFilter
+  } = _a, watchOptions = __objRest$5(_a, [
+    "eventFilter"
+  ]);
+  return vueDemi.watch(source, createFilterWrapper(eventFilter, cb), watchOptions);
 }
 
-// implementation
-function watchWithFilter(source, cb, options = {}) {
-    const { eventFilter = bypassFilter } = options, watchOptions = __rest(options, ["eventFilter"]);
-    return vueDemi.watch(source, createFilterWrapper(eventFilter, cb), watchOptions);
+var __defProp$6 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
+var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
+var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$6 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$7.call(b, prop))
+      __defNormalProp$6(a, prop, b[prop]);
+  if (__getOwnPropSymbols$7)
+    for (var prop of __getOwnPropSymbols$7(b)) {
+      if (__propIsEnum$7.call(b, prop))
+        __defNormalProp$6(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+var __objRest$4 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$7.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$7)
+    for (var prop of __getOwnPropSymbols$7(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$7.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function debouncedWatch(source, cb, options = {}) {
+  const _a = options, {
+    debounce = 0
+  } = _a, watchOptions = __objRest$4(_a, [
+    "debounce"
+  ]);
+  return watchWithFilter(source, cb, __spreadProps$3(__spreadValues$6({}, watchOptions), {
+    eventFilter: debounceFilter(debounce)
+  }));
 }
 
-// implementation
-function debouncedWatch(source, cb, options = {}) {
-    const { debounce = 0 } = options, watchOptions = __rest(options, ["debounce"]);
-    return watchWithFilter(source, cb, Object.assign(Object.assign({}, watchOptions), { eventFilter: debounceFilter(debounce) }));
+function eagerComputed(fn) {
+  const result = vueDemi.shallowRef();
+  vueDemi.watchSyncEffect(() => {
+    result.value = fn();
+  });
+  return vueDemi.readonly(result);
 }
 
-// ported from https://dev.to/linusborg/vue-when-a-computed-property-can-be-the-wrong-tool-195j
-function eagerComputed(fn) {
-    const result = vueDemi.shallowRef();
-    vueDemi.watchSyncEffect(() => {
-        result.value = fn();
-    });
-    return vueDemi.readonly(result);
+function get(obj, key) {
+  if (key == null)
+    return vueDemi.unref(obj);
+  return vueDemi.unref(obj)[key];
 }
 
-function get(obj, key) {
-    if (key == null)
-        return vueDemi.unref(obj);
-    return vueDemi.unref(obj)[key];
+var __defProp$5 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
+var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$5 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$6.call(b, prop))
+      __defNormalProp$5(a, prop, b[prop]);
+  if (__getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(b)) {
+      if (__propIsEnum$6.call(b, prop))
+        __defNormalProp$5(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+var __objRest$3 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$6.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$6.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function ignorableWatch(source, cb, options = {}) {
+  const _a = options, {
+    eventFilter = bypassFilter
+  } = _a, watchOptions = __objRest$3(_a, [
+    "eventFilter"
+  ]);
+  const filteredCb = createFilterWrapper(eventFilter, cb);
+  let ignoreUpdates;
+  let ignorePrevAsyncUpdates;
+  let stop;
+  if (watchOptions.flush === "sync") {
+    const ignore = vueDemi.ref(false);
+    ignorePrevAsyncUpdates = () => {
+    };
+    ignoreUpdates = (updater) => {
+      ignore.value = true;
+      updater();
+      ignore.value = false;
+    };
+    stop = vueDemi.watch(source, (...args) => {
+      if (!ignore.value)
+        filteredCb(...args);
+    }, watchOptions);
+  } else {
+    const disposables = [];
+    const ignoreCounter = vueDemi.ref(0);
+    const syncCounter = vueDemi.ref(0);
+    ignorePrevAsyncUpdates = () => {
+      ignoreCounter.value = syncCounter.value;
+    };
+    disposables.push(vueDemi.watch(source, () => {
+      syncCounter.value++;
+    }, __spreadProps$2(__spreadValues$5({}, 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));
+    stop = () => {
+      disposables.forEach((fn) => fn());
+    };
+  }
+  return { stop, ignoreUpdates, ignorePrevAsyncUpdates };
+}
+
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
+var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
+var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$5.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(b)) {
+      if (__propIsEnum$5.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
+    }
+  return a;
+};
+function makeDestructurable(obj, arr) {
+  if (typeof Symbol !== "undefined") {
+    const clone = __spreadValues$4({}, obj);
+    Object.defineProperty(clone, Symbol.iterator, {
+      enumerable: false,
+      value() {
+        let index = 0;
+        return {
+          next: () => ({
+            value: arr[index++],
+            done: index > arr.length
+          })
+        };
+      }
+    });
+    return clone;
+  } else {
+    return Object.assign([...arr], obj);
+  }
 }
 
-function ignorableWatch(source, cb, options = {}) {
-    const { eventFilter = bypassFilter } = options, watchOptions = __rest(options, ["eventFilter"]);
-    const filteredCb = createFilterWrapper(eventFilter, cb);
-    let ignoreUpdates;
-    let ignorePrevAsyncUpdates;
-    let stop;
-    if (watchOptions.flush === 'sync') {
-        const ignore = vueDemi.ref(false);
-        // no op for flush: sync
-        ignorePrevAsyncUpdates = () => { };
-        ignoreUpdates = (updater) => {
-            // Call the updater function and count how many sync updates are performed,
-            // then add them to the ignore count
-            ignore.value = true;
-            updater();
-            ignore.value = false;
-        };
-        stop = vueDemi.watch(source, (...args) => {
-            if (!ignore.value)
-                filteredCb(...args);
-        }, watchOptions);
-    }
-    else {
-        // flush 'pre' and 'post'
-        const disposables = [];
-        // counters for how many following changes to be ignored
-        // ignoreCounter is incremented before there is a history operation
-        // affecting the source ref value (undo, redo, revert).
-        // syncCounter is incremented in sync with every change to the
-        // source ref value. This let us know how many times the ref
-        // was modified and support chained sync operations. If there
-        // are more sync triggers than the ignore count, the we now
-        // there are modifications in the source ref value that we
-        // need to commit
-        const ignoreCounter = vueDemi.ref(0);
-        const syncCounter = vueDemi.ref(0);
-        ignorePrevAsyncUpdates = () => {
-            ignoreCounter.value = syncCounter.value;
-        };
-        // Sync watch to count modifications to the source
-        disposables.push(vueDemi.watch(source, () => {
-            syncCounter.value++;
-        }, Object.assign(Object.assign({}, watchOptions), { flush: 'sync' })));
-        ignoreUpdates = (updater) => {
-            // Call the updater function and count how many sync updates are performed,
-            // then add them to the ignore count
-            const syncCounterPrev = syncCounter.value;
-            updater();
-            ignoreCounter.value += syncCounter.value - syncCounterPrev;
-        };
-        disposables.push(vueDemi.watch(source, (...args) => {
-            // If a history operation was performed (ignoreCounter > 0) and there are
-            // no other changes to the source ref value afterwards, then ignore this commit
-            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());
-        };
-    }
-    return { stop, ignoreUpdates, ignorePrevAsyncUpdates };
+function not(v) {
+  return vueDemi.computed(() => !vueDemi.unref(v));
 }
 
-function makeDestructurable(obj, arr) {
-    if (typeof Symbol !== 'undefined') {
-        const clone = Object.assign({}, obj);
-        Object.defineProperty(clone, Symbol.iterator, {
-            enumerable: false,
-            value() {
-                let index = 0;
-                return {
-                    next: () => ({
-                        value: arr[index++],
-                        done: index > arr.length,
-                    }),
-                };
-            },
-        });
-        return clone;
-    }
-    else {
-        return Object.assign([...arr], obj);
-    }
+function or(...args) {
+  return vueDemi.computed(() => args.some((i) => vueDemi.unref(i)));
 }
 
-/**
- * `NOT` conditions for refs.
- *
- * @see https://vueuse.org/not
- */
-function not(v) {
-    return vueDemi.computed(() => !vueDemi.unref(v));
+var __defProp$3 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+var __objRest$2 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$4.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$4.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function pausableWatch(source, cb, options = {}) {
+  const _a = options, {
+    eventFilter: filter
+  } = _a, watchOptions = __objRest$2(_a, [
+    "eventFilter"
+  ]);
+  const { eventFilter, pause, resume, isActive } = pausableFilter(filter);
+  const stop = watchWithFilter(source, cb, __spreadProps$1(__spreadValues$3({}, watchOptions), {
+    eventFilter
+  }));
+  return { stop, pause, resume, isActive };
 }
 
-/**
- * `OR` conditions for refs.
- *
- * @see https://vueuse.org/or
- */
-function or(...args) {
-    return vueDemi.computed(() => args.some(i => vueDemi.unref(i)));
+function reactify(fn) {
+  return function(...args) {
+    return vueDemi.computed(() => fn.apply(this, args.map((i) => vueDemi.unref(i))));
+  };
 }
 
-// implementation
-function pausableWatch(source, cb, options = {}) {
-    const { eventFilter: filter } = options, watchOptions = __rest(options, ["eventFilter"]);
-    const { eventFilter, pause, resume, isActive } = pausableFilter(filter);
-    const stop = watchWithFilter(source, cb, Object.assign(Object.assign({}, watchOptions), { eventFilter }));
-    return { stop, pause, resume, isActive };
+function reactifyObject(obj, optionsOrKeys = {}) {
+  let keys = [];
+  if (Array.isArray(optionsOrKeys)) {
+    keys = optionsOrKeys;
+  } else {
+    const { includeOwnProperties = true } = optionsOrKeys;
+    keys.push(...Object.keys(obj));
+    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)) : value
+    ];
+  }));
 }
 
-/**
- * Converts plain function into a reactive function.
- * The converted function accepts refs as it's arguments
- * and returns a ComputedRef, with proper typing.
- *
- * @param fn - Source function
- */
-function reactify(fn) {
-    return function (...args) {
-        return vueDemi.computed(() => fn.apply(this, args.map(i => vueDemi.unref(i))));
-    };
+function reactivePick(obj, ...keys) {
+  return vueDemi.reactive(Object.fromEntries(keys.map((k) => [k, vueDemi.toRef(obj, k)])));
 }
 
-function reactifyObject(obj, optionsOrKeys = {}) {
-    let keys = [];
-    if (Array.isArray(optionsOrKeys)) {
-        keys = optionsOrKeys;
-    }
-    else {
-        const { includeOwnProperties = true } = optionsOrKeys;
-        keys.push(...Object.keys(obj));
-        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))
-                : value,
-        ];
-    }));
+function set(...args) {
+  if (args.length === 2) {
+    const [ref, value] = args;
+    ref.value = value;
+  }
+  if (args.length === 3) {
+    if (vueDemi.isVue2) {
+      require("vue-demi").set(...args);
+    } else {
+      const [target, key, value] = args;
+      target[key] = value;
+    }
+  }
 }
 
-/**
- * Reactively pick fields from a reactive object
- *
- * @see https://vueuse.js.org/reactivePick
- */
-function reactivePick(obj, ...keys) {
-    return vueDemi.reactive(Object.fromEntries(keys.map(k => [k, vueDemi.toRef(obj, k)])));
+function syncRef(source, targets, {
+  flush = "sync",
+  deep = false,
+  immediate = true
+} = {}) {
+  if (!Array.isArray(targets))
+    targets = [targets];
+  return vueDemi.watch(source, (newValue) => {
+    targets.forEach((target) => target.value = newValue);
+  }, {
+    flush,
+    deep,
+    immediate
+  });
 }
 
-/**
- *  Shorthand for `ref.value = x`
- */
-function set(...args) {
-    if (args.length === 2) {
-        const [ref, value] = args;
-        ref.value = value;
-    }
-    if (args.length === 3) {
-        if (vueDemi.isVue2) {
-            // use @vue/composition-api's set API
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
-            require('vue-demi').set(...args);
-        }
-        else {
-            const [target, key, value] = args;
-            target[key] = value;
-        }
-    }
+var __defProp$2 = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest$1 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$3.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$3.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function throttledWatch(source, cb, options = {}) {
+  const _a = options, {
+    throttle = 0,
+    trailing = true
+  } = _a, watchOptions = __objRest$1(_a, [
+    "throttle",
+    "trailing"
+  ]);
+  return watchWithFilter(source, cb, __spreadProps(__spreadValues$2({}, watchOptions), {
+    eventFilter: throttleFilter(throttle, trailing)
+  }));
 }
 
-/**
- * Keep target ref(s) in sync with the source ref
- *
- * @param source source ref
- * @param targets
- */
-function syncRef(source, targets, { flush = 'sync', deep = false, immediate = true, } = {}) {
-    if (!Array.isArray(targets))
-        targets = [targets];
-    return vueDemi.watch(source, (newValue) => {
-        targets.forEach(target => target.value = newValue);
-    }, {
-        flush,
-        deep,
-        immediate,
-    });
+function toReactive(objectRef) {
+  if (!vueDemi.isRef(objectRef))
+    return vueDemi.reactive(objectRef);
+  const proxy = new Proxy({}, {
+    get(_, p, receiver) {
+      return Reflect.get(objectRef.value, p, receiver);
+    },
+    set(_, p, value) {
+      objectRef.value[p] = value;
+      return true;
+    },
+    deleteProperty(_, p) {
+      return Reflect.deleteProperty(objectRef.value, p);
+    },
+    has(_, p) {
+      return Reflect.has(objectRef.value, p);
+    },
+    ownKeys() {
+      return Object.keys(objectRef.value);
+    },
+    getOwnPropertyDescriptor() {
+      return {
+        enumerable: true,
+        configurable: true
+      };
+    }
+  });
+  return vueDemi.reactive(proxy);
 }
 
-// implementation
-function throttledWatch(source, cb, options = {}) {
-    const { throttle = 0 } = options, watchOptions = __rest(options, ["throttle"]);
-    return watchWithFilter(source, cb, Object.assign(Object.assign({}, watchOptions), { eventFilter: throttleFilter(throttle) }));
+function toRefs(objectRef) {
+  if (!vueDemi.isRef(objectRef))
+    return vueDemi.toRefs(objectRef);
+  const result = Array.isArray(objectRef.value) ? new Array(objectRef.value.length) : {};
+  for (const key in objectRef.value) {
+    result[key] = vueDemi.customRef(() => ({
+      get() {
+        return objectRef.value[key];
+      },
+      set(v) {
+        objectRef.value[key] = v;
+      }
+    }));
+  }
+  return result;
 }
 
-/**
- * Converts ref to reactive.
- *
- * @see https://vueuse.org/toReactive
- * @param objectRef A ref of object
- */
-function toReactive(objectRef) {
-    if (!vueDemi.isRef(objectRef))
-        return vueDemi.reactive(objectRef);
-    const proxy = new Proxy({}, {
-        get(_, p, receiver) {
-            return Reflect.get(objectRef.value, p, receiver);
-        },
-        set(_, p, value) {
-            objectRef.value[p] = value;
-            return true;
-        },
-        deleteProperty(_, p) {
-            return Reflect.deleteProperty(objectRef.value, p);
-        },
-        has(_, p) {
-            return Reflect.has(objectRef.value, p);
-        },
-        ownKeys() {
-            return Object.keys(objectRef.value);
-        },
-        getOwnPropertyDescriptor() {
-            return {
-                enumerable: true,
-                configurable: true,
-            };
-        },
-    });
-    return vueDemi.reactive(proxy);
+function tryOnBeforeUnmount(fn) {
+  if (vueDemi.getCurrentInstance())
+    vueDemi.onBeforeUnmount(fn);
 }
 
-/**
- * Extended `toRefs` that also accepts refs of an object.
- *
- * @see https://vueuse.org/toRefs
- * @param objectRef A ref or normal object or array.
- */
-function toRefs(objectRef) {
-    if (!vueDemi.isRef(objectRef))
-        return vueDemi.toRefs(objectRef);
-    const result = Array.isArray(objectRef.value)
-        ? new Array(objectRef.value.length)
-        : {};
-    // eslint-disable-next-line no-restricted-syntax
-    for (const key in objectRef.value) {
-        result[key] = vueDemi.customRef(() => ({
-            get() {
-                return objectRef.value[key];
-            },
-            set(v) {
-                objectRef.value[key] = v;
-            },
-        }));
-    }
-    return result;
+function tryOnMounted(fn, sync = true) {
+  if (vueDemi.getCurrentInstance())
+    vueDemi.onMounted(fn);
+  else if (sync)
+    fn();
+  else
+    vueDemi.nextTick(fn);
 }
 
-/**
- * Call onBeforeUnmount() if it's inside a component lifecycle, if not, do nothing
- *
- * @param fn
- */
-function tryOnBeforeUnmount(fn) {
-    if (vueDemi.getCurrentInstance())
-        vueDemi.onBeforeUnmount(fn);
+function tryOnUnmounted(fn) {
+  if (vueDemi.getCurrentInstance())
+    vueDemi.onUnmounted(fn);
 }
 
-/**
- * Call onMounted() if it's inside a component lifecycle, if not, run just call the function
- *
- * @param fn
- * @param sync if set to false, it will run in the nextTick() of Vue
- */
-function tryOnMounted(fn, sync = true) {
-    if (vueDemi.getCurrentInstance())
-        vueDemi.onMounted(fn);
-    else if (sync)
-        fn();
-    else
-        vueDemi.nextTick(fn);
+function until(r) {
+  let 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();
+        }
+      }, {
+        flush,
+        deep,
+        immediate: true
+      });
+    });
+    const promises = [watcher];
+    if (timeout) {
+      promises.push(promiseTimeout(timeout, throwOnTimeout).finally(() => {
+        stop == null ? void 0 : stop();
+      }));
+    }
+    return Promise.race(promises);
+  }
+  function toBe(value, options) {
+    return toMatch((v) => v === vueDemi.unref(value), options);
+  }
+  function toBeTruthy(options) {
+    return toMatch((v) => Boolean(v), options);
+  }
+  function toBeNull(options) {
+    return toBe(null, options);
+  }
+  function toBeUndefined(options) {
+    return toBe(void 0, options);
+  }
+  function toBeNaN(options) {
+    return toMatch(Number.isNaN, options);
+  }
+  function toContains(value, options) {
+    return toMatch((v) => {
+      const array = Array.from(v);
+      return array.includes(value) || array.includes(vueDemi.unref(value));
+    }, options);
+  }
+  function changed(options) {
+    return changedTimes(1, options);
+  }
+  function changedTimes(n = 1, options) {
+    let count = -1;
+    return toMatch(() => {
+      count += 1;
+      return count >= n;
+    }, options);
+  }
+  if (Array.isArray(vueDemi.unref(r))) {
+    const instance = {
+      toMatch,
+      toContains,
+      changed,
+      changedTimes,
+      get not() {
+        isNot = !isNot;
+        return this;
+      }
+    };
+    return instance;
+  } else {
+    const instance = {
+      toMatch,
+      toBe,
+      toBeTruthy,
+      toBeNull,
+      toBeNaN,
+      toBeUndefined,
+      changed,
+      changedTimes,
+      get not() {
+        isNot = !isNot;
+        return this;
+      }
+    };
+    return instance;
+  }
 }
 
-/**
- * Call onUnmounted() if it's inside a component lifecycle, if not, do nothing
- *
- * @param fn
- */
-function tryOnUnmounted(fn) {
-    if (vueDemi.getCurrentInstance())
-        vueDemi.onUnmounted(fn);
+function useCounter(initialValue = 0) {
+  const count = vueDemi.ref(initialValue);
+  const inc = (delta = 1) => count.value += delta;
+  const dec = (delta = 1) => count.value -= delta;
+  const get = () => count.value;
+  const set = (val) => count.value = val;
+  const reset = (val = initialValue) => {
+    initialValue = val;
+    return set(val);
+  };
+  return { count, inc, dec, get, set, reset };
 }
 
-function until(r) {
-    let 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 || stop === void 0 ? void 0 : stop();
-                    resolve();
-                }
-            }, {
-                flush,
-                deep,
-                immediate: true,
-            });
-        });
-        const promises = [watcher];
-        if (timeout) {
-            promises.push(promiseTimeout(timeout, throwOnTimeout).finally(() => {
-                stop === null || stop === void 0 ? void 0 : stop();
-            }));
-        }
-        return Promise.race(promises);
-    }
-    function toBe(value, options) {
-        return toMatch(v => v === vueDemi.unref(value), options);
-    }
-    function toBeTruthy(options) {
-        return toMatch(v => Boolean(v), options);
-    }
-    function toBeNull(options) {
-        return toBe(null, options);
-    }
-    function toBeUndefined(options) {
-        return toBe(undefined, options);
-    }
-    function toBeNaN(options) {
-        return toMatch(Number.isNaN, options);
-    }
-    function toContains(value, options) {
-        return toMatch((v) => {
-            const array = Array.from(v);
-            return array.includes(value) || array.includes(vueDemi.unref(value));
-        }, options);
-    }
-    function changed(options) {
-        return changedTimes(1, options);
-    }
-    function changedTimes(n = 1, options) {
-        let count = -1; // skip the immediate check
-        return toMatch(() => {
-            count += 1;
-            return count >= n;
-        }, options);
-    }
-    if (Array.isArray(vueDemi.unref(r))) {
-        const instance = {
-            toMatch,
-            toContains,
-            changed,
-            changedTimes,
-            get not() {
-                isNot = !isNot;
-                return this;
-            },
-        };
-        return instance;
-    }
-    else {
-        const instance = {
-            toMatch,
-            toBe,
-            toBeTruthy,
-            toBeNull,
-            toBeNaN,
-            toBeUndefined,
-            changed,
-            changedTimes,
-            get not() {
-                isNot = !isNot;
-                return this;
-            },
-        };
-        return instance;
-    }
+function useDebounceFn(fn, ms = 200) {
+  return createFilterWrapper(debounceFilter(ms), fn);
 }
 
-/**
- * Basic counter with utility functions.
- *
- * @see https://vueuse.org/useCounter
- * @param [initialValue=0]
- */
-function useCounter(initialValue = 0) {
-    const count = vueDemi.ref(initialValue);
-    const inc = (delta = 1) => (count.value += delta);
-    const dec = (delta = 1) => (count.value -= delta);
-    const get = () => count.value;
-    const set = (val) => (count.value = val);
-    const reset = (val = initialValue) => {
-        initialValue = val;
-        return set(val);
-    };
-    return { count, inc, dec, get, set, reset };
+function useDebounce(value, ms = 200) {
+  if (ms <= 0)
+    return value;
+  const debounced = vueDemi.ref(value.value);
+  const updater = useDebounceFn(() => {
+    debounced.value = value.value;
+  }, ms);
+  vueDemi.watch(value, () => updater());
+  return debounced;
 }
 
-/**
- * Debounce execution of a function.
- *
- * @param  fn          A function to be executed after delay milliseconds debounced.
- * @param  ms          A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
- *
- * @return A new, debounce, function.
- */
-function useDebounceFn(fn, ms = 200) {
-    return createFilterWrapper(debounceFilter(ms), fn);
+function useIntervalFn(cb, interval = 1e3, options = {}) {
+  const {
+    immediate = true,
+    immediateCallback = false
+  } = options;
+  let timer = null;
+  const isActive = vueDemi.ref(false);
+  function clean() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+  function pause() {
+    isActive.value = false;
+    clean();
+  }
+  function resume() {
+    if (interval <= 0)
+      return;
+    isActive.value = true;
+    if (immediateCallback)
+      cb();
+    clean();
+    timer = setInterval(cb, interval);
+  }
+  if (immediate && isClient)
+    resume();
+  tryOnScopeDispose(pause);
+  return {
+    isActive,
+    pause,
+    resume
+  };
 }
 
-function useDebounce(value, ms = 200) {
-    if (ms <= 0)
-        return value;
-    const debounced = vueDemi.ref(value.value);
-    const updater = useDebounceFn(() => {
-        debounced.value = value.value;
-    }, ms);
-    vueDemi.watch(value, () => updater());
-    return debounced;
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+function useInterval(interval = 1e3, options = {}) {
+  const {
+    controls: exposeControls = false,
+    immediate = true
+  } = options;
+  const counter = vueDemi.ref(0);
+  const controls = useIntervalFn(() => counter.value += 1, interval, { immediate });
+  if (exposeControls) {
+    return __spreadValues$1({
+      counter
+    }, controls);
+  } else {
+    return counter;
+  }
 }
 
-/**
- * Wrapper for `setInterval` with controls
- *
- * @param cb
- * @param interval
- * @param options
- */
-function useIntervalFn(cb, interval = 1000, options = {}) {
-    const { immediate = true, immediateCallback = false, } = options;
-    let timer = null;
-    const isActive = vueDemi.ref(false);
-    function clean() {
-        if (timer) {
-            clearInterval(timer);
-            timer = null;
-        }
-    }
-    function pause() {
-        isActive.value = false;
-        clean();
-    }
-    function resume() {
-        if (interval <= 0)
-            return;
-        isActive.value = true;
-        if (immediateCallback)
-            cb();
-        clean();
-        timer = setInterval(cb, interval);
-    }
-    if (immediate && isClient)
-        resume();
-    tryOnScopeDispose(pause);
-    return {
-        isActive,
-        pause,
-        resume,
-    };
+function useLastChanged(source, options = {}) {
+  var _a;
+  const ms = vueDemi.ref((_a = options.initialValue) != null ? _a : null);
+  vueDemi.watch(source, () => ms.value = timestamp(), options);
+  return ms;
 }
 
-function useInterval(interval = 1000, options = {}) {
-    const { controls: exposeControls = false, immediate = true, } = options;
-    const counter = vueDemi.ref(0);
-    const controls = useIntervalFn(() => counter.value += 1, interval, { immediate });
-    if (exposeControls) {
-        return Object.assign({ counter }, controls);
-    }
-    else {
-        return counter;
-    }
+function useThrottleFn(fn, ms = 200, trailing = true, leading = true) {
+  return createFilterWrapper(throttleFilter(ms, trailing, leading), fn);
 }
 
-function useLastChanged(source, options = {}) {
-    var _a;
-    const ms = vueDemi.ref((_a = options.initialValue) !== null && _a !== void 0 ? _a : null);
-    vueDemi.watch(source, () => ms.value = timestamp(), options);
-    return ms;
+function useThrottle(value, delay = 200, trailing = true, leading = true) {
+  if (delay <= 0)
+    return value;
+  const throttled = vueDemi.ref(value.value);
+  const updater = useThrottleFn(() => {
+    throttled.value = value.value;
+  }, delay, trailing, leading);
+  vueDemi.watch(value, () => updater());
+  return throttled;
 }
 
-/**
- * Throttle execution of a function. Especially useful for rate limiting
- * execution of handlers on events like resize and scroll.
- *
- * @param   fn             A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,
- *                                    to `callback` when the throttled-function is executed.
- * @param   ms             A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
- *
- * @return  A new, throttled, function.
- */
-function useThrottleFn(fn, ms = 200, trailing = true) {
-    return createFilterWrapper(throttleFilter(ms, trailing), fn);
+function useTimeoutFn(cb, interval, options = {}) {
+  const {
+    immediate = true
+  } = options;
+  const isPending = vueDemi.ref(false);
+  let timer = null;
+  function clear() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  function stop() {
+    isPending.value = false;
+    clear();
+  }
+  function start(...args) {
+    clear();
+    isPending.value = true;
+    timer = setTimeout(() => {
+      isPending.value = false;
+      timer = null;
+      cb(...args);
+    }, vueDemi.unref(interval));
+  }
+  if (immediate) {
+    isPending.value = true;
+    if (isClient)
+      start();
+  }
+  tryOnScopeDispose(stop);
+  return {
+    isPending,
+    start,
+    stop
+  };
 }
 
-/**
- * Throttle execution of a function. Especially useful for rate limiting
- * execution of handlers on events like resize and scroll.
- *
- * @param  delay  A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
- */
-function useThrottle(value, delay = 200) {
-    if (delay <= 0)
-        return value;
-    const throttled = vueDemi.ref(value.value);
-    const updater = useThrottleFn(() => {
-        throttled.value = value.value;
-    }, delay);
-    vueDemi.watch(value, () => updater());
-    return throttled;
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+function useTimeout(interval = 1e3, options = {}) {
+  const {
+    controls: exposeControls = false
+  } = options;
+  const controls = useTimeoutFn(noop, interval, options);
+  const ready = vueDemi.computed(() => !controls.isPending.value);
+  if (exposeControls) {
+    return __spreadValues({
+      ready
+    }, controls);
+  } else {
+    return ready;
+  }
 }
 
-/**
- * Wrapper for `setTimeout` with controls.
- *
- * @param cb
- * @param interval
- * @param immediate
- */
-function useTimeoutFn(cb, interval, options = {}) {
-    const { immediate = true, } = options;
-    const isPending = vueDemi.ref(false);
-    let timer = null;
-    function clear() {
-        if (timer) {
-            clearTimeout(timer);
-            timer = null;
-        }
-    }
-    function stop() {
-        isPending.value = false;
-        clear();
-    }
-    function start(...args) {
-        clear();
-        isPending.value = true;
-        timer = setTimeout(() => {
-            isPending.value = false;
-            timer = null;
-            // eslint-disable-next-line node/no-callback-literal
-            cb(...args);
-        }, vueDemi.unref(interval));
-    }
-    if (immediate) {
-        isPending.value = true;
-        if (isClient)
-            start();
-    }
-    tryOnScopeDispose(stop);
-    return {
-        isPending,
-        start,
-        stop,
-    };
+function useToggle(initialValue = false) {
+  if (vueDemi.isRef(initialValue)) {
+    return (value) => {
+      initialValue.value = typeof value === "boolean" ? value : !initialValue.value;
+    };
+  } else {
+    const boolean = vueDemi.ref(initialValue);
+    const toggle = (value) => {
+      boolean.value = typeof value === "boolean" ? value : !boolean.value;
+    };
+    return [boolean, toggle];
+  }
 }
 
-function useTimeout(interval = 1000, options = {}) {
-    const { controls: exposeControls = false, } = options;
-    const controls = useTimeoutFn(noop, interval, options);
-    const ready = vueDemi.computed(() => !controls.isPending.value);
-    if (exposeControls) {
-        return Object.assign({ ready }, controls);
-    }
-    else {
-        return ready;
-    }
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function watchAtMost(source, cb, options) {
+  const _a = options, {
+    count
+  } = _a, watchOptions = __objRest(_a, [
+    "count"
+  ]);
+  const current = vueDemi.ref(0);
+  const stop = watchWithFilter(source, (...args) => {
+    current.value += 1;
+    if (current.value >= vueDemi.unref(count))
+      stop();
+    cb(...args);
+  }, watchOptions);
+  return { count: current, stop };
 }
 
-function useToggle(initialValue = false) {
-    if (vueDemi.isRef(initialValue)) {
-        return (value) => {
-            initialValue.value = typeof value === 'boolean'
-                ? value
-                : !initialValue.value;
-        };
-    }
-    else {
-        const boolean = vueDemi.ref(initialValue);
-        const toggle = (value) => {
-            boolean.value = typeof value === 'boolean'
-                ? value
-                : !boolean.value;
-        };
-        return [boolean, toggle];
-    }
+function watchOnce(source, cb, options) {
+  const stop = vueDemi.watch(source, (...args) => {
+    stop();
+    return cb(...args);
+  }, options);
 }
 
-/**
- * Shorthand for watching value to be truthy
- *
- * @see https://vueuse.js.org/whenever
- */
-function whenever(source, cb, options) {
-    return vueDemi.watch(source, (v, ov, onInvalidate) => { if (v)
-        cb(v, ov, onInvalidate); }, options);
+function whenever(source, cb, options) {
+  return vueDemi.watch(source, (v, ov, onInvalidate) => {
+    if (v)
+      cb(v, ov, onInvalidate);
+  }, options);
 }
 
 exports.and = and;
@@ -1168,5 +1169,7 @@ exports.useThrottleFn = useThrottleFn;
 exports.useTimeout = useTimeout;
 exports.useTimeoutFn = useTimeoutFn;
 exports.useToggle = useToggle;
+exports.watchAtMost = watchAtMost;
+exports.watchOnce = watchOnce;
 exports.watchWithFilter = watchWithFilter;
 exports.whenever = whenever;