@vc-shell/framework 1.1.45 → 1.1.47

package/dist/vendor-vueuse-shared-_mOXsFuM.js

@@ -1,1568 +0,0 @@
-import { computed, isRef, reactive, unref, effectScope, watch, nextTick, customRef, shallowRef, watchEffect, readonly, ref, getCurrentInstance, inject, provide, toRefs as toRefs$1, toRef as toRef$1, onBeforeMount, onBeforeUnmount, onMounted, getCurrentScope, onScopeDispose, onUnmounted, isReactive } from 'vue';
-
-function computedEager(fn, options) {
-  var _a;
-  const result = shallowRef();
-  watchEffect(() => {
-    result.value = fn();
-  }, {
-    ...options,
-    flush: (_a = options == null ? void 0 : options.flush) != null ? _a : "sync"
-  });
-  return readonly(result);
-}
-
-function computedWithControl(source, fn) {
-  let v = void 0;
-  let track;
-  let trigger;
-  const dirty = ref(true);
-  const update = () => {
-    dirty.value = true;
-    trigger();
-  };
-  watch(source, update, { flush: "sync" });
-  const get = typeof fn === "function" ? fn : fn.get;
-  const set = typeof fn === "function" ? void 0 : fn.set;
-  const result = customRef((_track, _trigger) => {
-    track = _track;
-    trigger = _trigger;
-    return {
-      get() {
-        if (dirty.value) {
-          v = get();
-          dirty.value = false;
-        }
-        track();
-        return v;
-      },
-      set(v2) {
-        set == null ? void 0 : set(v2);
-      }
-    };
-  });
-  if (Object.isExtensible(result))
-    result.trigger = update;
-  return result;
-}
-
-function tryOnScopeDispose(fn) {
-  if (getCurrentScope()) {
-    onScopeDispose(fn);
-    return true;
-  }
-  return false;
-}
-
-function createEventHook() {
-  const fns = /* @__PURE__ */ new Set();
-  const off = (fn) => {
-    fns.delete(fn);
-  };
-  const on = (fn) => {
-    fns.add(fn);
-    const offFn = () => off(fn);
-    tryOnScopeDispose(offFn);
-    return {
-      off: offFn
-    };
-  };
-  const trigger = (...args) => {
-    return Promise.all(Array.from(fns).map((fn) => fn(...args)));
-  };
-  return {
-    on,
-    off,
-    trigger
-  };
-}
-
-function createGlobalState(stateFactory) {
-  let initialized = false;
-  let state;
-  const scope = effectScope(true);
-  return (...args) => {
-    if (!initialized) {
-      state = scope.run(() => stateFactory(...args));
-      initialized = true;
-    }
-    return state;
-  };
-}
-
-const localProvidedStateMap = /* @__PURE__ */ new WeakMap();
-
-const provideLocal = (key, value) => {
-  var _a;
-  const instance = (_a = getCurrentInstance()) == null ? void 0 : _a.proxy;
-  if (instance == null)
-    throw new Error("provideLocal must be called in setup");
-  if (!localProvidedStateMap.has(instance))
-    localProvidedStateMap.set(instance, /* @__PURE__ */ Object.create(null));
-  const localProvidedState = localProvidedStateMap.get(instance);
-  localProvidedState[key] = value;
-  provide(key, value);
-};
-
-const injectLocal = (...args) => {
-  var _a;
-  const key = args[0];
-  const instance = (_a = getCurrentInstance()) == null ? void 0 : _a.proxy;
-  if (instance == null)
-    throw new Error("injectLocal must be called in setup");
-  if (localProvidedStateMap.has(instance) && key in localProvidedStateMap.get(instance))
-    return localProvidedStateMap.get(instance)[key];
-  return inject(...args);
-};
-
-function createInjectionState(composable, options) {
-  const key = (options == null ? void 0 : options.injectionKey) || Symbol(composable.name || "InjectionState");
-  const defaultValue = options == null ? void 0 : options.defaultValue;
-  const useProvidingState = (...args) => {
-    const state = composable(...args);
-    provideLocal(key, state);
-    return state;
-  };
-  const useInjectedState = () => injectLocal(key, defaultValue);
-  return [useProvidingState, useInjectedState];
-}
-
-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 = effectScope(true);
-      state = scope.run(() => composable(...args));
-    }
-    tryOnScopeDispose(dispose);
-    return state;
-  };
-}
-
-function extendRef(ref, extend, { enumerable = false, unwrap = true } = {}) {
-  for (const [key, value] of Object.entries(extend)) {
-    if (key === "value")
-      continue;
-    if (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 get(obj, key) {
-  if (key == null)
-    return unref(obj);
-  return unref(obj)[key];
-}
-
-function isDefined(v) {
-  return unref(v) != null;
-}
-
-function makeDestructurable(obj, arr) {
-  if (typeof Symbol !== "undefined") {
-    const clone = { ...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 toValue(r) {
-  return typeof r === "function" ? r() : unref(r);
-}
-const resolveUnref = toValue;
-
-function reactify(fn, options) {
-  const unrefFn = (options == null ? void 0 : options.computedGetter) === false ? unref : toValue;
-  return function(...args) {
-    return computed(() => fn.apply(this, args.map((i) => unrefFn(i))));
-  };
-}
-
-function reactifyObject(obj, optionsOrKeys = {}) {
-  let keys = [];
-  let options;
-  if (Array.isArray(optionsOrKeys)) {
-    keys = optionsOrKeys;
-  } else {
-    options = optionsOrKeys;
-    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), options) : value
-      ];
-    })
-  );
-}
-
-function toReactive(objectRef) {
-  if (!isRef(objectRef))
-    return reactive(objectRef);
-  const proxy = new Proxy({}, {
-    get(_, p, receiver) {
-      return unref(Reflect.get(objectRef.value, p, receiver));
-    },
-    set(_, p, value) {
-      if (isRef(objectRef.value[p]) && !isRef(value))
-        objectRef.value[p].value = value;
-      else
-        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 reactive(proxy);
-}
-
-function reactiveComputed(fn) {
-  return toReactive(computed(fn));
-}
-
-function reactiveOmit(obj, ...keys) {
-  const flatKeys = keys.flat();
-  const predicate = flatKeys[0];
-  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(toRefs$1(obj)).filter(([k, v]) => !predicate(toValue(v), k))) : Object.fromEntries(Object.entries(toRefs$1(obj)).filter((e) => !flatKeys.includes(e[0]))));
-}
-
-const isClient = typeof window !== "undefined" && typeof document !== "undefined";
-const isWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
-const isDef = (val) => typeof val !== "undefined";
-const notNullish = (val) => val != null;
-const assert = (condition, ...infos) => {
-  if (!condition)
-    console.warn(...infos);
-};
-const toString = Object.prototype.toString;
-const isObject = (val) => toString.call(val) === "[object Object]";
-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 hasOwn = (val, key) => Object.prototype.hasOwnProperty.call(val, key);
-const isIOS = /* @__PURE__ */ getIsIOS();
-function getIsIOS() {
-  var _a, _b;
-  return isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((_b = window == null ? void 0 : window.navigator) == null ? void 0 : _b.maxTouchPoints) > 2 && /iPad|Macintosh/.test(window == null ? void 0 : window.navigator.userAgent));
-}
-
-function createFilterWrapper(filter, fn) {
-  function wrapper(...args) {
-    return new Promise((resolve, reject) => {
-      Promise.resolve(filter(() => fn.apply(this, args), { fn, thisArg: this, args })).then(resolve).catch(reject);
-    });
-  }
-  return wrapper;
-}
-const bypassFilter = (invoke) => {
-  return invoke();
-};
-function debounceFilter(ms, options = {}) {
-  let timer;
-  let maxTimer;
-  let lastRejector = noop;
-  const _clearTimeout = (timer2) => {
-    clearTimeout(timer2);
-    lastRejector();
-    lastRejector = noop;
-  };
-  const filter = (invoke) => {
-    const duration = toValue(ms);
-    const maxDuration = toValue(options.maxWait);
-    if (timer)
-      _clearTimeout(timer);
-    if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
-      if (maxTimer) {
-        _clearTimeout(maxTimer);
-        maxTimer = null;
-      }
-      return Promise.resolve(invoke());
-    }
-    return new Promise((resolve, reject) => {
-      lastRejector = options.rejectOnCancel ? reject : resolve;
-      if (maxDuration && !maxTimer) {
-        maxTimer = setTimeout(() => {
-          if (timer)
-            _clearTimeout(timer);
-          maxTimer = null;
-          resolve(invoke());
-        }, maxDuration);
-      }
-      timer = setTimeout(() => {
-        if (maxTimer)
-          _clearTimeout(maxTimer);
-        maxTimer = null;
-        resolve(invoke());
-      }, duration);
-    });
-  };
-  return filter;
-}
-function throttleFilter(...args) {
-  let lastExec = 0;
-  let timer;
-  let isLeading = true;
-  let lastRejector = noop;
-  let lastValue;
-  let ms;
-  let trailing;
-  let leading;
-  let rejectOnCancel;
-  if (!isRef(args[0]) && typeof args[0] === "object")
-    ({ delay: ms, trailing = true, leading = true, rejectOnCancel = false } = args[0]);
-  else
-    [ms, trailing = true, leading = true, rejectOnCancel = false] = args;
-  const clear = () => {
-    if (timer) {
-      clearTimeout(timer);
-      timer = void 0;
-      lastRejector();
-      lastRejector = noop;
-    }
-  };
-  const filter = (_invoke) => {
-    const duration = toValue(ms);
-    const elapsed = Date.now() - lastExec;
-    const invoke = () => {
-      return lastValue = _invoke();
-    };
-    clear();
-    if (duration <= 0) {
-      lastExec = Date.now();
-      return invoke();
-    }
-    if (elapsed > duration && (leading || !isLeading)) {
-      lastExec = Date.now();
-      invoke();
-    } else if (trailing) {
-      lastValue = new Promise((resolve, reject) => {
-        lastRejector = rejectOnCancel ? reject : resolve;
-        timer = setTimeout(() => {
-          lastExec = Date.now();
-          isLeading = true;
-          resolve(invoke());
-          clear();
-        }, Math.max(0, duration - elapsed));
-      });
-    }
-    if (!leading && !timer)
-      timer = setTimeout(() => isLeading = true, duration);
-    isLeading = false;
-    return lastValue;
-  };
-  return filter;
-}
-function pausableFilter(extendFilter = bypassFilter) {
-  const isActive = ref(true);
-  function pause() {
-    isActive.value = false;
-  }
-  function resume() {
-    isActive.value = true;
-  }
-  const eventFilter = (...args) => {
-    if (isActive.value)
-      extendFilter(...args);
-  };
-  return { isActive: readonly(isActive), pause, resume, eventFilter };
-}
-
-const directiveHooks = {
-  mounted: "mounted" ,
-  updated: "updated" ,
-  unmounted: "unmounted" 
-};
-
-function cacheStringFunction(fn) {
-  const cache = /* @__PURE__ */ Object.create(null);
-  return (str) => {
-    const hit = cache[str];
-    return hit || (cache[str] = fn(str));
-  };
-}
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
-const camelizeRE = /-(\w)/g;
-const camelize = cacheStringFunction((str) => {
-  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
-});
-
-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(/^-?\d+\.?\d*/)) == null ? void 0 : _a[0]) || "";
-  const unit = target.slice(value.length);
-  const result = Number.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 objectOmit(obj, keys, omitUndefined = false) {
-  return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {
-    return (!omitUndefined || value !== void 0) && !keys.includes(key);
-  }));
-}
-function objectEntries(obj) {
-  return Object.entries(obj);
-}
-function getLifeCycleTarget(target) {
-  return target || getCurrentInstance();
-}
-
-function toRef(...args) {
-  if (args.length !== 1)
-    return toRef$1(...args);
-  const r = args[0];
-  return typeof r === "function" ? readonly(customRef(() => ({ get: r, set: noop }))) : ref(r);
-}
-const resolveRef = toRef;
-
-function reactivePick(obj, ...keys) {
-  const flatKeys = keys.flat();
-  const predicate = flatKeys[0];
-  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(toRefs$1(obj)).filter(([k, v]) => predicate(toValue(v), k))) : Object.fromEntries(flatKeys.map((k) => [k, toRef(obj, k)])));
-}
-
-function refAutoReset(defaultValue, afterMs = 1e4) {
-  return customRef((track, trigger) => {
-    let value = toValue(defaultValue);
-    let timer;
-    const resetAfter = () => setTimeout(() => {
-      value = toValue(defaultValue);
-      trigger();
-    }, toValue(afterMs));
-    tryOnScopeDispose(() => {
-      clearTimeout(timer);
-    });
-    return {
-      get() {
-        track();
-        return value;
-      },
-      set(newValue) {
-        value = newValue;
-        trigger();
-        clearTimeout(timer);
-        timer = resetAfter();
-      }
-    };
-  });
-}
-
-function useDebounceFn(fn, ms = 200, options = {}) {
-  return createFilterWrapper(
-    debounceFilter(ms, options),
-    fn
-  );
-}
-
-function refDebounced(value, ms = 200, options = {}) {
-  const debounced = ref(value.value);
-  const updater = useDebounceFn(() => {
-    debounced.value = value.value;
-  }, ms, options);
-  watch(value, () => updater());
-  return debounced;
-}
-
-function refDefault(source, defaultValue) {
-  return computed({
-    get() {
-      var _a;
-      return (_a = source.value) != null ? _a : defaultValue;
-    },
-    set(value) {
-      source.value = value;
-    }
-  });
-}
-
-function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
-  return createFilterWrapper(
-    throttleFilter(ms, trailing, leading, rejectOnCancel),
-    fn
-  );
-}
-
-function refThrottled(value, delay = 200, trailing = true, leading = true) {
-  if (delay <= 0)
-    return value;
-  const throttled = ref(value.value);
-  const updater = useThrottleFn(() => {
-    throttled.value = value.value;
-  }, delay, trailing, leading);
-  watch(value, () => updater());
-  return throttled;
-}
-
-function refWithControl(initial, options = {}) {
-  let source = initial;
-  let track;
-  let trigger;
-  const ref = 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 }
-  );
-}
-const controlledRef = refWithControl;
-
-function set(...args) {
-  if (args.length === 2) {
-    const [ref, value] = args;
-    ref.value = value;
-  }
-  if (args.length === 3) {
-    {
-      const [target, key, value] = args;
-      target[key] = value;
-    }
-  }
-}
-
-function watchWithFilter(source, cb, options = {}) {
-  const {
-    eventFilter = bypassFilter,
-    ...watchOptions
-  } = options;
-  return watch(
-    source,
-    createFilterWrapper(
-      eventFilter,
-      cb
-    ),
-    watchOptions
-  );
-}
-
-function watchPausable(source, cb, options = {}) {
-  const {
-    eventFilter: filter,
-    ...watchOptions
-  } = options;
-  const { eventFilter, pause, resume, isActive } = pausableFilter(filter);
-  const stop = watchWithFilter(
-    source,
-    cb,
-    {
-      ...watchOptions,
-      eventFilter
-    }
-  );
-  return { stop, pause, resume, isActive };
-}
-
-function syncRef(left, right, ...[options]) {
-  const {
-    flush = "sync",
-    deep = false,
-    immediate = true,
-    direction = "both",
-    transform = {}
-  } = options || {};
-  const watchers = [];
-  const transformLTR = "ltr" in transform && transform.ltr || ((v) => v);
-  const transformRTL = "rtl" in transform && transform.rtl || ((v) => v);
-  if (direction === "both" || direction === "ltr") {
-    watchers.push(watchPausable(
-      left,
-      (newValue) => {
-        watchers.forEach((w) => w.pause());
-        right.value = transformLTR(newValue);
-        watchers.forEach((w) => w.resume());
-      },
-      { flush, deep, immediate }
-    ));
-  }
-  if (direction === "both" || direction === "rtl") {
-    watchers.push(watchPausable(
-      right,
-      (newValue) => {
-        watchers.forEach((w) => w.pause());
-        left.value = transformRTL(newValue);
-        watchers.forEach((w) => w.resume());
-      },
-      { flush, deep, immediate }
-    ));
-  }
-  const stop = () => {
-    watchers.forEach((w) => w.stop());
-  };
-  return stop;
-}
-
-function syncRefs(source, targets, options = {}) {
-  const {
-    flush = "sync",
-    deep = false,
-    immediate = true
-  } = options;
-  if (!Array.isArray(targets))
-    targets = [targets];
-  return watch(
-    source,
-    (newValue) => targets.forEach((target) => target.value = newValue),
-    { flush, deep, immediate }
-  );
-}
-
-function toRefs(objectRef, options = {}) {
-  if (!isRef(objectRef))
-    return toRefs$1(objectRef);
-  const result = Array.isArray(objectRef.value) ? Array.from({ length: objectRef.value.length }) : {};
-  for (const key in objectRef.value) {
-    result[key] = customRef(() => ({
-      get() {
-        return objectRef.value[key];
-      },
-      set(v) {
-        var _a;
-        const replaceRef = (_a = toValue(options.replaceRef)) != null ? _a : true;
-        if (replaceRef) {
-          if (Array.isArray(objectRef.value)) {
-            const copy = [...objectRef.value];
-            copy[key] = v;
-            objectRef.value = copy;
-          } else {
-            const newObject = { ...objectRef.value, [key]: v };
-            Object.setPrototypeOf(newObject, Object.getPrototypeOf(objectRef.value));
-            objectRef.value = newObject;
-          }
-        } else {
-          objectRef.value[key] = v;
-        }
-      }
-    }));
-  }
-  return result;
-}
-
-function tryOnBeforeMount(fn, sync = true, target) {
-  const instance = getLifeCycleTarget(target);
-  if (instance)
-    onBeforeMount(fn, target);
-  else if (sync)
-    fn();
-  else
-    nextTick(fn);
-}
-
-function tryOnBeforeUnmount(fn, target) {
-  const instance = getLifeCycleTarget(target);
-  if (instance)
-    onBeforeUnmount(fn, target);
-}
-
-function tryOnMounted(fn, sync = true, target) {
-  const instance = getLifeCycleTarget();
-  if (instance)
-    onMounted(fn, target);
-  else if (sync)
-    fn();
-  else
-    nextTick(fn);
-}
-
-function tryOnUnmounted(fn, target) {
-  const instance = getLifeCycleTarget(target);
-  if (instance)
-    onUnmounted(fn, target);
-}
-
-function createUntil(r, isNot = false) {
-  function toMatch(condition, { flush = "sync", deep = false, timeout, throwOnTimeout } = {}) {
-    let stop = null;
-    const watcher = new Promise((resolve) => {
-      stop = watch(
-        r,
-        (v) => {
-          if (condition(v) !== isNot) {
-            stop == null ? void 0 : stop();
-            resolve(v);
-          }
-        },
-        {
-          flush,
-          deep,
-          immediate: true
-        }
-      );
-    });
-    const promises = [watcher];
-    if (timeout != null) {
-      promises.push(
-        promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => stop == null ? void 0 : stop())
-      );
-    }
-    return Promise.race(promises);
-  }
-  function toBe(value, options) {
-    if (!isRef(value))
-      return toMatch((v) => v === value, options);
-    const { flush = "sync", deep = false, timeout, throwOnTimeout } = options != null ? options : {};
-    let stop = null;
-    const watcher = new Promise((resolve) => {
-      stop = watch(
-        [r, value],
-        ([v1, v2]) => {
-          if (isNot !== (v1 === v2)) {
-            stop == null ? void 0 : stop();
-            resolve(v1);
-          }
-        },
-        {
-          flush,
-          deep,
-          immediate: true
-        }
-      );
-    });
-    const promises = [watcher];
-    if (timeout != null) {
-      promises.push(
-        promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => {
-          stop == null ? void 0 : stop();
-          return toValue(r);
-        })
-      );
-    }
-    return Promise.race(promises);
-  }
-  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(toValue(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(toValue(r))) {
-    const instance = {
-      toMatch,
-      toContains,
-      changed,
-      changedTimes,
-      get not() {
-        return createUntil(r, !isNot);
-      }
-    };
-    return instance;
-  } else {
-    const instance = {
-      toMatch,
-      toBe,
-      toBeTruthy,
-      toBeNull,
-      toBeNaN,
-      toBeUndefined,
-      changed,
-      changedTimes,
-      get not() {
-        return createUntil(r, !isNot);
-      }
-    };
-    return instance;
-  }
-}
-function until(r) {
-  return createUntil(r);
-}
-
-function defaultComparator(value, othVal) {
-  return value === othVal;
-}
-function useArrayDifference(...args) {
-  var _a;
-  const list = args[0];
-  const values = args[1];
-  let compareFn = (_a = args[2]) != null ? _a : defaultComparator;
-  if (typeof compareFn === "string") {
-    const key = compareFn;
-    compareFn = (value, othVal) => value[key] === othVal[key];
-  }
-  return computed(() => toValue(list).filter((x) => toValue(values).findIndex((y) => compareFn(x, y)) === -1));
-}
-
-function useArrayEvery(list, fn) {
-  return computed(() => toValue(list).every((element, index, array) => fn(toValue(element), index, array)));
-}
-
-function useArrayFilter(list, fn) {
-  return computed(() => toValue(list).map((i) => toValue(i)).filter(fn));
-}
-
-function useArrayFind(list, fn) {
-  return computed(() => toValue(
-    toValue(list).find((element, index, array) => fn(toValue(element), index, array))
-  ));
-}
-
-function useArrayFindIndex(list, fn) {
-  return computed(() => toValue(list).findIndex((element, index, array) => fn(toValue(element), index, array)));
-}
-
-function findLast(arr, cb) {
-  let index = arr.length;
-  while (index-- > 0) {
-    if (cb(arr[index], index, arr))
-      return arr[index];
-  }
-  return void 0;
-}
-function useArrayFindLast(list, fn) {
-  return computed(() => toValue(
-    !Array.prototype.findLast ? findLast(toValue(list), (element, index, array) => fn(toValue(element), index, array)) : toValue(list).findLast((element, index, array) => fn(toValue(element), index, array))
-  ));
-}
-
-function isArrayIncludesOptions(obj) {
-  return isObject(obj) && containsProp(obj, "formIndex", "comparator");
-}
-function useArrayIncludes(...args) {
-  var _a;
-  const list = args[0];
-  const value = args[1];
-  let comparator = args[2];
-  let formIndex = 0;
-  if (isArrayIncludesOptions(comparator)) {
-    formIndex = (_a = comparator.fromIndex) != null ? _a : 0;
-    comparator = comparator.comparator;
-  }
-  if (typeof comparator === "string") {
-    const key = comparator;
-    comparator = (element, value2) => element[key] === toValue(value2);
-  }
-  comparator = comparator != null ? comparator : (element, value2) => element === toValue(value2);
-  return computed(() => toValue(list).slice(formIndex).some((element, index, array) => comparator(
-    toValue(element),
-    toValue(value),
-    index,
-    toValue(array)
-  )));
-}
-
-function useArrayJoin(list, separator) {
-  return computed(() => toValue(list).map((i) => toValue(i)).join(toValue(separator)));
-}
-
-function useArrayMap(list, fn) {
-  return computed(() => toValue(list).map((i) => toValue(i)).map(fn));
-}
-
-function useArrayReduce(list, reducer, ...args) {
-  const reduceCallback = (sum, value, index) => reducer(toValue(sum), toValue(value), index);
-  return computed(() => {
-    const resolved = toValue(list);
-    return args.length ? resolved.reduce(reduceCallback, toValue(args[0])) : resolved.reduce(reduceCallback);
-  });
-}
-
-function useArraySome(list, fn) {
-  return computed(() => toValue(list).some((element, index, array) => fn(toValue(element), index, array)));
-}
-
-function uniq(array) {
-  return Array.from(new Set(array));
-}
-function uniqueElementsBy(array, fn) {
-  return array.reduce((acc, v) => {
-    if (!acc.some((x) => fn(v, x, array)))
-      acc.push(v);
-    return acc;
-  }, []);
-}
-function useArrayUnique(list, compareFn) {
-  return computed(() => {
-    const resolvedList = toValue(list).map((element) => toValue(element));
-    return compareFn ? uniqueElementsBy(resolvedList, compareFn) : uniq(resolvedList);
-  });
-}
-
-function useCounter(initialValue = 0, options = {}) {
-  let _initialValue = unref(initialValue);
-  const count = ref(initialValue);
-  const {
-    max = Number.POSITIVE_INFINITY,
-    min = Number.NEGATIVE_INFINITY
-  } = options;
-  const inc = (delta = 1) => count.value = Math.max(Math.min(max, count.value + delta), min);
-  const dec = (delta = 1) => count.value = Math.min(Math.max(min, count.value - delta), max);
-  const get = () => count.value;
-  const set = (val) => count.value = Math.max(min, Math.min(max, val));
-  const reset = (val = _initialValue) => {
-    _initialValue = val;
-    return set(val);
-  };
-  return { count, inc, dec, get, set, reset };
-}
-
-const REGEX_PARSE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[T\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/i;
-const REGEX_FORMAT = /[YMDHhms]o|\[([^\]]+)\]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a{1,2}|A{1,2}|m{1,2}|s{1,2}|Z{1,2}|SSS/g;
-function defaultMeridiem(hours, minutes, isLowercase, hasPeriod) {
-  let m = hours < 12 ? "AM" : "PM";
-  if (hasPeriod)
-    m = m.split("").reduce((acc, curr) => acc += `${curr}.`, "");
-  return isLowercase ? m.toLowerCase() : m;
-}
-function formatOrdinal(num) {
-  const suffixes = ["th", "st", "nd", "rd"];
-  const v = num % 100;
-  return num + (suffixes[(v - 20) % 10] || suffixes[v] || suffixes[0]);
-}
-function formatDate(date, formatStr, options = {}) {
-  var _a;
-  const years = date.getFullYear();
-  const month = date.getMonth();
-  const days = date.getDate();
-  const hours = date.getHours();
-  const minutes = date.getMinutes();
-  const seconds = date.getSeconds();
-  const milliseconds = date.getMilliseconds();
-  const day = date.getDay();
-  const meridiem = (_a = options.customMeridiem) != null ? _a : defaultMeridiem;
-  const matches = {
-    Yo: () => formatOrdinal(years),
-    YY: () => String(years).slice(-2),
-    YYYY: () => years,
-    M: () => month + 1,
-    Mo: () => formatOrdinal(month + 1),
-    MM: () => `${month + 1}`.padStart(2, "0"),
-    MMM: () => date.toLocaleDateString(options.locales, { month: "short" }),
-    MMMM: () => date.toLocaleDateString(options.locales, { month: "long" }),
-    D: () => String(days),
-    Do: () => formatOrdinal(days),
-    DD: () => `${days}`.padStart(2, "0"),
-    H: () => String(hours),
-    Ho: () => formatOrdinal(hours),
-    HH: () => `${hours}`.padStart(2, "0"),
-    h: () => `${hours % 12 || 12}`.padStart(1, "0"),
-    ho: () => formatOrdinal(hours % 12 || 12),
-    hh: () => `${hours % 12 || 12}`.padStart(2, "0"),
-    m: () => String(minutes),
-    mo: () => formatOrdinal(minutes),
-    mm: () => `${minutes}`.padStart(2, "0"),
-    s: () => String(seconds),
-    so: () => formatOrdinal(seconds),
-    ss: () => `${seconds}`.padStart(2, "0"),
-    SSS: () => `${milliseconds}`.padStart(3, "0"),
-    d: () => day,
-    dd: () => date.toLocaleDateString(options.locales, { weekday: "narrow" }),
-    ddd: () => date.toLocaleDateString(options.locales, { weekday: "short" }),
-    dddd: () => date.toLocaleDateString(options.locales, { weekday: "long" }),
-    A: () => meridiem(hours, minutes),
-    AA: () => meridiem(hours, minutes, false, true),
-    a: () => meridiem(hours, minutes, true),
-    aa: () => meridiem(hours, minutes, true, true)
-  };
-  return formatStr.replace(REGEX_FORMAT, (match, $1) => {
-    var _a2, _b;
-    return (_b = $1 != null ? $1 : (_a2 = matches[match]) == null ? void 0 : _a2.call(matches)) != null ? _b : match;
-  });
-}
-function normalizeDate(date) {
-  if (date === null)
-    return new Date(Number.NaN);
-  if (date === void 0)
-    return /* @__PURE__ */ new Date();
-  if (date instanceof Date)
-    return new Date(date);
-  if (typeof date === "string" && !/Z$/i.test(date)) {
-    const d = date.match(REGEX_PARSE);
-    if (d) {
-      const m = d[2] - 1 || 0;
-      const ms = (d[7] || "0").substring(0, 3);
-      return new Date(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms);
-    }
-  }
-  return new Date(date);
-}
-function useDateFormat(date, formatStr = "HH:mm:ss", options = {}) {
-  return computed(() => formatDate(normalizeDate(toValue(date)), toValue(formatStr), options));
-}
-
-function useIntervalFn(cb, interval = 1e3, options = {}) {
-  const {
-    immediate = true,
-    immediateCallback = false
-  } = options;
-  let timer = null;
-  const isActive = ref(false);
-  function clean() {
-    if (timer) {
-      clearInterval(timer);
-      timer = null;
-    }
-  }
-  function pause() {
-    isActive.value = false;
-    clean();
-  }
-  function resume() {
-    const intervalValue = toValue(interval);
-    if (intervalValue <= 0)
-      return;
-    isActive.value = true;
-    if (immediateCallback)
-      cb();
-    clean();
-    timer = setInterval(cb, intervalValue);
-  }
-  if (immediate && isClient)
-    resume();
-  if (isRef(interval) || typeof interval === "function") {
-    const stopWatch = watch(interval, () => {
-      if (isActive.value && isClient)
-        resume();
-    });
-    tryOnScopeDispose(stopWatch);
-  }
-  tryOnScopeDispose(pause);
-  return {
-    isActive,
-    pause,
-    resume
-  };
-}
-
-function useInterval(interval = 1e3, options = {}) {
-  const {
-    controls: exposeControls = false,
-    immediate = true,
-    callback
-  } = options;
-  const counter = ref(0);
-  const update = () => counter.value += 1;
-  const reset = () => {
-    counter.value = 0;
-  };
-  const controls = useIntervalFn(
-    callback ? () => {
-      update();
-      callback(counter.value);
-    } : update,
-    interval,
-    { immediate }
-  );
-  if (exposeControls) {
-    return {
-      counter,
-      reset,
-      ...controls
-    };
-  } else {
-    return counter;
-  }
-}
-
-function useLastChanged(source, options = {}) {
-  var _a;
-  const ms = ref((_a = options.initialValue) != null ? _a : null);
-  watch(
-    source,
-    () => ms.value = timestamp(),
-    options
-  );
-  return ms;
-}
-
-function useTimeoutFn(cb, interval, options = {}) {
-  const {
-    immediate = true
-  } = options;
-  const isPending = 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);
-    }, toValue(interval));
-  }
-  if (immediate) {
-    isPending.value = true;
-    if (isClient)
-      start();
-  }
-  tryOnScopeDispose(stop);
-  return {
-    isPending: readonly(isPending),
-    start,
-    stop
-  };
-}
-
-function useTimeout(interval = 1e3, options = {}) {
-  const {
-    controls: exposeControls = false,
-    callback
-  } = options;
-  const controls = useTimeoutFn(
-    callback != null ? callback : noop,
-    interval,
-    options
-  );
-  const ready = computed(() => !controls.isPending.value);
-  if (exposeControls) {
-    return {
-      ready,
-      ...controls
-    };
-  } else {
-    return ready;
-  }
-}
-
-function useToNumber(value, options = {}) {
-  const {
-    method = "parseFloat",
-    radix,
-    nanToZero
-  } = options;
-  return computed(() => {
-    let resolved = toValue(value);
-    if (typeof resolved === "string")
-      resolved = Number[method](resolved, radix);
-    if (nanToZero && Number.isNaN(resolved))
-      resolved = 0;
-    return resolved;
-  });
-}
-
-function useToString(value) {
-  return computed(() => `${toValue(value)}`);
-}
-
-function useToggle(initialValue = false, options = {}) {
-  const {
-    truthyValue = true,
-    falsyValue = false
-  } = options;
-  const valueIsRef = isRef(initialValue);
-  const _value = ref(initialValue);
-  function toggle(value) {
-    if (arguments.length) {
-      _value.value = value;
-      return _value.value;
-    } else {
-      const truthy = toValue(truthyValue);
-      _value.value = _value.value === truthy ? toValue(falsyValue) : truthy;
-      return _value.value;
-    }
-  }
-  if (valueIsRef)
-    return toggle;
-  else
-    return [_value, toggle];
-}
-
-function watchArray(source, cb, options) {
-  let oldList = (options == null ? void 0 : options.immediate) ? [] : [...source instanceof Function ? source() : Array.isArray(source) ? source : toValue(source)];
-  return watch(source, (newList, _, onCleanup) => {
-    const oldListRemains = Array.from({ length: oldList.length });
-    const added = [];
-    for (const obj of newList) {
-      let found = false;
-      for (let i = 0; i < oldList.length; i++) {
-        if (!oldListRemains[i] && obj === oldList[i]) {
-          oldListRemains[i] = true;
-          found = true;
-          break;
-        }
-      }
-      if (!found)
-        added.push(obj);
-    }
-    const removed = oldList.filter((_2, i) => !oldListRemains[i]);
-    cb(newList, oldList, added, removed, onCleanup);
-    oldList = [...newList];
-  }, options);
-}
-
-function watchAtMost(source, cb, options) {
-  const {
-    count,
-    ...watchOptions
-  } = options;
-  const current = ref(0);
-  const stop = watchWithFilter(
-    source,
-    (...args) => {
-      current.value += 1;
-      if (current.value >= toValue(count))
-        nextTick(() => stop());
-      cb(...args);
-    },
-    watchOptions
-  );
-  return { count: current, stop };
-}
-
-function watchDebounced(source, cb, options = {}) {
-  const {
-    debounce = 0,
-    maxWait = void 0,
-    ...watchOptions
-  } = options;
-  return watchWithFilter(
-    source,
-    cb,
-    {
-      ...watchOptions,
-      eventFilter: debounceFilter(debounce, { maxWait })
-    }
-  );
-}
-
-function watchDeep(source, cb, options) {
-  return watch(
-    source,
-    cb,
-    {
-      ...options,
-      deep: true
-    }
-  );
-}
-
-function watchIgnorable(source, cb, options = {}) {
-  const {
-    eventFilter = bypassFilter,
-    ...watchOptions
-  } = options;
-  const filteredCb = createFilterWrapper(
-    eventFilter,
-    cb
-  );
-  let ignoreUpdates;
-  let ignorePrevAsyncUpdates;
-  let stop;
-  if (watchOptions.flush === "sync") {
-    const ignore = ref(false);
-    ignorePrevAsyncUpdates = () => {
-    };
-    ignoreUpdates = (updater) => {
-      ignore.value = true;
-      updater();
-      ignore.value = false;
-    };
-    stop = watch(
-      source,
-      (...args) => {
-        if (!ignore.value)
-          filteredCb(...args);
-      },
-      watchOptions
-    );
-  } else {
-    const disposables = [];
-    const ignoreCounter = ref(0);
-    const syncCounter = ref(0);
-    ignorePrevAsyncUpdates = () => {
-      ignoreCounter.value = syncCounter.value;
-    };
-    disposables.push(
-      watch(
-        source,
-        () => {
-          syncCounter.value++;
-        },
-        { ...watchOptions, flush: "sync" }
-      )
-    );
-    ignoreUpdates = (updater) => {
-      const syncCounterPrev = syncCounter.value;
-      updater();
-      ignoreCounter.value += syncCounter.value - syncCounterPrev;
-    };
-    disposables.push(
-      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 watchImmediate(source, cb, options) {
-  return watch(
-    source,
-    cb,
-    {
-      ...options,
-      immediate: true
-    }
-  );
-}
-
-function watchOnce(source, cb, options) {
-  const stop = watch(source, (...args) => {
-    nextTick(() => stop());
-    return cb(...args);
-  }, options);
-  return stop;
-}
-
-function watchThrottled(source, cb, options = {}) {
-  const {
-    throttle = 0,
-    trailing = true,
-    leading = true,
-    ...watchOptions
-  } = options;
-  return watchWithFilter(
-    source,
-    cb,
-    {
-      ...watchOptions,
-      eventFilter: throttleFilter(throttle, trailing, leading)
-    }
-  );
-}
-
-function watchTriggerable(source, cb, options = {}) {
-  let cleanupFn;
-  function onEffect() {
-    if (!cleanupFn)
-      return;
-    const fn = cleanupFn;
-    cleanupFn = void 0;
-    fn();
-  }
-  function onCleanup(callback) {
-    cleanupFn = callback;
-  }
-  const _cb = (value, oldValue) => {
-    onEffect();
-    return cb(value, oldValue, onCleanup);
-  };
-  const res = watchIgnorable(source, _cb, options);
-  const { ignoreUpdates } = res;
-  const trigger = () => {
-    let res2;
-    ignoreUpdates(() => {
-      res2 = _cb(getWatchSources(source), getOldValue(source));
-    });
-    return res2;
-  };
-  return {
-    ...res,
-    trigger
-  };
-}
-function getWatchSources(sources) {
-  if (isReactive(sources))
-    return sources;
-  if (Array.isArray(sources))
-    return sources.map((item) => toValue(item));
-  return toValue(sources);
-}
-function getOldValue(source) {
-  return Array.isArray(source) ? source.map(() => void 0) : void 0;
-}
-
-function whenever(source, cb, options) {
-  const stop = watch(
-    source,
-    (v, ov, onInvalidate) => {
-      if (v) {
-        if (options == null ? void 0 : options.once)
-          nextTick(() => stop());
-        cb(v, ov, onInvalidate);
-      }
-    },
-    {
-      ...options,
-      once: false
-    }
-  );
-  return stop;
-}
-
-export { watchDebounced as $, useDebounceFn as A, tryOnUnmounted as B, useThrottleFn as C, watchPausable as D, watchWithFilter as E, tryOnBeforeUnmount as F, promiseTimeout as G, until as H, increaseWithUnit as I, containsProp as J, hasOwn as K, clamp as L, objectPick as M, isDef as N, isWorker as O, debounceFilter as P, bypassFilter as Q, camelize as R, assert as S, refAutoReset as T, computedEager as U, controlledRef as V, createGlobalState as W, createInjectionState as X, reactify as Y, createSharedComposable as Z, refDebounced as _, isClient as a, extendRef as a0, formatDate as a1, get as a2, getLifeCycleTarget as a3, hyphenate as a4, injectLocal as a5, invoke as a6, isDefined as a7, normalizeDate as a8, now as a9, useArraySome as aA, useArrayUnique as aB, useCounter as aC, useDateFormat as aD, useInterval as aE, useLastChanged as aF, useTimeout as aG, useToNumber as aH, useToString as aI, useToggle as aJ, watchArray as aK, watchAtMost as aL, watchDeep as aM, watchImmediate as aN, watchOnce as aO, watchTriggerable as aP, whenever as aQ, provideLocal as aa, rand as ab, reactifyObject as ac, reactiveComputed as ad, reactiveOmit as ae, reactivePick as af, refDefault as ag, refThrottled as ah, refWithControl as ai, resolveRef as aj, resolveUnref as ak, set as al, syncRefs as am, watchThrottled as an, toReactive as ao, tryOnBeforeMount as ap, useArrayDifference as aq, useArrayEvery as ar, useArrayFilter as as, useArrayFind as at, useArrayFindIndex as au, useArrayFindLast as av, useArrayIncludes as aw, useArrayJoin as ax, useArrayMap as ay, useArrayReduce as az, isObject as b, tryOnScopeDispose as c, directiveHooks as d, toRef as e, notNullish as f, identity as g, tryOnMounted as h, isIOS as i, objectEntries as j, createEventHook as k, computedWithControl as l, makeDestructurable as m, noop as n, objectOmit as o, toRefs as p, useIntervalFn as q, throttleFilter as r, timestamp as s, toValue as t, useTimeoutFn as u, createFilterWrapper as v, watchIgnorable as w, syncRef as x, createSingletonPromise as y, pausableFilter as z };