@vueuse/shared 6.3.2 → 6.5.3

package/index.iife.js

@@ -62,1102 +62,1103 @@
 ;(function (exports, vueDemi) {
   'use strict';
 
-  /**
-   * `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 };
+  }
+
+  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;
+    }, {});
+  }
 
-  /**
-   * @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 };
+  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);
   }
 
-  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 __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 watchWithFilter(source, cb, options = {}) {
-      const { eventFilter = bypassFilter } = options, watchOptions = __rest(options, ["eventFilter"]);
-      return vueDemi.watch(source, createFilterWrapper(eventFilter, cb), watchOptions);
+  function eagerComputed(fn) {
+    const result = vueDemi.shallowRef();
+    vueDemi.watchSyncEffect(() => {
+      result.value = fn();
+    });
+    return vueDemi.readonly(result);
   }
 
-  // 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 get(obj, key) {
+    if (key == null)
+      return vueDemi.unref(obj);
+    return vueDemi.unref(obj)[key];
   }
 
-  // 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);
+  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 };
   }
 
-  function get(obj, key) {
-      if (key == null)
-          return vueDemi.unref(obj);
-      return vueDemi.unref(obj)[key];
+  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;
@@ -1226,9 +1227,11 @@
   exports.useTimeout = useTimeout;
   exports.useTimeoutFn = useTimeoutFn;
   exports.useToggle = useToggle;
+  exports.watchAtMost = watchAtMost;
+  exports.watchOnce = watchOnce;
   exports.watchWithFilter = watchWithFilter;
   exports.whenever = whenever;
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
-}(this.VueUse = this.VueUse || {}, VueDemi));
+})(this.VueUse = this.VueUse || {}, VueDemi);