@reactive-vscode/vueuse 0.4.0 → 1.0.0-beta.1

package/dist/index.cjs

@@ -1,6 +1,21 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const reactivity = require("@reactive-vscode/reactivity");
+function getCurrentInstance() {
+  return null;
+}
+function computedEager(fn, options) {
+  var _options$flush;
+  const result = reactivity.shallowRef();
+  reactivity.watchEffect(() => {
+    result.value = fn();
+  }, {
+    ...options,
+    flush: (_options$flush = options === null || options === void 0 ? void 0 : options.flush) !== null && _options$flush !== void 0 ? _options$flush : "sync"
+  });
+  return reactivity.readonly(result);
+}
+const eagerComputed = computedEager;
 function computedWithControl(source, fn, options = {}) {
   let v = void 0;
   let track;
@@ -10,32 +25,36 @@ function computedWithControl(source, fn, options = {}) {
     dirty = true;
     trigger();
   };
-  reactivity.watch(source, update, { flush: "sync", ...options });
-  const get2 = typeof fn === "function" ? fn : fn.get;
-  const set2 = typeof fn === "function" ? void 0 : fn.set;
+  reactivity.watch(source, update, {
+    flush: "sync",
+    ...options
+  });
+  const get$1 = typeof fn === "function" ? fn : fn.get;
+  const set$1 = typeof fn === "function" ? void 0 : fn.set;
   const result = reactivity.customRef((_track, _trigger) => {
     track = _track;
     trigger = _trigger;
     return {
       get() {
         if (dirty) {
-          v = get2(v);
+          v = get$1(v);
           dirty = false;
         }
         track();
         return v;
       },
-      set(v2) {
-        set2 == null ? void 0 : set2(v2);
+      set(v$1) {
+        set$1 === null || set$1 === void 0 || set$1(v$1);
       }
     };
   });
   result.trigger = update;
   return result;
 }
-function tryOnScopeDispose(fn) {
+const controlledComputed = computedWithControl;
+function tryOnScopeDispose(fn, failSilently) {
   if (reactivity.getCurrentScope()) {
-    reactivity.onScopeDispose(fn);
+    reactivity.onScopeDispose(fn, failSilently);
     return true;
   }
   return false;
@@ -53,9 +72,7 @@ function createEventHook() {
     fns.add(fn);
     const offFn = () => off(fn);
     tryOnScopeDispose(offFn);
-    return {
-      off: offFn
-    };
+    return { off: offFn };
   };
   const trigger = (...args) => {
     return Promise.all(Array.from(fns).map((fn) => fn(...args)));
@@ -72,171 +89,57 @@ function createGlobalState(stateFactory) {
   let initialized = false;
   let state;
   const scope = reactivity.effectScope(true);
-  return (...args) => {
+  return ((...args) => {
     if (!initialized) {
       state = scope.run(() => stateFactory(...args));
       initialized = true;
     }
     return state;
-  };
+  });
 }
-// @__NO_SIDE_EFFECTS__
-function createRef(value, deep) {
-  if (deep === true) {
-    return reactivity.ref(value);
-  } else {
-    return reactivity.shallowRef(value);
-  }
+const localProvidedStateMap = /* @__PURE__ */ new WeakMap();
+const injectLocal = /* @__NO_SIDE_EFFECTS__ */ (...args) => {
+  var _getCurrentInstance;
+  const key = args[0];
+  const instance = (_getCurrentInstance = getCurrentInstance()) === null || _getCurrentInstance === void 0 ? void 0 : _getCurrentInstance.proxy;
+  const owner = instance !== null && instance !== void 0 ? instance : reactivity.getCurrentScope();
+  if (owner == null && !reactivity.hasInjectionContext()) throw new Error("injectLocal must be called in setup");
+  if (owner && localProvidedStateMap.has(owner) && key in localProvidedStateMap.get(owner)) return localProvidedStateMap.get(owner)[key];
+  return reactivity.inject(...args);
+};
+function provideLocal(key, value) {
+  var _getCurrentInstance;
+  const instance = (_getCurrentInstance = getCurrentInstance()) === null || _getCurrentInstance === void 0 ? void 0 : _getCurrentInstance.proxy;
+  const owner = instance !== null && instance !== void 0 ? instance : reactivity.getCurrentScope();
+  if (owner == null) throw new Error("provideLocal must be called in setup");
+  if (!localProvidedStateMap.has(owner)) localProvidedStateMap.set(owner, /* @__PURE__ */ Object.create(null));
+  const localProvidedState = localProvidedStateMap.get(owner);
+  localProvidedState[key] = value;
+  return reactivity.provide(key, value);
 }
 // @__NO_SIDE_EFFECTS__
-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 (!scope) {
-      scope = reactivity.effectScope(true);
-      state = scope.run(() => composable(...args));
-    }
-    tryOnScopeDispose(dispose);
+function createInjectionState(composable, options) {
+  const key = (options === null || options === void 0 ? void 0 : options.injectionKey) || Symbol(composable.name || "InjectionState");
+  const defaultValue = options === null || options === void 0 ? void 0 : options.defaultValue;
+  const useProvidingState = (...args) => {
+    const state = composable(...args);
+    provideLocal(key, state);
     return state;
   };
-}
-function extendRef(ref, extend, { enumerable = false, unwrap = true } = {}) {
-  for (const [key, value] of Object.entries(extend)) {
-    if (key === "value")
-      continue;
-    if (reactivity.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 reactivity.unref(obj);
-  return reactivity.unref(obj)[key];
-}
-function isDefined(v) {
-  return reactivity.unref(v) != null;
-}
-// @__NO_SIDE_EFFECTS__
-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);
-  }
+  const useInjectedState = () => /* @__PURE__ */ injectLocal(key, defaultValue);
+  return [useProvidingState, useInjectedState];
 }
 // @__NO_SIDE_EFFECTS__
-function reactify(fn, options) {
-  const unrefFn = (options == null ? void 0 : options.computedGetter) === false ? reactivity.unref : reactivity.toValue;
-  return function(...args) {
-    return reactivity.computed(() => fn.apply(this, args.map((i) => unrefFn(i))));
-  };
-}
-// @__NO_SIDE_EFFECTS__
-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" ? /* @__PURE__ */ reactify(value.bind(obj), options) : value
-      ];
-    })
-  );
-}
-function toReactive(objectRef) {
-  if (!reactivity.isRef(objectRef))
-    return reactivity.reactive(objectRef);
-  const proxy = new Proxy({}, {
-    get(_, p, receiver) {
-      return reactivity.unref(Reflect.get(objectRef.value, p, receiver));
-    },
-    set(_, p, value) {
-      if (reactivity.isRef(objectRef.value[p]) && !reactivity.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 reactivity.reactive(proxy);
-}
-function reactiveComputed(fn) {
-  return toReactive(reactivity.computed(fn));
-}
-function reactiveOmit(obj, ...keys) {
-  const flatKeys = keys.flat();
-  const predicate = flatKeys[0];
-  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(reactivity.toRefs(obj)).filter(([k, v]) => !predicate(reactivity.toValue(v), k))) : Object.fromEntries(Object.entries(reactivity.toRefs(obj)).filter((e) => !flatKeys.includes(e[0]))));
+function createRef(value, deep) {
+  if (deep === true) return reactivity.ref(value);
+  else return reactivity.shallowRef(value);
 }
 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);
+  if (!condition) console.warn(...infos);
 };
 const toString = Object.prototype.toString;
 const isObject = (val) => toString.call(val) === "[object Object]";
@@ -252,91 +155,61 @@ const rand = (min, max) => {
 };
 const hasOwn = (val, key) => Object.prototype.hasOwnProperty.call(val, key);
 function toRef(...args) {
-  if (args.length !== 1)
-    return reactivity.toRef(...args);
+  if (args.length !== 1) return reactivity.toRef(...args);
   const r = args[0];
-  return typeof r === "function" ? reactivity.readonly(reactivity.customRef(() => ({ get: r, set: noop }))) : reactivity.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(reactivity.toRefs(obj)).filter(([k, v]) => predicate(reactivity.toValue(v), k))) : Object.fromEntries(flatKeys.map((k) => [k, toRef(obj, k)])));
-}
-function refAutoReset(defaultValue, afterMs = 1e4) {
-  return reactivity.customRef((track, trigger) => {
-    let value = reactivity.toValue(defaultValue);
-    let timer;
-    const resetAfter = () => setTimeout(() => {
-      value = reactivity.toValue(defaultValue);
-      trigger();
-    }, reactivity.toValue(afterMs));
-    tryOnScopeDispose(() => {
-      clearTimeout(timer);
-    });
-    return {
-      get() {
-        track();
-        return value;
-      },
-      set(newValue) {
-        value = newValue;
-        trigger();
-        clearTimeout(timer);
-        timer = resetAfter();
-      }
-    };
-  });
+  return typeof r === "function" ? reactivity.readonly(reactivity.customRef(() => ({
+    get: r,
+    set: noop
+  }))) : reactivity.ref(r);
 }
 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);
+      Promise.resolve(filter(() => fn.apply(this, args), {
+        fn,
+        thisArg: this,
+        args
+      })).then(resolve).catch(reject);
     });
   }
   return wrapper;
 }
-const bypassFilter = (invoke2) => {
-  return invoke2();
+const bypassFilter = (invoke$1) => {
+  return invoke$1();
 };
 function debounceFilter(ms, options = {}) {
   let timer;
   let maxTimer;
   let lastRejector = noop;
-  const _clearTimeout = (timer2) => {
-    clearTimeout(timer2);
+  const _clearTimeout = (timer$1) => {
+    clearTimeout(timer$1);
     lastRejector();
     lastRejector = noop;
   };
   let lastInvoker;
-  const filter = (invoke2) => {
+  const filter = (invoke$1) => {
     const duration = reactivity.toValue(ms);
     const maxDuration = reactivity.toValue(options.maxWait);
-    if (timer)
-      _clearTimeout(timer);
+    if (timer) _clearTimeout(timer);
     if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
       if (maxTimer) {
         _clearTimeout(maxTimer);
         maxTimer = void 0;
       }
-      return Promise.resolve(invoke2());
+      return Promise.resolve(invoke$1());
     }
     return new Promise((resolve, reject) => {
       lastRejector = options.rejectOnCancel ? reject : resolve;
-      lastInvoker = invoke2;
-      if (maxDuration && !maxTimer) {
-        maxTimer = setTimeout(() => {
-          if (timer)
-            _clearTimeout(timer);
-          maxTimer = void 0;
-          resolve(lastInvoker());
-        }, maxDuration);
-      }
+      lastInvoker = invoke$1;
+      if (maxDuration && !maxTimer) maxTimer = setTimeout(() => {
+        if (timer) _clearTimeout(timer);
+        maxTimer = void 0;
+        resolve(lastInvoker());
+      }, maxDuration);
       timer = setTimeout(() => {
-        if (maxTimer)
-          _clearTimeout(maxTimer);
+        if (maxTimer) _clearTimeout(maxTimer);
         maxTimer = void 0;
-        resolve(invoke2());
+        resolve(invoke$1());
       }, duration);
     });
   };
@@ -352,10 +225,8 @@ function throttleFilter(...args) {
   let trailing;
   let leading;
   let rejectOnCancel;
-  if (!reactivity.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;
+  if (!reactivity.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);
@@ -367,39 +238,34 @@ function throttleFilter(...args) {
   const filter = (_invoke) => {
     const duration = reactivity.toValue(ms);
     const elapsed = Date.now() - lastExec;
-    const invoke2 = () => {
+    const invoke$1 = () => {
       return lastValue = _invoke();
     };
     clear();
     if (duration <= 0) {
       lastExec = Date.now();
-      return invoke2();
+      return invoke$1();
     }
-    if (elapsed > duration && (leading || !isLeading)) {
+    if (elapsed > duration) {
       lastExec = Date.now();
-      invoke2();
-    } else if (trailing) {
-      lastValue = new Promise((resolve, reject) => {
-        lastRejector = rejectOnCancel ? reject : resolve;
-        timer = setTimeout(() => {
-          lastExec = Date.now();
-          isLeading = true;
-          resolve(invoke2());
-          clear();
-        }, Math.max(0, duration - elapsed));
-      });
-    }
-    if (!leading && !timer)
-      timer = setTimeout(() => isLeading = true, duration);
+      if (leading || !isLeading) invoke$1();
+    } else if (trailing) lastValue = new Promise((resolve, reject) => {
+      lastRejector = rejectOnCancel ? reject : resolve;
+      timer = setTimeout(() => {
+        lastExec = Date.now();
+        isLeading = true;
+        resolve(invoke$1());
+        clear();
+      }, Math.max(0, duration - elapsed));
+    });
+    if (!leading && !timer) timer = setTimeout(() => isLeading = true, duration);
     isLeading = false;
     return lastValue;
   };
   return filter;
 }
 function pausableFilter(extendFilter = bypassFilter, options = {}) {
-  const {
-    initialState = "active"
-  } = options;
+  const { initialState = "active" } = options;
   const isActive = toRef(initialState === "active");
   function pause() {
     isActive.value = false;
@@ -408,17 +274,19 @@ function pausableFilter(extendFilter = bypassFilter, options = {}) {
     isActive.value = true;
   }
   const eventFilter = (...args) => {
-    if (isActive.value)
-      extendFilter(...args);
+    if (isActive.value) extendFilter(...args);
+  };
+  return {
+    isActive: reactivity.readonly(isActive),
+    pause,
+    resume,
+    eventFilter
   };
-  return { isActive: reactivity.readonly(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);
+    if (throwOnTimeout) setTimeout(() => reject(reason), ms);
+    else setTimeout(resolve, ms);
   });
 }
 function identity(arg) {
@@ -427,15 +295,13 @@ function identity(arg) {
 function createSingletonPromise(fn) {
   let _promise;
   function wrapper() {
-    if (!_promise)
-      _promise = fn();
+    if (!_promise) _promise = fn();
     return _promise;
   }
   wrapper.reset = async () => {
     const _prev = _promise;
     _promise = void 0;
-    if (_prev)
-      await _prev;
+    if (_prev) await _prev;
   };
   return wrapper;
 }
@@ -446,21 +312,21 @@ 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]) || "";
+  var _target$match;
+  if (typeof target === "number") return target + delta;
+  const value = ((_target$match = target.match(/^-?\d+\.?\d*/)) === null || _target$match === void 0 ? void 0 : _target$match[0]) || "";
   const unit = target.slice(value.length);
   const result = Number.parseFloat(value) + delta;
-  if (Number.isNaN(result))
-    return target;
+  if (Number.isNaN(result)) return target;
   return result + unit;
 }
+function pxValue(px) {
+  return px.endsWith("rem") ? Number.parseFloat(px) * 16 : Number.parseFloat(px);
+}
 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];
+      if (!omitUndefined || obj[k] !== void 0) n[k] = obj[k];
     }
     return n;
   }, {});
@@ -478,10 +344,9 @@ function toArray(value) {
 }
 function cacheStringFunction(fn) {
   const cache = /* @__PURE__ */ Object.create(null);
-  return (str) => {
-    const hit = cache[str];
-    return hit || (cache[str] = fn(str));
-  };
+  return ((str) => {
+    return cache[str] || (cache[str] = fn(str));
+  });
 }
 const hyphenateRE = /\B([A-Z])/g;
 const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
@@ -490,14 +355,169 @@ const camelize = cacheStringFunction((str) => {
   return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
 });
 function getLifeCycleTarget(target) {
-  return target || null;
+  return target || getCurrentInstance();
+}
+// @__NO_SIDE_EFFECTS__
+function createSharedComposable(composable) {
+  if (!isClient) return 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 (!scope) {
+      scope = reactivity.effectScope(true);
+      state = scope.run(() => composable(...args));
+    }
+    tryOnScopeDispose(dispose);
+    return state;
+  });
+}
+function extendRef(ref$1, extend, { enumerable = false, unwrap = true } = {}) {
+  for (const [key, value] of Object.entries(extend)) {
+    if (key === "value") continue;
+    if (reactivity.isRef(value) && unwrap) Object.defineProperty(ref$1, key, {
+      get() {
+        return value.value;
+      },
+      set(v) {
+        value.value = v;
+      },
+      enumerable
+    });
+    else Object.defineProperty(ref$1, key, {
+      value,
+      enumerable
+    });
+  }
+  return ref$1;
+}
+function get(obj, key) {
+  if (key == null) return reactivity.unref(obj);
+  return reactivity.unref(obj)[key];
+}
+function isDefined(v) {
+  return reactivity.unref(v) != null;
+}
+// @__NO_SIDE_EFFECTS__
+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);
+}
+// @__NO_SIDE_EFFECTS__
+function reactify(fn, options) {
+  const unrefFn = (options === null || options === void 0 ? void 0 : options.computedGetter) === false ? reactivity.unref : reactivity.toValue;
+  return function(...args) {
+    return reactivity.computed(() => fn.apply(this, args.map((i) => unrefFn(i))));
+  };
+}
+const createReactiveFn = reactify;
+// @__NO_SIDE_EFFECTS__
+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" ? /* @__PURE__ */ reactify(value.bind(obj), options) : value];
+  }));
+}
+function toReactive(objectRef) {
+  if (!reactivity.isRef(objectRef)) return reactivity.reactive(objectRef);
+  return reactivity.reactive(new Proxy({}, {
+    get(_, p, receiver) {
+      return reactivity.unref(Reflect.get(objectRef.value, p, receiver));
+    },
+    set(_, p, value) {
+      if (reactivity.isRef(objectRef.value[p]) && !reactivity.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
+      };
+    }
+  }));
+}
+function reactiveComputed(fn) {
+  return toReactive(reactivity.computed(fn));
 }
+function reactiveOmit(obj, ...keys) {
+  const flatKeys = keys.flat();
+  const predicate = flatKeys[0];
+  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(reactivity.toRefs(obj)).filter(([k, v]) => !predicate(reactivity.toValue(v), k))) : Object.fromEntries(Object.entries(reactivity.toRefs(obj)).filter((e) => !flatKeys.includes(e[0]))));
+}
+function reactivePick(obj, ...keys) {
+  const flatKeys = keys.flat();
+  const predicate = flatKeys[0];
+  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(reactivity.toRefs(obj)).filter(([k, v]) => predicate(reactivity.toValue(v), k))) : Object.fromEntries(flatKeys.map((k) => [k, toRef(obj, k)])));
+}
+function refAutoReset(defaultValue, afterMs = 1e4) {
+  return reactivity.customRef((track, trigger) => {
+    let value = reactivity.toValue(defaultValue);
+    let timer;
+    const resetAfter = () => setTimeout(() => {
+      value = reactivity.toValue(defaultValue);
+      trigger();
+    }, reactivity.toValue(afterMs));
+    tryOnScopeDispose(() => {
+      clearTimeout(timer);
+    });
+    return {
+      get() {
+        track();
+        return value;
+      },
+      set(newValue) {
+        value = newValue;
+        trigger();
+        clearTimeout(timer);
+        timer = resetAfter();
+      }
+    };
+  });
+}
+const autoResetRef = refAutoReset;
 // @__NO_SIDE_EFFECTS__
 function useDebounceFn(fn, ms = 200, options = {}) {
-  return createFilterWrapper(
-    debounceFilter(ms, options),
-    fn
-  );
+  return createFilterWrapper(debounceFilter(ms, options), fn);
 }
 function refDebounced(value, ms = 200, options = {}) {
   const debounced = reactivity.ref(reactivity.toValue(value));
@@ -507,28 +527,49 @@ function refDebounced(value, ms = 200, options = {}) {
   reactivity.watch(value, () => updater());
   return reactivity.shallowReadonly(debounced);
 }
+const debouncedRef = refDebounced;
+const useDebounce = refDebounced;
 // @__NO_SIDE_EFFECTS__
 function refDefault(source, defaultValue) {
   return reactivity.computed({
     get() {
-      var _a;
-      return (_a = source.value) != null ? _a : defaultValue;
+      var _source$value;
+      return (_source$value = source.value) !== null && _source$value !== void 0 ? _source$value : defaultValue;
     },
     set(value) {
       source.value = value;
     }
   });
 }
+function refManualReset(defaultValue) {
+  let value = reactivity.toValue(defaultValue);
+  let trigger;
+  const reset = () => {
+    value = reactivity.toValue(defaultValue);
+    trigger();
+  };
+  const refValue = reactivity.customRef((track, _trigger) => {
+    trigger = _trigger;
+    return {
+      get() {
+        track();
+        return value;
+      },
+      set(newValue) {
+        value = newValue;
+        trigger();
+      }
+    };
+  });
+  refValue.reset = reset;
+  return refValue;
+}
 // @__NO_SIDE_EFFECTS__
 function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
-  return createFilterWrapper(
-    throttleFilter(ms, trailing, leading, rejectOnCancel),
-    fn
-  );
+  return createFilterWrapper(throttleFilter(ms, trailing, leading, rejectOnCancel), fn);
 }
 function refThrottled(value, delay = 200, trailing = true, leading = true) {
-  if (delay <= 0)
-    return value;
+  if (delay <= 0) return value;
   const throttled = reactivity.ref(reactivity.toValue(value));
   const updater = /* @__PURE__ */ useThrottleFn(() => {
     throttled.value = value.value;
@@ -536,62 +577,56 @@ function refThrottled(value, delay = 200, trailing = true, leading = true) {
   reactivity.watch(value, () => updater());
   return throttled;
 }
+const throttledRef = refThrottled;
+const useThrottle = refThrottled;
 // @__NO_SIDE_EFFECTS__
 function refWithControl(initial, options = {}) {
   let source = initial;
   let track;
   let trigger;
-  const ref = reactivity.customRef((_track, _trigger) => {
+  const ref$1 = reactivity.customRef((_track, _trigger) => {
     track = _track;
     trigger = _trigger;
     return {
       get() {
-        return get2();
+        return get$1();
       },
       set(v) {
-        set2(v);
+        set$1(v);
       }
     };
   });
-  function get2(tracking = true) {
-    if (tracking)
-      track();
+  function get$1(tracking = true) {
+    if (tracking) track();
     return source;
   }
-  function set2(value, triggering = true) {
-    var _a, _b;
-    if (value === source)
-      return;
+  function set$1(value, triggering = true) {
+    var _options$onBeforeChan, _options$onChanged;
+    if (value === source) return;
     const old = source;
-    if (((_a = options.onBeforeChange) == null ? void 0 : _a.call(options, value, old)) === false)
-      return;
+    if (((_options$onBeforeChan = options.onBeforeChange) === null || _options$onBeforeChan === void 0 ? void 0 : _options$onBeforeChan.call(options, value, old)) === false) return;
     source = value;
-    (_b = options.onChanged) == null ? void 0 : _b.call(options, value, old);
-    if (triggering)
-      trigger();
-  }
-  const untrackedGet = () => get2(false);
-  const silentSet = (v) => set2(v, false);
-  const peek = () => get2(false);
-  const lay = (v) => set2(v, false);
-  return extendRef(
-    ref,
-    {
-      get: get2,
-      set: set2,
-      untrackedGet,
-      silentSet,
-      peek,
-      lay
-    },
-    { enumerable: true }
-  );
+    (_options$onChanged = options.onChanged) === null || _options$onChanged === void 0 || _options$onChanged.call(options, value, old);
+    if (triggering) trigger();
+  }
+  const untrackedGet = () => get$1(false);
+  const silentSet = (v) => set$1(v, false);
+  const peek = () => get$1(false);
+  const lay = (v) => set$1(v, false);
+  return extendRef(ref$1, {
+    get: get$1,
+    set: set$1,
+    untrackedGet,
+    silentSet,
+    peek,
+    lay
+  }, { enumerable: true });
 }
 const controlledRef = refWithControl;
 function set(...args) {
   if (args.length === 2) {
-    const [ref, value] = args;
-    ref.value = value;
+    const [ref$1, value] = args;
+    ref$1.value = value;
   }
   if (args.length === 3) {
     const [target, key, value] = args;
@@ -599,191 +634,142 @@ function set(...args) {
   }
 }
 function watchWithFilter(source, cb, options = {}) {
-  const {
-    eventFilter = bypassFilter,
-    ...watchOptions
-  } = options;
-  return reactivity.watch(
-    source,
-    createFilterWrapper(
-      eventFilter,
-      cb
-    ),
-    watchOptions
-  );
+  const { eventFilter = bypassFilter, ...watchOptions } = options;
+  return reactivity.watch(source, createFilterWrapper(eventFilter, cb), watchOptions);
 }
 function watchPausable(source, cb, options = {}) {
-  const {
-    eventFilter: filter,
-    initialState = "active",
-    ...watchOptions
-  } = options;
+  const { eventFilter: filter, initialState = "active", ...watchOptions } = options;
   const { eventFilter, pause, resume, isActive } = pausableFilter(filter, { initialState });
-  const stop = watchWithFilter(
-    source,
-    cb,
-    {
+  return {
+    stop: watchWithFilter(source, cb, {
       ...watchOptions,
       eventFilter
-    }
-  );
-  return { stop, pause, resume, isActive };
+    }),
+    pause,
+    resume,
+    isActive
+  };
 }
+const pausableWatch = watchPausable;
 function syncRef(left, right, ...[options]) {
-  const {
-    flush = "sync",
-    deep = false,
-    immediate = true,
-    direction = "both",
-    transform = {}
-  } = 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 }
-    ));
-  }
+  if (direction === "both" || direction === "ltr") watchers.push(pausableWatch(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(pausableWatch(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;
+  const { flush = "sync", deep = false, immediate = true } = options;
   const targetsArray = toArray(targets);
-  return reactivity.watch(
-    source,
-    (newValue) => targetsArray.forEach((target) => target.value = newValue),
-    { flush, deep, immediate }
-  );
+  return reactivity.watch(source, (newValue) => targetsArray.forEach((target) => target.value = newValue), {
+    flush,
+    deep,
+    immediate
+  });
 }
 function toRefs(objectRef, options = {}) {
-  if (!reactivity.isRef(objectRef))
-    return reactivity.toRefs(objectRef);
+  if (!reactivity.isRef(objectRef)) return reactivity.toRefs(objectRef);
   const result = Array.isArray(objectRef.value) ? Array.from({ length: objectRef.value.length }) : {};
-  for (const key in objectRef.value) {
-    result[key] = reactivity.customRef(() => ({
-      get() {
-        return objectRef.value[key];
-      },
-      set(v) {
-        var _a;
-        const replaceRef = (_a = reactivity.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;
-        }
+  for (const key in objectRef.value) result[key] = reactivity.customRef(() => ({
+    get() {
+      return objectRef.value[key];
+    },
+    set(v) {
+      var _toValue;
+      if ((_toValue = reactivity.toValue(options.replaceRef)) !== null && _toValue !== void 0 ? _toValue : true) 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;
 }
-const toValue = reactivity.toValue;
-const resolveUnref = reactivity.toValue;
+function tryOnBeforeMount(fn, sync = true, target) {
+  if (getLifeCycleTarget(target)) reactivity.onBeforeMount(fn, target);
+  else if (sync) fn();
+  else reactivity.nextTick(fn);
+}
+function tryOnBeforeUnmount(fn, target) {
+  if (getLifeCycleTarget(target)) reactivity.onBeforeUnmount(fn, target);
+}
 function tryOnMounted(fn, sync = true, target) {
-  const instance = getLifeCycleTarget(target);
-  if (instance)
-    ;
-  else if (sync)
-    fn();
-  else
-    reactivity.nextTick(fn);
+  if (getLifeCycleTarget(target)) ;
+  else if (sync) fn();
+  else reactivity.nextTick(fn);
+}
+function tryOnUnmounted(fn, target) {
+  if (getLifeCycleTarget(target)) reactivity.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 = reactivity.watch(
-        r,
-        (v) => {
-          if (condition(v) !== isNot) {
-            if (stop)
-              stop();
-            else
-              reactivity.nextTick(() => stop == null ? void 0 : stop());
-            resolve(v);
-          }
-        },
-        {
-          flush,
-          deep,
-          immediate: true
+    const promises = [new Promise((resolve) => {
+      stop = reactivity.watch(r, (v) => {
+        if (condition(v) !== isNot) {
+          if (stop) stop();
+          else reactivity.nextTick(() => stop === null || stop === void 0 ? void 0 : stop());
+          resolve(v);
         }
-      );
-    });
-    const promises = [watcher];
-    if (timeout != null) {
-      promises.push(
-        promiseTimeout(timeout, throwOnTimeout).then(() => reactivity.toValue(r)).finally(() => stop == null ? void 0 : stop())
-      );
-    }
+      }, {
+        flush,
+        deep,
+        immediate: true
+      });
+    })];
+    if (timeout != null) promises.push(promiseTimeout(timeout, throwOnTimeout).then(() => reactivity.toValue(r)).finally(() => stop === null || stop === void 0 ? void 0 : stop()));
     return Promise.race(promises);
   }
   function toBe(value, options) {
-    if (!reactivity.isRef(value))
-      return toMatch((v) => v === value, options);
-    const { flush = "sync", deep = false, timeout, throwOnTimeout } = options != null ? options : {};
+    if (!reactivity.isRef(value)) return toMatch((v) => v === value, options);
+    const { flush = "sync", deep = false, timeout, throwOnTimeout } = options !== null && options !== void 0 ? options : {};
     let stop = null;
-    const watcher = new Promise((resolve) => {
-      stop = reactivity.watch(
-        [r, value],
-        ([v1, v2]) => {
-          if (isNot !== (v1 === v2)) {
-            if (stop)
-              stop();
-            else
-              reactivity.nextTick(() => stop == null ? void 0 : stop());
-            resolve(v1);
-          }
-        },
-        {
-          flush,
-          deep,
-          immediate: true
+    const promises = [new Promise((resolve) => {
+      stop = reactivity.watch([r, value], ([v1, v2]) => {
+        if (isNot !== (v1 === v2)) {
+          if (stop) stop();
+          else reactivity.nextTick(() => stop === null || stop === void 0 ? void 0 : stop());
+          resolve(v1);
         }
-      );
-    });
-    const promises = [watcher];
-    if (timeout != null) {
-      promises.push(
-        promiseTimeout(timeout, throwOnTimeout).then(() => reactivity.toValue(r)).finally(() => {
-          stop == null ? void 0 : stop();
-          return reactivity.toValue(r);
-        })
-      );
-    }
+      }, {
+        flush,
+        deep,
+        immediate: true
+      });
+    })];
+    if (timeout != null) promises.push(promiseTimeout(timeout, throwOnTimeout).then(() => reactivity.toValue(r)).finally(() => {
+      stop === null || stop === void 0 || stop();
+      return reactivity.toValue(r);
+    }));
     return Promise.race(promises);
   }
   function toBeTruthy(options) {
@@ -814,33 +800,28 @@ function createUntil(r, isNot = false) {
       return count >= n;
     }, options);
   }
-  if (Array.isArray(reactivity.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;
-  }
+  if (Array.isArray(reactivity.toValue(r))) return {
+    toMatch,
+    toContains,
+    changed,
+    changedTimes,
+    get not() {
+      return createUntil(r, !isNot);
+    }
+  };
+  else return {
+    toMatch,
+    toBe,
+    toBeTruthy,
+    toBeNull,
+    toBeNaN,
+    toBeUndefined,
+    changed,
+    changedTimes,
+    get not() {
+      return createUntil(r, !isNot);
+    }
+  };
 }
 function until(r) {
   return createUntil(r);
@@ -850,13 +831,11 @@ function defaultComparator(value, othVal) {
 }
 // @__NO_SIDE_EFFECTS__
 function useArrayDifference(...args) {
-  var _a, _b;
+  var _args$, _args$2;
   const list = args[0];
   const values = args[1];
-  let compareFn = (_a = args[2]) != null ? _a : defaultComparator;
-  const {
-    symmetric = false
-  } = (_b = args[3]) != null ? _b : {};
+  let compareFn = (_args$ = args[2]) !== null && _args$ !== void 0 ? _args$ : defaultComparator;
+  const { symmetric = false } = (_args$2 = args[3]) !== null && _args$2 !== void 0 ? _args$2 : {};
   if (typeof compareFn === "string") {
     const key = compareFn;
     compareFn = (value, othVal) => value[key] === othVal[key];
@@ -865,9 +844,7 @@ function useArrayDifference(...args) {
   if (symmetric) {
     const diff2 = reactivity.computed(() => reactivity.toValue(values).filter((x) => reactivity.toValue(list).findIndex((y) => compareFn(x, y)) === -1));
     return reactivity.computed(() => symmetric ? [...reactivity.toValue(diff1), ...reactivity.toValue(diff2)] : reactivity.toValue(diff1));
-  } else {
-    return diff1;
-  }
+  } else return diff1;
 }
 // @__NO_SIDE_EFFECTS__
 function useArrayEvery(list, fn) {
@@ -879,9 +856,7 @@ function useArrayFilter(list, fn) {
 }
 // @__NO_SIDE_EFFECTS__
 function useArrayFind(list, fn) {
-  return reactivity.computed(() => reactivity.toValue(
-    reactivity.toValue(list).find((element, index, array) => fn(reactivity.toValue(element), index, array))
-  ));
+  return reactivity.computed(() => reactivity.toValue(reactivity.toValue(list).find((element, index, array) => fn(reactivity.toValue(element), index, array))));
 }
 // @__NO_SIDE_EFFECTS__
 function useArrayFindIndex(list, fn) {
@@ -889,43 +864,33 @@ function useArrayFindIndex(list, fn) {
 }
 function findLast(arr, cb) {
   let index = arr.length;
-  while (index-- > 0) {
-    if (cb(arr[index], index, arr))
-      return arr[index];
-  }
-  return void 0;
+  while (index-- > 0) if (cb(arr[index], index, arr)) return arr[index];
 }
 // @__NO_SIDE_EFFECTS__
 function useArrayFindLast(list, fn) {
-  return reactivity.computed(() => reactivity.toValue(
-    !Array.prototype.findLast ? findLast(reactivity.toValue(list), (element, index, array) => fn(reactivity.toValue(element), index, array)) : reactivity.toValue(list).findLast((element, index, array) => fn(reactivity.toValue(element), index, array))
-  ));
+  return reactivity.computed(() => reactivity.toValue(!Array.prototype.findLast ? findLast(reactivity.toValue(list), (element, index, array) => fn(reactivity.toValue(element), index, array)) : reactivity.toValue(list).findLast((element, index, array) => fn(reactivity.toValue(element), index, array))));
 }
 function isArrayIncludesOptions(obj) {
   return isObject(obj) && containsProp(obj, "formIndex", "comparator");
 }
 // @__NO_SIDE_EFFECTS__
 function useArrayIncludes(...args) {
-  var _a;
+  var _comparator;
   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;
+    var _comparator$fromIndex;
+    formIndex = (_comparator$fromIndex = comparator.fromIndex) !== null && _comparator$fromIndex !== void 0 ? _comparator$fromIndex : 0;
     comparator = comparator.comparator;
   }
   if (typeof comparator === "string") {
     const key = comparator;
-    comparator = (element, value2) => element[key] === reactivity.toValue(value2);
+    comparator = (element, value$1) => element[key] === reactivity.toValue(value$1);
   }
-  comparator = comparator != null ? comparator : (element, value2) => element === reactivity.toValue(value2);
-  return reactivity.computed(() => reactivity.toValue(list).slice(formIndex).some((element, index, array) => comparator(
-    reactivity.toValue(element),
-    reactivity.toValue(value),
-    index,
-    reactivity.toValue(array)
-  )));
+  comparator = (_comparator = comparator) !== null && _comparator !== void 0 ? _comparator : ((element, value$1) => element === reactivity.toValue(value$1));
+  return reactivity.computed(() => reactivity.toValue(list).slice(formIndex).some((element, index, array) => comparator(reactivity.toValue(element), reactivity.toValue(value), index, reactivity.toValue(array))));
 }
 // @__NO_SIDE_EFFECTS__
 function useArrayJoin(list, separator) {
@@ -952,8 +917,7 @@ function uniq(array) {
 }
 function uniqueElementsBy(array, fn) {
   return array.reduce((acc, v) => {
-    if (!acc.some((x) => fn(v, x, array)))
-      acc.push(v);
+    if (!acc.some((x) => fn(v, x, array))) acc.push(v);
     return acc;
   }, []);
 }
@@ -967,35 +931,43 @@ function useArrayUnique(list, compareFn) {
 function useCounter(initialValue = 0, options = {}) {
   let _initialValue = reactivity.unref(initialValue);
   const count = reactivity.shallowRef(initialValue);
-  const {
-    max = Number.POSITIVE_INFINITY,
-    min = Number.NEGATIVE_INFINITY
-  } = options;
+  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 get2 = () => count.value;
-  const set2 = (val) => count.value = Math.max(min, Math.min(max, val));
+  const get$1 = () => count.value;
+  const set$1 = (val) => count.value = Math.max(min, Math.min(max, val));
   const reset = (val = _initialValue) => {
     _initialValue = val;
-    return set2(val);
+    return set$1(val);
+  };
+  return {
+    count: reactivity.shallowReadonly(count),
+    inc,
+    dec,
+    get: get$1,
+    set: set$1,
+    reset
   };
-  return { count: reactivity.shallowReadonly(count), inc, dec, get: get2, set: set2, 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}|z{1,4}|SSS/g;
 function defaultMeridiem(hours, minutes, isLowercase, hasPeriod) {
   let m = hours < 12 ? "AM" : "PM";
-  if (hasPeriod)
-    m = m.split("").reduce((acc, curr) => acc += `${curr}.`, "");
+  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 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;
+  var _options$customMeridi;
   const years = date.getFullYear();
   const month = date.getMonth();
   const days = date.getDate();
@@ -1004,10 +976,10 @@ function formatDate(date, formatStr, options = {}) {
   const seconds = date.getSeconds();
   const milliseconds = date.getMilliseconds();
   const day = date.getDay();
-  const meridiem = (_a = options.customMeridiem) != null ? _a : defaultMeridiem;
+  const meridiem = (_options$customMeridi = options.customMeridiem) !== null && _options$customMeridi !== void 0 ? _options$customMeridi : defaultMeridiem;
   const stripTimeZone = (dateString) => {
-    var _a2;
-    return (_a2 = dateString.split(" ")[1]) != null ? _a2 : "";
+    var _dateString$split$;
+    return (_dateString$split$ = dateString.split(" ")[1]) !== null && _dateString$split$ !== void 0 ? _dateString$split$ : "";
   };
   const matches = {
     Yo: () => formatOrdinal(years),
@@ -1048,17 +1020,14 @@ function formatDate(date, formatStr, options = {}) {
     zzzz: () => stripTimeZone(date.toLocaleDateString(reactivity.toValue(options.locales), { timeZoneName: "longOffset" }))
   };
   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;
+    var _ref, _matches$match;
+    return (_ref = $1 !== null && $1 !== void 0 ? $1 : (_matches$match = matches[match]) === null || _matches$match === void 0 ? void 0 : _matches$match.call(matches)) !== null && _ref !== void 0 ? _ref : 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 (date === null) return /* @__PURE__ */ new Date(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) {
@@ -1074,10 +1043,7 @@ function useDateFormat(date, formatStr = "HH:mm:ss", options = {}) {
   return reactivity.computed(() => formatDate(normalizeDate(reactivity.toValue(date)), reactivity.toValue(formatStr), options));
 }
 function useIntervalFn(cb, interval = 1e3, options = {}) {
-  const {
-    immediate = true,
-    immediateCallback = false
-  } = options;
+  const { immediate = true, immediateCallback = false } = options;
   let timer = null;
   const isActive = reactivity.shallowRef(false);
   function clean() {
@@ -1092,24 +1058,16 @@ function useIntervalFn(cb, interval = 1e3, options = {}) {
   }
   function resume() {
     const intervalValue = reactivity.toValue(interval);
-    if (intervalValue <= 0)
-      return;
+    if (intervalValue <= 0) return;
     isActive.value = true;
-    if (immediateCallback)
-      cb();
+    if (immediateCallback) cb();
     clean();
-    if (isActive.value)
-      timer = setInterval(cb, intervalValue);
-  }
-  if (immediate && isClient)
-    resume();
-  if (reactivity.isRef(interval) || typeof interval === "function") {
-    const stopWatch = reactivity.watch(interval, () => {
-      if (isActive.value && isClient)
-        resume();
-    });
-    tryOnScopeDispose(stopWatch);
+    if (isActive.value) timer = setInterval(cb, intervalValue);
   }
+  if (immediate && isClient) resume();
+  if (reactivity.isRef(interval) || typeof interval === "function") tryOnScopeDispose(reactivity.watch(interval, () => {
+    if (isActive.value && isClient) resume();
+  }));
   tryOnScopeDispose(pause);
   return {
     isActive: reactivity.shallowReadonly(isActive),
@@ -1118,49 +1076,31 @@ function useIntervalFn(cb, interval = 1e3, options = {}) {
   };
 }
 function useInterval(interval = 1e3, options = {}) {
-  const {
-    controls: exposeControls = false,
-    immediate = true,
-    callback
-  } = options;
+  const { controls: exposeControls = false, immediate = true, callback } = options;
   const counter = reactivity.shallowRef(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: reactivity.shallowReadonly(counter),
-      reset,
-      ...controls
-    };
-  } else {
-    return reactivity.shallowReadonly(counter);
-  }
+  const controls = useIntervalFn(callback ? () => {
+    update();
+    callback(counter.value);
+  } : update, interval, { immediate });
+  if (exposeControls) return {
+    counter: reactivity.shallowReadonly(counter),
+    reset,
+    ...controls
+  };
+  else return reactivity.shallowReadonly(counter);
 }
 function useLastChanged(source, options = {}) {
-  var _a;
-  const ms = reactivity.shallowRef((_a = options.initialValue) != null ? _a : null);
-  reactivity.watch(
-    source,
-    () => ms.value = timestamp(),
-    options
-  );
+  var _options$initialValue;
+  const ms = reactivity.shallowRef((_options$initialValue = options.initialValue) !== null && _options$initialValue !== void 0 ? _options$initialValue : null);
+  reactivity.watch(source, () => ms.value = timestamp(), options);
   return reactivity.shallowReadonly(ms);
 }
 function useTimeoutFn(cb, interval, options = {}) {
-  const {
-    immediate = true,
-    immediateCallback = false
-  } = options;
+  const { immediate = true, immediateCallback = false } = options;
   const isPending = reactivity.shallowRef(false);
   let timer;
   function clear() {
@@ -1174,8 +1114,7 @@ function useTimeoutFn(cb, interval, options = {}) {
     clear();
   }
   function start(...args) {
-    if (immediateCallback)
-      cb();
+    if (immediateCallback) cb();
     clear();
     isPending.value = true;
     timer = setTimeout(() => {
@@ -1186,8 +1125,7 @@ function useTimeoutFn(cb, interval, options = {}) {
   }
   if (immediate) {
     isPending.value = true;
-    if (isClient)
-      start();
+    if (isClient) start();
   }
   tryOnScopeDispose(stop);
   return {
@@ -1197,40 +1135,23 @@ function useTimeoutFn(cb, interval, options = {}) {
   };
 }
 function useTimeout(interval = 1e3, options = {}) {
-  const {
-    controls: exposeControls = false,
-    callback
-  } = options;
-  const controls = useTimeoutFn(
-    callback != null ? callback : noop,
-    interval,
-    options
-  );
+  const { controls: exposeControls = false, callback } = options;
+  const controls = useTimeoutFn(callback !== null && callback !== void 0 ? callback : noop, interval, options);
   const ready = reactivity.computed(() => !controls.isPending.value);
-  if (exposeControls) {
-    return {
-      ready,
-      ...controls
-    };
-  } else {
-    return ready;
-  }
+  if (exposeControls) return {
+    ready,
+    ...controls
+  };
+  else return ready;
 }
 // @__NO_SIDE_EFFECTS__
 function useToNumber(value, options = {}) {
-  const {
-    method = "parseFloat",
-    radix,
-    nanToZero
-  } = options;
+  const { method = "parseFloat", radix, nanToZero } = options;
   return reactivity.computed(() => {
     let resolved = reactivity.toValue(value);
-    if (typeof method === "function")
-      resolved = method(resolved);
-    else if (typeof resolved === "string")
-      resolved = Number[method](resolved, radix);
-    if (nanToZero && Number.isNaN(resolved))
-      resolved = 0;
+    if (typeof method === "function") resolved = method(resolved);
+    else if (typeof resolved === "string") resolved = Number[method](resolved, radix);
+    if (nanToZero && Number.isNaN(resolved)) resolved = 0;
     return resolved;
   });
 }
@@ -1240,10 +1161,7 @@ function useToString(value) {
 }
 // @__NO_SIDE_EFFECTS__
 function useToggle(initialValue = false, options = {}) {
-  const {
-    truthyValue = true,
-    falsyValue = false
-  } = options;
+  const { truthyValue = true, falsyValue = false } = options;
   const valueIsRef = reactivity.isRef(initialValue);
   const _value = reactivity.shallowRef(initialValue);
   function toggle(value) {
@@ -1256,85 +1174,60 @@ function useToggle(initialValue = false, options = {}) {
       return _value.value;
     }
   }
-  if (valueIsRef)
-    return toggle;
-  else
-    return [_value, toggle];
+  if (valueIsRef) return toggle;
+  else return [_value, toggle];
 }
 function watchArray(source, cb, options) {
-  let oldList = (options == null ? void 0 : options.immediate) ? [] : [...typeof source === "function" ? source() : Array.isArray(source) ? source : reactivity.toValue(source)];
+  let oldList = (options === null || options === void 0 ? void 0 : options.immediate) ? [] : [...typeof source === "function" ? source() : Array.isArray(source) ? source : reactivity.toValue(source)];
   return reactivity.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;
-        }
+      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);
+      if (!found) added.push(obj);
     }
-    const removed = oldList.filter((_2, i) => !oldListRemains[i]);
+    const removed = oldList.filter((_$1, i) => !oldListRemains[i]);
     cb(newList, oldList, added, removed, onCleanup);
     oldList = [...newList];
   }, options);
 }
 function watchAtMost(source, cb, options) {
-  const {
-    count,
-    ...watchOptions
-  } = options;
+  const { count, ...watchOptions } = options;
   const current = reactivity.shallowRef(0);
-  const stop = watchWithFilter(
-    source,
-    (...args) => {
-      current.value += 1;
-      if (current.value >= reactivity.toValue(count))
-        reactivity.nextTick(() => stop());
-      cb(...args);
-    },
-    watchOptions
-  );
-  return { count: current, stop };
+  const { stop, resume, pause } = watchWithFilter(source, (...args) => {
+    current.value += 1;
+    if (current.value >= reactivity.toValue(count)) reactivity.nextTick(() => stop());
+    cb(...args);
+  }, watchOptions);
+  return {
+    count: current,
+    stop,
+    resume,
+    pause
+  };
 }
 function watchDebounced(source, cb, options = {}) {
-  const {
-    debounce = 0,
-    maxWait = void 0,
-    ...watchOptions
-  } = options;
-  return watchWithFilter(
-    source,
-    cb,
-    {
-      ...watchOptions,
-      eventFilter: debounceFilter(debounce, { maxWait })
-    }
-  );
+  const { debounce = 0, maxWait = void 0, ...watchOptions } = options;
+  return watchWithFilter(source, cb, {
+    ...watchOptions,
+    eventFilter: debounceFilter(debounce, { maxWait })
+  });
 }
+const debouncedWatch = watchDebounced;
 function watchDeep(source, cb, options) {
-  return reactivity.watch(
-    source,
-    cb,
-    {
-      ...options,
-      deep: true
-    }
-  );
+  return reactivity.watch(source, cb, {
+    ...options,
+    deep: true
+  });
 }
 function watchIgnorable(source, cb, options = {}) {
-  const {
-    eventFilter = bypassFilter,
-    ...watchOptions
-  } = options;
-  const filteredCb = createFilterWrapper(
-    eventFilter,
-    cb
-  );
+  const { eventFilter = bypassFilter, ...watchOptions } = options;
+  const filteredCb = createFilterWrapper(eventFilter, cb);
   let ignoreUpdates;
   let ignorePrevAsyncUpdates;
   let stop;
@@ -1347,14 +1240,9 @@ function watchIgnorable(source, cb, options = {}) {
       updater();
       ignore = false;
     };
-    stop = reactivity.watch(
-      source,
-      (...args) => {
-        if (!ignore)
-          filteredCb(...args);
-      },
-      watchOptions
-    );
+    stop = reactivity.watch(source, (...args) => {
+      if (!ignore) filteredCb(...args);
+    }, watchOptions);
   } else {
     const disposables = [];
     let ignoreCounter = 0;
@@ -1362,81 +1250,59 @@ function watchIgnorable(source, cb, options = {}) {
     ignorePrevAsyncUpdates = () => {
       ignoreCounter = syncCounter;
     };
-    disposables.push(
-      reactivity.watch(
-        source,
-        () => {
-          syncCounter++;
-        },
-        { ...watchOptions, flush: "sync" }
-      )
-    );
+    disposables.push(reactivity.watch(source, () => {
+      syncCounter++;
+    }, {
+      ...watchOptions,
+      flush: "sync"
+    }));
     ignoreUpdates = (updater) => {
       const syncCounterPrev = syncCounter;
       updater();
       ignoreCounter += syncCounter - syncCounterPrev;
     };
-    disposables.push(
-      reactivity.watch(
-        source,
-        (...args) => {
-          const ignore = ignoreCounter > 0 && ignoreCounter === syncCounter;
-          ignoreCounter = 0;
-          syncCounter = 0;
-          if (ignore)
-            return;
-          filteredCb(...args);
-        },
-        watchOptions
-      )
-    );
+    disposables.push(reactivity.watch(source, (...args) => {
+      const ignore = ignoreCounter > 0 && ignoreCounter === syncCounter;
+      ignoreCounter = 0;
+      syncCounter = 0;
+      if (ignore) return;
+      filteredCb(...args);
+    }, watchOptions));
     stop = () => {
       disposables.forEach((fn) => fn());
     };
   }
-  return { stop, ignoreUpdates, ignorePrevAsyncUpdates };
+  return {
+    stop,
+    ignoreUpdates,
+    ignorePrevAsyncUpdates
+  };
 }
+const ignorableWatch = watchIgnorable;
 function watchImmediate(source, cb, options) {
-  return reactivity.watch(
-    source,
-    cb,
-    {
-      ...options,
-      immediate: true
-    }
-  );
+  return reactivity.watch(source, cb, {
+    ...options,
+    immediate: true
+  });
 }
 function watchOnce(source, cb, options) {
-  return reactivity.watch(
-    source,
-    cb,
-    {
-      ...options,
-      once: true
-    }
-  );
+  return reactivity.watch(source, cb, {
+    ...options,
+    once: true
+  });
 }
 function watchThrottled(source, cb, options = {}) {
-  const {
-    throttle = 0,
-    trailing = true,
-    leading = true,
-    ...watchOptions
-  } = options;
-  return watchWithFilter(
-    source,
-    cb,
-    {
-      ...watchOptions,
-      eventFilter: throttleFilter(throttle, trailing, leading)
-    }
-  );
+  const { throttle = 0, trailing = true, leading = true, ...watchOptions } = options;
+  return watchWithFilter(source, cb, {
+    ...watchOptions,
+    eventFilter: throttleFilter(throttle, trailing, leading)
+  });
 }
+const throttledWatch = watchThrottled;
 function watchTriggerable(source, cb, options = {}) {
   let cleanupFn;
   function onEffect() {
-    if (!cleanupFn)
-      return;
+    if (!cleanupFn) return;
     const fn = cleanupFn;
     cleanupFn = void 0;
     fn();
@@ -1451,11 +1317,11 @@ function watchTriggerable(source, cb, options = {}) {
   const res = watchIgnorable(source, _cb, options);
   const { ignoreUpdates } = res;
   const trigger = () => {
-    let res2;
+    let res$1;
     ignoreUpdates(() => {
-      res2 = _cb(getWatchSources(source), getOldValue(source));
+      res$1 = _cb(getWatchSources(source), getOldValue(source));
     });
-    return res2;
+    return res$1;
   };
   return {
     ...res,
@@ -1463,91 +1329,64 @@ function watchTriggerable(source, cb, options = {}) {
   };
 }
 function getWatchSources(sources) {
-  if (reactivity.isReactive(sources))
-    return sources;
-  if (Array.isArray(sources))
-    return sources.map((item) => reactivity.toValue(item));
+  if (reactivity.isReactive(sources)) return sources;
+  if (Array.isArray(sources)) return sources.map((item) => reactivity.toValue(item));
   return reactivity.toValue(sources);
 }
 function getOldValue(source) {
   return Array.isArray(source) ? source.map(() => void 0) : void 0;
 }
 function whenever(source, cb, options) {
-  const stop = reactivity.watch(
-    source,
-    (v, ov, onInvalidate) => {
-      if (v) {
-        if (options == null ? void 0 : options.once)
-          reactivity.nextTick(() => stop());
-        cb(v, ov, onInvalidate);
-      }
-    },
-    {
-      ...options,
-      once: false
+  const stop = reactivity.watch(source, (v, ov, onInvalidate) => {
+    if (v) {
+      if (options === null || options === void 0 ? void 0 : options.once) reactivity.nextTick(() => stop());
+      cb(v, ov, onInvalidate);
     }
-  );
+  }, {
+    ...options,
+    once: false
+  });
   return stop;
 }
 function computedAsync(evaluationCallback, initialState, optionsOrRef) {
-  var _a;
+  var _globalThis$reportErr;
   let options;
-  if (reactivity.isRef(optionsOrRef)) {
-    options = {
-      evaluating: optionsOrRef
-    };
-  } else {
-    options = optionsOrRef || {};
-  }
-  const {
-    lazy = false,
-    flush = "pre",
-    evaluating = void 0,
-    shallow = true,
-    onError = (_a = globalThis.reportError) != null ? _a : noop
-  } = options;
+  if (reactivity.isRef(optionsOrRef)) options = { evaluating: optionsOrRef };
+  else options = optionsOrRef || {};
+  const { lazy = false, flush = "sync", evaluating = void 0, shallow = true, onError = (_globalThis$reportErr = globalThis.reportError) !== null && _globalThis$reportErr !== void 0 ? _globalThis$reportErr : noop } = options;
   const started = reactivity.shallowRef(!lazy);
   const current = shallow ? reactivity.shallowRef(initialState) : reactivity.ref(initialState);
   let counter = 0;
   reactivity.watchEffect(async (onInvalidate) => {
-    if (!started.value)
-      return;
+    if (!started.value) return;
     counter++;
     const counterAtBeginning = counter;
     let hasFinished = false;
-    if (evaluating) {
-      Promise.resolve().then(() => {
-        evaluating.value = true;
-      });
-    }
+    if (evaluating) Promise.resolve().then(() => {
+      evaluating.value = true;
+    });
     try {
       const result = await evaluationCallback((cancelCallback) => {
         onInvalidate(() => {
-          if (evaluating)
-            evaluating.value = false;
-          if (!hasFinished)
-            cancelCallback();
+          if (evaluating) evaluating.value = false;
+          if (!hasFinished) cancelCallback();
         });
       });
-      if (counterAtBeginning === counter)
-        current.value = result;
+      if (counterAtBeginning === counter) current.value = result;
     } catch (e) {
       onError(e);
     } finally {
-      if (evaluating && counterAtBeginning === counter)
-        evaluating.value = false;
+      if (evaluating && counterAtBeginning === counter) evaluating.value = false;
       hasFinished = true;
     }
   }, { flush });
-  if (lazy) {
-    return reactivity.computed(() => {
-      started.value = true;
-      return current.value;
-    });
-  } else {
-    return current;
-  }
+  if (lazy) return reactivity.computed(() => {
+    started.value = true;
+    return current.value;
+  });
+  else return current;
 }
+const asyncComputed = computedAsync;
 // @__NO_SIDE_EFFECTS__
 function createUnrefFn(fn) {
   return function(...args) {
@@ -1556,16 +1395,11 @@ function createUnrefFn(fn) {
 }
 const defaultWindow = isClient ? window : void 0;
 function unrefElement(elRef) {
-  var _a;
+  var _$el;
   const plain = reactivity.toValue(elRef);
-  return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
+  return (_$el = plain === null || plain === void 0 ? void 0 : plain.$el) !== null && _$el !== void 0 ? _$el : plain;
 }
 function useEventListener(...args) {
-  const cleanups = [];
-  const cleanup = () => {
-    cleanups.forEach((fn) => fn());
-    cleanups.length = 0;
-  };
   const register = (el, event, listener, options) => {
     el.addEventListener(event, listener, options);
     return () => el.removeEventListener(event, listener, options);
@@ -1574,38 +1408,22 @@ function useEventListener(...args) {
     const test = toArray(reactivity.toValue(args[0])).filter((e) => e != null);
     return test.every((e) => typeof e !== "string") ? test : void 0;
   });
-  const stopWatch = watchImmediate(
-    () => {
-      var _a, _b;
-      return [
-        (_b = (_a = firstParamTargets.value) == null ? void 0 : _a.map((e) => unrefElement(e))) != null ? _b : [defaultWindow].filter((e) => e != null),
-        toArray(reactivity.toValue(firstParamTargets.value ? args[1] : args[0])),
-        toArray(reactivity.unref(firstParamTargets.value ? args[2] : args[1])),
-        // @ts-expect-error - TypeScript gets the correct types, but somehow still complains
-        reactivity.toValue(firstParamTargets.value ? args[3] : args[2])
-      ];
-    },
-    ([raw_targets, raw_events, raw_listeners, raw_options]) => {
-      cleanup();
-      if (!(raw_targets == null ? void 0 : raw_targets.length) || !(raw_events == null ? void 0 : raw_events.length) || !(raw_listeners == null ? void 0 : raw_listeners.length))
-        return;
-      const optionsClone = isObject(raw_options) ? { ...raw_options } : raw_options;
-      cleanups.push(
-        ...raw_targets.flatMap(
-          (el) => raw_events.flatMap(
-            (event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone))
-          )
-        )
-      );
-    },
-    { flush: "post" }
-  );
-  const stop = () => {
-    stopWatch();
-    cleanup();
-  };
-  tryOnScopeDispose(cleanup);
-  return stop;
+  return watchImmediate(() => {
+    var _firstParamTargets$va, _firstParamTargets$va2;
+    return [
+      (_firstParamTargets$va = (_firstParamTargets$va2 = firstParamTargets.value) === null || _firstParamTargets$va2 === void 0 ? void 0 : _firstParamTargets$va2.map((e) => unrefElement(e))) !== null && _firstParamTargets$va !== void 0 ? _firstParamTargets$va : [defaultWindow].filter((e) => e != null),
+      toArray(reactivity.toValue(firstParamTargets.value ? args[1] : args[0])),
+      toArray(reactivity.unref(firstParamTargets.value ? args[2] : args[1])),
+      reactivity.toValue(firstParamTargets.value ? args[3] : args[2])
+    ];
+  }, ([raw_targets, raw_events, raw_listeners, raw_options], _, onCleanup) => {
+    if (!(raw_targets === null || raw_targets === void 0 ? void 0 : raw_targets.length) || !(raw_events === null || raw_events === void 0 ? void 0 : raw_events.length) || !(raw_listeners === null || raw_listeners === void 0 ? void 0 : raw_listeners.length)) return;
+    const optionsClone = isObject(raw_options) ? { ...raw_options } : raw_options;
+    const cleanups = raw_targets.flatMap((el) => raw_events.flatMap((event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone))));
+    onCleanup(() => {
+      cleanups.forEach((fn) => fn());
+    });
+  }, { flush: "post" });
 }
 // @__NO_SIDE_EFFECTS__
 function useMounted() {
@@ -1621,53 +1439,48 @@ function useSupported(callback) {
   });
 }
 function useRafFn(fn, options = {}) {
-  const {
-    immediate = true,
-    fpsLimit = void 0,
-    window: window2 = defaultWindow,
-    once = false
-  } = options;
+  const { immediate = true, fpsLimit = void 0, window: window$1 = defaultWindow, once = false } = options;
   const isActive = reactivity.shallowRef(false);
   const intervalLimit = reactivity.computed(() => {
     return fpsLimit ? 1e3 / reactivity.toValue(fpsLimit) : null;
   });
   let previousFrameTimestamp = 0;
   let rafId = null;
-  function loop(timestamp2) {
-    if (!isActive.value || !window2)
-      return;
-    if (!previousFrameTimestamp)
-      previousFrameTimestamp = timestamp2;
-    const delta = timestamp2 - previousFrameTimestamp;
+  function loop(timestamp$1) {
+    if (!isActive.value || !window$1) return;
+    if (!previousFrameTimestamp) previousFrameTimestamp = timestamp$1;
+    const delta = timestamp$1 - previousFrameTimestamp;
     if (intervalLimit.value && delta < intervalLimit.value) {
-      rafId = window2.requestAnimationFrame(loop);
+      rafId = window$1.requestAnimationFrame(loop);
       return;
     }
-    previousFrameTimestamp = timestamp2;
-    fn({ delta, timestamp: timestamp2 });
+    previousFrameTimestamp = timestamp$1;
+    fn({
+      delta,
+      timestamp: timestamp$1
+    });
     if (once) {
       isActive.value = false;
       rafId = null;
       return;
     }
-    rafId = window2.requestAnimationFrame(loop);
+    rafId = window$1.requestAnimationFrame(loop);
   }
   function resume() {
-    if (!isActive.value && window2) {
+    if (!isActive.value && window$1) {
       isActive.value = true;
       previousFrameTimestamp = 0;
-      rafId = window2.requestAnimationFrame(loop);
+      rafId = window$1.requestAnimationFrame(loop);
     }
   }
   function pause() {
     isActive.value = false;
-    if (rafId != null && window2) {
-      window2.cancelAnimationFrame(rafId);
+    if (rafId != null && window$1) {
+      window$1.cancelAnimationFrame(rafId);
       rafId = null;
     }
   }
-  if (immediate)
-    resume();
+  if (immediate) resume();
   tryOnScopeDispose(pause);
   return {
     isActive: reactivity.readonly(isActive),
@@ -1676,20 +1489,17 @@ function useRafFn(fn, options = {}) {
   };
 }
 function useAsyncQueue(tasks, options) {
-  const {
-    interrupt = true,
-    onError = noop,
-    onFinished = noop,
-    signal
-  } = options || {};
+  const { interrupt = true, onError = noop, onFinished = noop, signal } = options || {};
   const promiseState = {
     aborted: "aborted",
     fulfilled: "fulfilled",
     pending: "pending",
     rejected: "rejected"
   };
-  const initialResult = Array.from(Array.from({ length: tasks.length }), () => ({ state: promiseState.pending, data: null }));
-  const result = reactivity.reactive(initialResult);
+  const result = reactivity.reactive(Array.from(Array.from({ length: tasks.length }), () => ({
+    state: promiseState.pending,
+    data: null
+  })));
   const activeIndex = reactivity.shallowRef(-1);
   if (!tasks || tasks.length === 0) {
     onFinished();
@@ -1705,31 +1515,30 @@ function useAsyncQueue(tasks, options) {
   }
   tasks.reduce((prev, curr) => {
     return prev.then((prevRes) => {
-      var _a;
-      if (signal == null ? void 0 : signal.aborted) {
-        updateResult(promiseState.aborted, new Error("aborted"));
+      var _result$activeIndex$v;
+      if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+        updateResult(promiseState.aborted, /* @__PURE__ */ new Error("aborted"));
         return;
       }
-      if (((_a = result[activeIndex.value]) == null ? void 0 : _a.state) === promiseState.rejected && interrupt) {
+      if (((_result$activeIndex$v = result[activeIndex.value]) === null || _result$activeIndex$v === void 0 ? void 0 : _result$activeIndex$v.state) === promiseState.rejected && interrupt) {
         onFinished();
         return;
       }
       const done = curr(prevRes).then((currentRes) => {
         updateResult(promiseState.fulfilled, currentRes);
-        if (activeIndex.value === tasks.length - 1)
-          onFinished();
+        if (activeIndex.value === tasks.length - 1) onFinished();
         return currentRes;
       });
-      if (!signal)
-        return done;
+      if (!signal) return done;
       return Promise.race([done, whenAborted(signal)]);
     }).catch((e) => {
-      if (signal == null ? void 0 : signal.aborted) {
+      if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
         updateResult(promiseState.aborted, e);
         return e;
       }
       updateResult(promiseState.rejected, e);
       onError();
+      if (activeIndex.value === tasks.length - 1) onFinished();
       return e;
     });
   }, Promise.resolve());
@@ -1740,55 +1549,44 @@ function useAsyncQueue(tasks, options) {
 }
 function whenAborted(signal) {
   return new Promise((resolve, reject) => {
-    const error = new Error("aborted");
-    if (signal.aborted)
-      reject(error);
-    else
-      signal.addEventListener("abort", () => reject(error), { once: true });
+    const error = /* @__PURE__ */ new Error("aborted");
+    if (signal.aborted) reject(error);
+    else signal.addEventListener("abort", () => reject(error), { once: true });
   });
 }
 function useAsyncState(promise, initialState, options) {
-  var _a;
-  const {
-    immediate = true,
-    delay = 0,
-    onError = (_a = globalThis.reportError) != null ? _a : noop,
-    onSuccess = noop,
-    resetOnExecute = true,
-    shallow = true,
-    throwError
-  } = options != null ? options : {};
+  var _globalThis$reportErr;
+  const { immediate = true, delay = 0, onError = (_globalThis$reportErr = globalThis.reportError) !== null && _globalThis$reportErr !== void 0 ? _globalThis$reportErr : noop, onSuccess = noop, resetOnExecute = true, shallow = true, throwError } = options !== null && options !== void 0 ? options : {};
   const state = shallow ? reactivity.shallowRef(initialState) : reactivity.ref(initialState);
   const isReady = reactivity.shallowRef(false);
   const isLoading = reactivity.shallowRef(false);
   const error = reactivity.shallowRef(void 0);
-  async function execute(delay2 = 0, ...args) {
-    if (resetOnExecute)
-      state.value = reactivity.toValue(initialState);
+  let executionsCount = 0;
+  async function execute(delay$1 = 0, ...args) {
+    const executionId = executionsCount += 1;
+    if (resetOnExecute) state.value = reactivity.toValue(initialState);
     error.value = void 0;
     isReady.value = false;
     isLoading.value = true;
-    if (delay2 > 0)
-      await promiseTimeout(delay2);
+    if (delay$1 > 0) await promiseTimeout(delay$1);
     const _promise = typeof promise === "function" ? promise(...args) : promise;
     try {
       const data = await _promise;
-      state.value = data;
-      isReady.value = true;
+      if (executionId === executionsCount) {
+        state.value = data;
+        isReady.value = true;
+      }
       onSuccess(data);
     } catch (e) {
-      error.value = e;
+      if (executionId === executionsCount) error.value = e;
       onError(e);
-      if (throwError)
-        throw e;
+      if (throwError) throw e;
     } finally {
-      isLoading.value = false;
+      if (executionId === executionsCount) isLoading.value = false;
     }
     return state.value;
   }
-  if (immediate) {
-    execute(delay);
-  }
+  if (immediate) execute(delay);
   const shell = {
     state,
     isReady,
@@ -1817,37 +1615,26 @@ const defaults = {
   null: () => ""
 };
 function getDefaultSerialization(target) {
-  if (!target)
-    return defaults.null;
-  if (target instanceof Map)
-    return defaults.map;
-  else if (target instanceof Set)
-    return defaults.set;
-  else if (Array.isArray(target))
-    return defaults.array;
-  else
-    return defaults.object;
+  if (!target) return defaults.null;
+  if (target instanceof Map) return defaults.map;
+  else if (target instanceof Set) return defaults.set;
+  else if (Array.isArray(target)) return defaults.array;
+  else return defaults.object;
 }
 function useBase64(target, options) {
   const base64 = reactivity.shallowRef("");
   const promise = reactivity.shallowRef();
   function execute() {
-    if (!isClient)
-      return;
+    if (!isClient) return;
     promise.value = new Promise((resolve, reject) => {
       try {
         const _target = reactivity.toValue(target);
-        if (_target == null) {
-          resolve("");
-        } else if (typeof _target === "string") {
-          resolve(blobToBase64(new Blob([_target], { type: "text/plain" })));
-        } else if (_target instanceof Blob) {
-          resolve(blobToBase64(_target));
-        } else if (_target instanceof ArrayBuffer) {
-          resolve(window.btoa(String.fromCharCode(...new Uint8Array(_target))));
-        } else if (_target instanceof HTMLCanvasElement) {
-          resolve(_target.toDataURL(options == null ? void 0 : options.type, options == null ? void 0 : options.quality));
-        } else if (_target instanceof HTMLImageElement) {
+        if (_target == null) resolve("");
+        else if (typeof _target === "string") resolve(blobToBase64(new Blob([_target], { type: "text/plain" })));
+        else if (_target instanceof Blob) resolve(blobToBase64(_target));
+        else if (_target instanceof ArrayBuffer) resolve(window.btoa(String.fromCharCode(...new Uint8Array(_target))));
+        else if (_target instanceof HTMLCanvasElement) resolve(_target.toDataURL(options === null || options === void 0 ? void 0 : options.type, options === null || options === void 0 ? void 0 : options.quality));
+        else if (_target instanceof HTMLImageElement) {
           const img = _target.cloneNode(false);
           img.crossOrigin = "Anonymous";
           imgLoaded(img).then(() => {
@@ -1856,28 +1643,23 @@ function useBase64(target, options) {
             canvas.width = img.width;
             canvas.height = img.height;
             ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
-            resolve(canvas.toDataURL(options == null ? void 0 : options.type, options == null ? void 0 : options.quality));
+            resolve(canvas.toDataURL(options === null || options === void 0 ? void 0 : options.type, options === null || options === void 0 ? void 0 : options.quality));
           }).catch(reject);
         } else if (typeof _target === "object") {
-          const _serializeFn = (options == null ? void 0 : options.serializer) || getDefaultSerialization(_target);
-          const serialized = _serializeFn(_target);
+          const serialized = ((options === null || options === void 0 ? void 0 : options.serializer) || getDefaultSerialization(_target))(_target);
           return resolve(blobToBase64(new Blob([serialized], { type: "application/json" })));
-        } else {
-          reject(new Error("target is unsupported types"));
-        }
+        } else reject(/* @__PURE__ */ new Error("target is unsupported types"));
       } catch (error) {
         reject(error);
       }
     });
     promise.value.then((res) => {
-      base64.value = (options == null ? void 0 : options.dataUrl) === false ? res.replace(/^data:.*?;base64,/, "") : res;
+      base64.value = (options === null || options === void 0 ? void 0 : options.dataUrl) === false ? res.replace(/^data:.*?;base64,/, "") : res;
     });
     return promise.value;
   }
-  if (reactivity.isRef(target) || typeof target === "function")
-    reactivity.watch(target, execute, { immediate: true });
-  else
-    execute();
+  if (reactivity.isRef(target) || typeof target === "function") reactivity.watch(target, execute, { immediate: true });
+  else execute();
   return {
     base64,
     promise,
@@ -1891,9 +1673,7 @@ function imgLoaded(img) {
         resolve();
       };
       img.onerror = reject;
-    } else {
-      resolve();
-    }
+    } else resolve();
   });
 }
 function blobToBase64(blob) {
@@ -1907,42 +1687,33 @@ function blobToBase64(blob) {
   });
 }
 function useBroadcastChannel(options) {
-  const {
-    name,
-    window: window2 = defaultWindow
-  } = options;
-  const isSupported = /* @__PURE__ */ useSupported(() => window2 && "BroadcastChannel" in window2);
+  const { name, window: window$1 = defaultWindow } = options;
+  const isSupported = /* @__PURE__ */ useSupported(() => window$1 && "BroadcastChannel" in window$1);
   const isClosed = reactivity.shallowRef(false);
   const channel = reactivity.ref();
   const data = reactivity.ref();
   const error = reactivity.shallowRef(null);
-  const post = (data2) => {
-    if (channel.value)
-      channel.value.postMessage(data2);
+  const post = (data$1) => {
+    if (channel.value) channel.value.postMessage(data$1);
   };
   const close = () => {
-    if (channel.value)
-      channel.value.close();
+    if (channel.value) channel.value.close();
     isClosed.value = true;
   };
-  if (isSupported.value) {
-    tryOnMounted(() => {
-      error.value = null;
-      channel.value = new BroadcastChannel(name);
-      const listenerOptions = {
-        passive: true
-      };
-      useEventListener(channel, "message", (e) => {
-        data.value = e.data;
-      }, listenerOptions);
-      useEventListener(channel, "messageerror", (e) => {
-        error.value = e;
-      }, listenerOptions);
-      useEventListener(channel, "close", () => {
-        isClosed.value = true;
-      }, listenerOptions);
-    });
-  }
+  if (isSupported.value) tryOnMounted(() => {
+    error.value = null;
+    channel.value = new BroadcastChannel(name);
+    const listenerOptions = { passive: true };
+    useEventListener(channel, "message", (e) => {
+      data.value = e.data;
+    }, listenerOptions);
+    useEventListener(channel, "messageerror", (e) => {
+      error.value = e;
+    }, listenerOptions);
+    useEventListener(channel, "close", () => {
+      isClosed.value = true;
+    }, listenerOptions);
+  });
   tryOnScopeDispose(() => {
     close();
   });
@@ -1960,8 +1731,7 @@ function useCached(refValue, comparator = (a, b) => a === b, options) {
   const { deepRefs = true, ...watchOptions } = options || {};
   const cachedValue = /* @__PURE__ */ createRef(refValue.value, deepRefs);
   reactivity.watch(() => refValue.value, (value) => {
-    if (!comparator(value, cachedValue.value))
-      cachedValue.value = value;
+    if (!comparator(value, cachedValue.value)) cachedValue.value = value;
   }, watchOptions);
   return cachedValue;
 }
@@ -1972,13 +1742,7 @@ function useCloned(source, options = {}) {
   const cloned = reactivity.ref({});
   const isModified = reactivity.shallowRef(false);
   let _lastSync = false;
-  const {
-    manual,
-    clone = cloneFnJSON,
-    // watch options
-    deep = true,
-    immediate = true
-  } = options;
+  const { manual, clone = cloneFnJSON, deep = true, immediate = true } = options;
   reactivity.watch(cloned, () => {
     if (_lastSync) {
       _lastSync = false;
@@ -1994,28 +1758,28 @@ function useCloned(source, options = {}) {
     isModified.value = false;
     cloned.value = clone(reactivity.toValue(source));
   }
-  if (!manual && (reactivity.isRef(source) || typeof source === "function")) {
-    reactivity.watch(source, sync, {
-      ...options,
-      deep,
-      immediate
-    });
-  } else {
-    sync();
-  }
-  return { cloned, isModified, sync };
+  if (!manual && (reactivity.isRef(source) || typeof source === "function")) reactivity.watch(source, sync, {
+    ...options,
+    deep,
+    immediate
+  });
+  else sync();
+  return {
+    cloned,
+    isModified,
+    sync
+  };
 }
 function useCycleList(list, options) {
   const state = reactivity.shallowRef(getInitialValue());
   const listRef = toRef(list);
   const index = reactivity.computed({
     get() {
-      var _a;
+      var _options$fallbackInde;
       const targetList = listRef.value;
-      let index2 = (options == null ? void 0 : options.getIndexOf) ? options.getIndexOf(state.value, targetList) : targetList.indexOf(state.value);
-      if (index2 < 0)
-        index2 = (_a = options == null ? void 0 : options.fallbackIndex) != null ? _a : 0;
-      return index2;
+      let index$1 = (options === null || options === void 0 ? void 0 : options.getIndexOf) ? options.getIndexOf(state.value, targetList) : targetList.indexOf(state.value);
+      if (index$1 < 0) index$1 = (_options$fallbackInde = options === null || options === void 0 ? void 0 : options.fallbackIndex) !== null && _options$fallbackInde !== void 0 ? _options$fallbackInde : 0;
+      return index$1;
     },
     set(v) {
       set2(v);
@@ -2024,8 +1788,7 @@ function useCycleList(list, options) {
   function set2(i) {
     const targetList = listRef.value;
     const length = targetList.length;
-    const index2 = (i % length + length) % length;
-    const value = targetList[index2];
+    const value = targetList[(i % length + length) % length];
     state.value = value;
     return value;
   }
@@ -2039,8 +1802,8 @@ function useCycleList(list, options) {
     return shift(-n);
   }
   function getInitialValue() {
-    var _a, _b;
-    return (_b = reactivity.toValue((_a = options == null ? void 0 : options.initialValue) != null ? _a : reactivity.toValue(list)[0])) != null ? _b : void 0;
+    var _toValue, _options$initialValue;
+    return (_toValue = reactivity.toValue((_options$initialValue = options === null || options === void 0 ? void 0 : options.initialValue) !== null && _options$initialValue !== void 0 ? _options$initialValue : reactivity.toValue(list)[0])) !== null && _toValue !== void 0 ? _toValue : void 0;
   }
   reactivity.watch(listRef, () => set2(index.value));
   return {
@@ -2064,12 +1827,7 @@ function defaultParse(clone) {
   return clone ? typeof clone === "function" ? clone : cloneFnJSON : fnBypass;
 }
 function useManualRefHistory(source, options = {}) {
-  const {
-    clone = false,
-    dump = defaultDump(clone),
-    parse = defaultParse(clone),
-    setSource = fnSetSource
-  } = options;
+  const { clone = false, dump = defaultDump(clone), parse = defaultParse(clone), setSource = fnSetSource } = options;
   function _createHistoryRecord() {
     return reactivity.markRaw({
       snapshot: dump(source.value),
@@ -2086,10 +1844,8 @@ function useManualRefHistory(source, options = {}) {
   const commit = () => {
     undoStack.value.unshift(last.value);
     last.value = _createHistoryRecord();
-    if (options.capacity && undoStack.value.length > options.capacity)
-      undoStack.value.splice(options.capacity, Number.POSITIVE_INFINITY);
-    if (redoStack.value.length)
-      redoStack.value.splice(0, redoStack.value.length);
+    if (options.capacity && undoStack.value.length > options.capacity) undoStack.value.splice(options.capacity, Number.POSITIVE_INFINITY);
+    if (redoStack.value.length) redoStack.value.splice(0, redoStack.value.length);
   };
   const clear = () => {
     undoStack.value.splice(0, undoStack.value.length);
@@ -2112,17 +1868,14 @@ function useManualRefHistory(source, options = {}) {
   const reset = () => {
     _setSource(last.value);
   };
-  const history = reactivity.computed(() => [last.value, ...undoStack.value]);
-  const canUndo = reactivity.computed(() => undoStack.value.length > 0);
-  const canRedo = reactivity.computed(() => redoStack.value.length > 0);
   return {
     source,
     undoStack,
     redoStack,
     last,
-    history,
-    canUndo,
-    canRedo,
+    history: reactivity.computed(() => [last.value, ...undoStack.value]),
+    canUndo: reactivity.computed(() => undoStack.value.length > 0),
+    canRedo: reactivity.computed(() => redoStack.value.length > 0),
     clear,
     commit,
     reset,
@@ -2131,48 +1884,36 @@ function useManualRefHistory(source, options = {}) {
   };
 }
 function useRefHistory(source, options = {}) {
-  const {
-    deep = false,
-    flush = "pre",
-    eventFilter,
-    shouldCommit = () => true
-  } = options;
-  const {
-    eventFilter: composedFilter,
-    pause,
-    resume: resumeTracking,
-    isActive: isTracking
-  } = pausableFilter(eventFilter);
+  const { deep = false, flush = "pre", eventFilter, shouldCommit = () => true } = options;
+  const { eventFilter: composedFilter, pause, resume: resumeTracking, isActive: isTracking } = pausableFilter(eventFilter);
   let lastRawValue = source.value;
-  const {
-    ignoreUpdates,
-    ignorePrevAsyncUpdates,
-    stop
-  } = watchIgnorable(
-    source,
-    commit,
-    { deep, flush, eventFilter: composedFilter }
-  );
-  function setSource(source2, value) {
+  const { ignoreUpdates, ignorePrevAsyncUpdates, stop } = watchIgnorable(source, commit, {
+    deep,
+    flush,
+    eventFilter: composedFilter
+  });
+  function setSource(source$1, value) {
     ignorePrevAsyncUpdates();
     ignoreUpdates(() => {
-      source2.value = value;
+      source$1.value = value;
       lastRawValue = value;
     });
   }
-  const manualHistory = useManualRefHistory(source, { ...options, clone: options.clone || deep, setSource });
+  const manualHistory = useManualRefHistory(source, {
+    ...options,
+    clone: options.clone || deep,
+    setSource
+  });
   const { clear, commit: manualCommit } = manualHistory;
   function commit() {
     ignorePrevAsyncUpdates();
-    if (!shouldCommit(lastRawValue, source.value))
-      return;
+    if (!shouldCommit(lastRawValue, source.value)) return;
     lastRawValue = source.value;
     manualCommit();
   }
   function resume(commitNow) {
     resumeTracking();
-    if (commitNow)
-      commit();
+    if (commitNow) commit();
   }
   function batch(fn) {
     let canceled = false;
@@ -2180,8 +1921,7 @@ function useRefHistory(source, options = {}) {
     ignoreUpdates(() => {
       fn(cancel);
     });
-    if (!canceled)
-      commit();
+    if (!canceled) commit();
   }
   function dispose() {
     stop();
@@ -2199,22 +1939,22 @@ function useRefHistory(source, options = {}) {
 }
 function useDebouncedRefHistory(source, options = {}) {
   const filter = options.debounce ? debounceFilter(options.debounce) : void 0;
-  const history = useRefHistory(source, { ...options, eventFilter: filter });
-  return {
-    ...history
-  };
+  return { ...useRefHistory(source, {
+    ...options,
+    eventFilter: filter
+  }) };
 }
 const events = /* @__PURE__ */ new Map();
 // @__NO_SIDE_EFFECTS__
 function useEventBus(key) {
   const scope = reactivity.getCurrentScope();
   function on(listener) {
-    var _a;
+    var _scope$cleanups;
     const listeners = events.get(key) || /* @__PURE__ */ new Set();
     listeners.add(listener);
     events.set(key, listeners);
     const _off = () => off(listener);
-    (_a = scope == null ? void 0 : scope.cleanups) == null ? void 0 : _a.push(_off);
+    scope === null || scope === void 0 || (_scope$cleanups = scope.cleanups) === null || _scope$cleanups === void 0 || _scope$cleanups.push(_off);
     return _off;
   }
   function once(listener) {
@@ -2226,20 +1966,24 @@ function useEventBus(key) {
   }
   function off(listener) {
     const listeners = events.get(key);
-    if (!listeners)
-      return;
+    if (!listeners) return;
     listeners.delete(listener);
-    if (!listeners.size)
-      reset();
+    if (!listeners.size) reset();
   }
   function reset() {
     events.delete(key);
   }
   function emit(event, payload) {
-    var _a;
-    (_a = events.get(key)) == null ? void 0 : _a.forEach((v) => v(event, payload));
+    var _events$get;
+    (_events$get = events.get(key)) === null || _events$get === void 0 || _events$get.forEach((v) => v(event, payload));
   }
-  return { on, once, off, emit, reset };
+  return {
+    on,
+    once,
+    off,
+    emit,
+    reset
+  };
 }
 const payloadMapping = {
   json: "application/json",
@@ -2253,33 +1997,29 @@ function isAbsoluteURL(url) {
   return reAbsolute.test(url);
 }
 function headersToObject(headers) {
-  if (typeof Headers !== "undefined" && headers instanceof Headers)
-    return Object.fromEntries(headers.entries());
+  if (typeof Headers !== "undefined" && headers instanceof Headers) return Object.fromEntries(headers.entries());
   return headers;
 }
 function combineCallbacks(combination, ...callbacks) {
-  if (combination === "overwrite") {
-    return async (ctx) => {
-      let callback;
-      for (let i = callbacks.length - 1; i >= 0; i--) {
-        if (callbacks[i] != null) {
-          callback = callbacks[i];
-          break;
-        }
-      }
-      if (callback)
-        return { ...ctx, ...await callback(ctx) };
-      return ctx;
+  if (combination === "overwrite") return async (ctx) => {
+    let callback;
+    for (let i = callbacks.length - 1; i >= 0; i--) if (callbacks[i] != null) {
+      callback = callbacks[i];
+      break;
+    }
+    if (callback) return {
+      ...ctx,
+      ...await callback(ctx)
     };
-  } else {
-    return async (ctx) => {
-      for (const callback of callbacks) {
-        if (callback)
-          ctx = { ...ctx, ...await callback(ctx) };
-      }
-      return ctx;
+    return ctx;
+  };
+  else return async (ctx) => {
+    for (const callback of callbacks) if (callback) ctx = {
+      ...ctx,
+      ...await callback(ctx)
     };
-  }
+    return ctx;
+  };
 }
 function createFetch(config = {}) {
   const _combination = config.combination || "chain";
@@ -2293,41 +2033,34 @@ function createFetch(config = {}) {
     });
     let options = _options;
     let fetchOptions = _fetchOptions;
-    if (args.length > 0) {
-      if (isFetchOptions(args[0])) {
-        options = {
-          ...options,
-          ...args[0],
-          beforeFetch: combineCallbacks(_combination, _options.beforeFetch, args[0].beforeFetch),
-          afterFetch: combineCallbacks(_combination, _options.afterFetch, args[0].afterFetch),
-          onFetchError: combineCallbacks(_combination, _options.onFetchError, args[0].onFetchError)
-        };
-      } else {
-        fetchOptions = {
-          ...fetchOptions,
-          ...args[0],
-          headers: {
-            ...headersToObject(fetchOptions.headers) || {},
-            ...headersToObject(args[0].headers) || {}
-          }
-        };
+    if (args.length > 0) if (isFetchOptions(args[0])) options = {
+      ...options,
+      ...args[0],
+      beforeFetch: combineCallbacks(_combination, _options.beforeFetch, args[0].beforeFetch),
+      afterFetch: combineCallbacks(_combination, _options.afterFetch, args[0].afterFetch),
+      onFetchError: combineCallbacks(_combination, _options.onFetchError, args[0].onFetchError)
+    };
+    else fetchOptions = {
+      ...fetchOptions,
+      ...args[0],
+      headers: {
+        ...headersToObject(fetchOptions.headers) || {},
+        ...headersToObject(args[0].headers) || {}
       }
-    }
-    if (args.length > 1 && isFetchOptions(args[1])) {
-      options = {
-        ...options,
-        ...args[1],
-        beforeFetch: combineCallbacks(_combination, _options.beforeFetch, args[1].beforeFetch),
-        afterFetch: combineCallbacks(_combination, _options.afterFetch, args[1].afterFetch),
-        onFetchError: combineCallbacks(_combination, _options.onFetchError, args[1].onFetchError)
-      };
-    }
+    };
+    if (args.length > 1 && isFetchOptions(args[1])) options = {
+      ...options,
+      ...args[1],
+      beforeFetch: combineCallbacks(_combination, _options.beforeFetch, args[1].beforeFetch),
+      afterFetch: combineCallbacks(_combination, _options.afterFetch, args[1].afterFetch),
+      onFetchError: combineCallbacks(_combination, _options.onFetchError, args[1].onFetchError)
+    };
     return useFetch(computedUrl, fetchOptions, options);
   }
   return useFactoryFetch;
 }
 function useFetch(url, ...args) {
-  var _a, _b;
+  var _defaultWindow$fetch, _globalThis;
   const supportsAbort = typeof AbortController === "function";
   let fetchOptions = {};
   let options = {
@@ -2341,21 +2074,18 @@ function useFetch(url, ...args) {
     type: "text",
     payload: void 0
   };
-  if (args.length > 0) {
-    if (isFetchOptions(args[0]))
-      options = { ...options, ...args[0] };
-    else
-      fetchOptions = args[0];
-  }
+  if (args.length > 0) if (isFetchOptions(args[0])) options = {
+    ...options,
+    ...args[0]
+  };
+  else fetchOptions = args[0];
   if (args.length > 1) {
-    if (isFetchOptions(args[1]))
-      options = { ...options, ...args[1] };
-  }
-  const {
-    fetch = (_b = (_a = defaultWindow) == null ? void 0 : _a.fetch) != null ? _b : globalThis == null ? void 0 : globalThis.fetch,
-    initialData,
-    timeout
-  } = options;
+    if (isFetchOptions(args[1])) options = {
+      ...options,
+      ...args[1]
+    };
+  }
+  const { fetch = (_defaultWindow$fetch = defaultWindow === null || defaultWindow === void 0 ? void 0 : defaultWindow.fetch) !== null && _defaultWindow$fetch !== void 0 ? _defaultWindow$fetch : (_globalThis = globalThis) === null || _globalThis === void 0 ? void 0 : _globalThis.fetch, initialData, timeout } = options;
   const responseEvent = /* @__PURE__ */ createEventHook();
   const errorEvent = /* @__PURE__ */ createEventHook();
   const finallyEvent = /* @__PURE__ */ createEventHook();
@@ -2371,7 +2101,7 @@ function useFetch(url, ...args) {
   let timer;
   const abort = (reason) => {
     if (supportsAbort) {
-      controller == null ? void 0 : controller.abort(reason);
+      controller === null || controller === void 0 || controller.abort(reason);
       controller = new AbortController();
       controller.signal.onabort = () => aborted.value = true;
       fetchOptions = {
@@ -2384,11 +2114,10 @@ function useFetch(url, ...args) {
     isFetching.value = isLoading;
     isFinished.value = !isLoading;
   };
-  if (timeout)
-    timer = useTimeoutFn(abort, timeout, { immediate: false });
+  if (timeout) timer = useTimeoutFn(abort, timeout, { immediate: false });
   let executeCounter = 0;
   const execute = async (throwOnFailed = false) => {
-    var _a2, _b2;
+    var _context$options;
     abort();
     loading(true);
     error.value = null;
@@ -2402,12 +2131,11 @@ function useFetch(url, ...args) {
     };
     const payload = reactivity.toValue(config.payload);
     if (payload) {
+      var _payloadMapping$confi;
       const headers = headersToObject(defaultFetchOptions.headers);
       const proto = Object.getPrototypeOf(payload);
-      if (!config.payloadType && payload && (proto === Object.prototype || Array.isArray(proto)) && !(payload instanceof FormData))
-        config.payloadType = "json";
-      if (config.payloadType)
-        headers["Content-Type"] = (_a2 = payloadMapping[config.payloadType]) != null ? _a2 : config.payloadType;
+      if (!config.payloadType && payload && (proto === Object.prototype || Array.isArray(proto)) && !(payload instanceof FormData)) config.payloadType = "json";
+      if (config.payloadType) headers["Content-Type"] = (_payloadMapping$confi = payloadMapping[config.payloadType]) !== null && _payloadMapping$confi !== void 0 ? _payloadMapping$confi : config.payloadType;
       defaultFetchOptions.body = config.payloadType === "json" ? JSON.stringify(payload) : payload;
     }
     let isCanceled = false;
@@ -2421,26 +2149,21 @@ function useFetch(url, ...args) {
         isCanceled = true;
       }
     };
-    if (options.beforeFetch)
-      Object.assign(context, await options.beforeFetch(context));
+    if (options.beforeFetch) Object.assign(context, await options.beforeFetch(context));
     if (isCanceled || !fetch) {
       loading(false);
       return Promise.resolve(null);
     }
     let responseData = null;
-    if (timer)
-      timer.start();
-    return fetch(
-      context.url,
-      {
-        ...defaultFetchOptions,
-        ...context.options,
-        headers: {
-          ...headersToObject(defaultFetchOptions.headers),
-          ...headersToObject((_b2 = context.options) == null ? void 0 : _b2.headers)
-        }
+    if (timer) timer.start();
+    return fetch(context.url, {
+      ...defaultFetchOptions,
+      ...context.options,
+      headers: {
+        ...headersToObject(defaultFetchOptions.headers),
+        ...headersToObject((_context$options = context.options) === null || _context$options === void 0 ? void 0 : _context$options.headers)
       }
-    ).then(async (fetchResponse) => {
+    }).then(async (fetchResponse) => {
       response.value = fetchResponse;
       statusCode.value = fetchResponse.status;
       responseData = await fetchResponse.clone()[config.type]();
@@ -2448,52 +2171,37 @@ function useFetch(url, ...args) {
         data.value = initialData || null;
         throw new Error(fetchResponse.statusText);
       }
-      if (options.afterFetch) {
-        ({ data: responseData } = await options.afterFetch({
-          data: responseData,
-          response: fetchResponse,
-          context,
-          execute
-        }));
-      }
+      if (options.afterFetch) ({ data: responseData } = await options.afterFetch({
+        data: responseData,
+        response: fetchResponse,
+        context,
+        execute
+      }));
       data.value = responseData;
       responseEvent.trigger(fetchResponse);
       return fetchResponse;
     }).catch(async (fetchError) => {
       let errorData = fetchError.message || fetchError.name;
-      if (options.onFetchError) {
-        ({ error: errorData, data: responseData } = await options.onFetchError({
-          data: responseData,
-          error: fetchError,
-          response: response.value,
-          context,
-          execute
-        }));
-      }
+      if (options.onFetchError) ({ error: errorData, data: responseData } = await options.onFetchError({
+        data: responseData,
+        error: fetchError,
+        response: response.value,
+        context,
+        execute
+      }));
       error.value = errorData;
-      if (options.updateDataOnError)
-        data.value = responseData;
+      if (options.updateDataOnError) data.value = responseData;
       errorEvent.trigger(fetchError);
-      if (throwOnFailed)
-        throw fetchError;
+      if (throwOnFailed) throw fetchError;
       return null;
     }).finally(() => {
-      if (currentExecuteCounter === executeCounter)
-        loading(false);
-      if (timer)
-        timer.stop();
+      if (currentExecuteCounter === executeCounter) loading(false);
+      if (timer) timer.stop();
       finallyEvent.trigger(null);
     });
   };
   const refetch = toRef(options.refetch);
-  reactivity.watch(
-    [
-      refetch,
-      toRef(url)
-    ],
-    ([refetch2]) => refetch2 && execute(),
-    { deep: true }
-  );
+  reactivity.watch([refetch, toRef(url)], ([refetch$1]) => refetch$1 && execute(), { deep: true });
   const shell = {
     isFinished: reactivity.readonly(isFinished),
     isFetching: reactivity.readonly(isFetching),
@@ -2508,7 +2216,6 @@ function useFetch(url, ...args) {
     onFetchResponse: responseEvent.on,
     onFetchError: errorEvent.on,
     onFetchFinally: finallyEvent.on,
-    // method
     get: setMethod("GET"),
     put: setMethod("PUT"),
     post: setMethod("POST"),
@@ -2516,7 +2223,6 @@ function useFetch(url, ...args) {
     patch: setMethod("PATCH"),
     head: setMethod("HEAD"),
     options: setMethod("OPTIONS"),
-    // type
     json: setType("json"),
     text: setType("text"),
     blob: setType("blob"),
@@ -2529,16 +2235,7 @@ function useFetch(url, ...args) {
         config.method = method;
         config.payload = payload;
         config.payloadType = payloadType;
-        if (reactivity.isRef(config.payload)) {
-          reactivity.watch(
-            [
-              refetch,
-              toRef(config.payload)
-            ],
-            ([refetch2]) => refetch2 && execute(),
-            { deep: true }
-          );
-        }
+        if (reactivity.isRef(config.payload)) reactivity.watch([refetch, toRef(config.payload)], ([refetch$1]) => refetch$1 && execute(), { deep: true });
         return {
           ...shell,
           then(onFulfilled, onRejected) {
@@ -2546,7 +2243,6 @@ function useFetch(url, ...args) {
           }
         };
       }
-      return void 0;
     };
   }
   function waitUntilFinished() {
@@ -2565,11 +2261,9 @@ function useFetch(url, ...args) {
           }
         };
       }
-      return void 0;
     };
   }
-  if (options.immediate)
-    Promise.resolve().then(() => execute());
+  if (options.immediate) Promise.resolve().then(() => execute());
   return {
     ...shell,
     then(onFulfilled, onRejected) {
@@ -2578,138 +2272,113 @@ function useFetch(url, ...args) {
   };
 }
 function joinPaths(start, end) {
-  if (!start.endsWith("/") && !end.startsWith("/")) {
-    return `${start}/${end}`;
-  }
-  if (start.endsWith("/") && end.startsWith("/")) {
-    return `${start.slice(0, -1)}${end}`;
-  }
+  if (!start.endsWith("/") && !end.startsWith("/")) return `${start}/${end}`;
+  if (start.endsWith("/") && end.startsWith("/")) return `${start.slice(0, -1)}${end}`;
   return `${start}${end}`;
 }
-const defaultEvents$1 = ["mousemove", "mousedown", "resize", "keydown", "touchstart", "wheel"];
+const defaultEvents$1 = [
+  "mousemove",
+  "mousedown",
+  "resize",
+  "keydown",
+  "touchstart",
+  "wheel"
+];
 const oneMinute = 6e4;
 function useIdle(timeout = oneMinute, options = {}) {
-  const {
-    initialState = false,
-    listenForVisibilityChange = true,
-    events: events2 = defaultEvents$1,
-    window: window2 = defaultWindow,
-    eventFilter = throttleFilter(50)
-  } = options;
+  const { initialState = false, listenForVisibilityChange = true, events: events$1 = defaultEvents$1, window: window$1 = defaultWindow, eventFilter = throttleFilter(50) } = options;
   const idle = reactivity.shallowRef(initialState);
   const lastActive = reactivity.shallowRef(timestamp());
+  const isPending = reactivity.shallowRef(false);
   let timer;
   const reset = () => {
     idle.value = false;
     clearTimeout(timer);
     timer = setTimeout(() => idle.value = true, timeout);
   };
-  const onEvent = createFilterWrapper(
-    eventFilter,
-    () => {
-      lastActive.value = timestamp();
-      reset();
-    }
-  );
-  if (window2) {
-    const document2 = window2.document;
+  const onEvent = createFilterWrapper(eventFilter, () => {
+    lastActive.value = timestamp();
+    reset();
+  });
+  if (window$1) {
+    const document$1 = window$1.document;
     const listenerOptions = { passive: true };
-    for (const event of events2)
-      useEventListener(window2, event, onEvent, listenerOptions);
-    if (listenForVisibilityChange) {
-      useEventListener(document2, "visibilitychange", () => {
-        if (!document2.hidden)
-          onEvent();
-      }, listenerOptions);
-    }
-    if (!initialState)
-      reset();
+    for (const event of events$1) useEventListener(window$1, event, () => {
+      if (!isPending.value) return;
+      onEvent();
+    }, listenerOptions);
+    if (listenForVisibilityChange) useEventListener(document$1, "visibilitychange", () => {
+      if (document$1.hidden || !isPending.value) return;
+      onEvent();
+    }, listenerOptions);
+    start();
+  }
+  function start() {
+    if (isPending.value) return;
+    isPending.value = true;
+    if (!initialState) reset();
+  }
+  function stop() {
+    idle.value = initialState;
+    clearTimeout(timer);
+    isPending.value = false;
   }
   return {
     idle,
     lastActive,
-    reset
+    reset,
+    stop,
+    start,
+    isPending: reactivity.shallowReadonly(isPending)
   };
 }
 // @__NO_SIDE_EFFECTS__
 function useNow(options = {}) {
-  const {
-    controls: exposeControls = false,
-    interval = "requestAnimationFrame",
-    immediate = true
-  } = options;
+  const { controls: exposeControls = false, interval = "requestAnimationFrame", immediate = true } = options;
   const now2 = reactivity.ref(/* @__PURE__ */ new Date());
   const update = () => now2.value = /* @__PURE__ */ new Date();
   const controls = interval === "requestAnimationFrame" ? useRafFn(update, { immediate }) : useIntervalFn(update, interval, { immediate });
-  if (exposeControls) {
-    return {
-      now: now2,
-      ...controls
-    };
-  } else {
-    return now2;
-  }
+  if (exposeControls) return {
+    now: now2,
+    ...controls
+  };
+  else return now2;
 }
 function useObjectUrl(object) {
   const url = reactivity.shallowRef();
   const release = () => {
-    if (url.value)
-      URL.revokeObjectURL(url.value);
+    if (url.value) URL.revokeObjectURL(url.value);
     url.value = void 0;
   };
-  reactivity.watch(
-    () => reactivity.toValue(object),
-    (newObject) => {
-      release();
-      if (newObject)
-        url.value = URL.createObjectURL(newObject);
-    },
-    { immediate: true }
-  );
+  reactivity.watch(() => reactivity.toValue(object), (newObject) => {
+    release();
+    if (newObject) url.value = URL.createObjectURL(newObject);
+  }, { immediate: true });
   tryOnScopeDispose(release);
   return reactivity.readonly(url);
 }
 // @__NO_SIDE_EFFECTS__
 function useClamp(value, min, max) {
-  if (typeof value === "function" || reactivity.isReadonly(value))
-    return reactivity.computed(() => clamp(reactivity.toValue(value), reactivity.toValue(min), reactivity.toValue(max)));
+  if (typeof value === "function" || reactivity.isReadonly(value)) return reactivity.computed(() => clamp(reactivity.toValue(value), reactivity.toValue(min), reactivity.toValue(max)));
   const _value = reactivity.ref(value);
   return reactivity.computed({
     get() {
       return _value.value = clamp(_value.value, reactivity.toValue(min), reactivity.toValue(max));
     },
-    set(value2) {
-      _value.value = clamp(value2, reactivity.toValue(min), reactivity.toValue(max));
+    set(value$1) {
+      _value.value = clamp(value$1, reactivity.toValue(min), reactivity.toValue(max));
     }
   });
 }
 function useOffsetPagination(options) {
-  const {
-    total = Number.POSITIVE_INFINITY,
-    pageSize = 10,
-    page = 1,
-    onPageChange = noop,
-    onPageSizeChange = noop,
-    onPageCountChange = noop
-  } = options;
+  const { total = Number.POSITIVE_INFINITY, pageSize = 10, page = 1, onPageChange = noop, onPageSizeChange = noop, onPageCountChange = noop } = options;
   const currentPageSize = /* @__PURE__ */ useClamp(pageSize, 1, Number.POSITIVE_INFINITY);
-  const pageCount = reactivity.computed(() => Math.max(
-    1,
-    Math.ceil(reactivity.toValue(total) / reactivity.toValue(currentPageSize))
-  ));
+  const pageCount = reactivity.computed(() => Math.max(1, Math.ceil(reactivity.toValue(total) / reactivity.toValue(currentPageSize))));
   const currentPage = /* @__PURE__ */ useClamp(page, 1, pageCount);
   const isFirstPage = reactivity.computed(() => currentPage.value === 1);
   const isLastPage = reactivity.computed(() => currentPage.value === pageCount.value);
-  if (reactivity.isRef(page)) {
-    syncRef(page, currentPage, {
-      direction: reactivity.isReadonly(page) ? "ltr" : "both"
-    });
-  }
-  if (reactivity.isRef(pageSize)) {
-    syncRef(pageSize, currentPageSize, {
-      direction: reactivity.isReadonly(pageSize) ? "ltr" : "both"
-    });
-  }
+  if (reactivity.isRef(page)) syncRef(page, currentPage, { direction: reactivity.isReadonly(page) ? "ltr" : "both" });
+  if (reactivity.isRef(pageSize)) syncRef(pageSize, currentPageSize, { direction: reactivity.isReadonly(pageSize) ? "ltr" : "both" });
   function prev() {
     currentPage.value--;
   }
@@ -2738,45 +2407,36 @@ function useOffsetPagination(options) {
 }
 function usePrevious(value, initialValue) {
   const previous = reactivity.shallowRef(initialValue);
-  reactivity.watch(
-    toRef(value),
-    (_, oldValue) => {
-      previous.value = oldValue;
-    },
-    { flush: "sync" }
-  );
+  reactivity.watch(toRef(value), (_, oldValue) => {
+    previous.value = oldValue;
+  }, { flush: "sync" });
   return reactivity.readonly(previous);
 }
 const defaultSortFn = (source, compareFn) => source.sort(compareFn);
 const defaultCompare = (a, b) => a - b;
 function useSorted(...args) {
-  var _a, _b, _c, _d;
   const [source] = args;
   let compareFn = defaultCompare;
   let options = {};
-  if (args.length === 2) {
-    if (typeof args[1] === "object") {
-      options = args[1];
-      compareFn = (_a = options.compareFn) != null ? _a : defaultCompare;
-    } else {
-      compareFn = (_b = args[1]) != null ? _b : defaultCompare;
-    }
-  } else if (args.length > 2) {
-    compareFn = (_c = args[1]) != null ? _c : defaultCompare;
-    options = (_d = args[2]) != null ? _d : {};
-  }
-  const {
-    dirty = false,
-    sortFn = defaultSortFn
-  } = options;
-  if (!dirty)
-    return reactivity.computed(() => sortFn([...reactivity.toValue(source)], compareFn));
+  if (args.length === 2) if (typeof args[1] === "object") {
+    var _options$compareFn;
+    options = args[1];
+    compareFn = (_options$compareFn = options.compareFn) !== null && _options$compareFn !== void 0 ? _options$compareFn : defaultCompare;
+  } else {
+    var _args$;
+    compareFn = (_args$ = args[1]) !== null && _args$ !== void 0 ? _args$ : defaultCompare;
+  }
+  else if (args.length > 2) {
+    var _args$2, _args$3;
+    compareFn = (_args$2 = args[1]) !== null && _args$2 !== void 0 ? _args$2 : defaultCompare;
+    options = (_args$3 = args[2]) !== null && _args$3 !== void 0 ? _args$3 : {};
+  }
+  const { dirty = false, sortFn = defaultSortFn } = options;
+  if (!dirty) return reactivity.computed(() => sortFn([...reactivity.toValue(source)], compareFn));
   reactivity.watchEffect(() => {
     const result = sortFn(reactivity.toValue(source), compareFn);
-    if (reactivity.isRef(source))
-      source.value = result;
-    else
-      source.splice(0, source.length, ...result);
+    if (reactivity.isRef(source)) source.value = result;
+    else source.splice(0, source.length, ...result);
   });
   return source;
 }
@@ -2784,39 +2444,33 @@ function useSorted(...args) {
 function useStepper(steps, initialStep) {
   const stepsRef = reactivity.ref(steps);
   const stepNames = reactivity.computed(() => Array.isArray(stepsRef.value) ? stepsRef.value : Object.keys(stepsRef.value));
-  const index = reactivity.ref(stepNames.value.indexOf(initialStep != null ? initialStep : stepNames.value[0]));
+  const index = reactivity.ref(stepNames.value.indexOf(initialStep !== null && initialStep !== void 0 ? initialStep : stepNames.value[0]));
   const current = reactivity.computed(() => at(index.value));
   const isFirst = reactivity.computed(() => index.value === 0);
   const isLast = reactivity.computed(() => index.value === stepNames.value.length - 1);
   const next = reactivity.computed(() => stepNames.value[index.value + 1]);
   const previous = reactivity.computed(() => stepNames.value[index.value - 1]);
-  function at(index2) {
-    if (Array.isArray(stepsRef.value))
-      return stepsRef.value[index2];
-    return stepsRef.value[stepNames.value[index2]];
+  function at(index$1) {
+    if (Array.isArray(stepsRef.value)) return stepsRef.value[index$1];
+    return stepsRef.value[stepNames.value[index$1]];
   }
   function get2(step) {
-    if (!stepNames.value.includes(step))
-      return;
+    if (!stepNames.value.includes(step)) return;
     return at(stepNames.value.indexOf(step));
   }
   function goTo(step) {
-    if (stepNames.value.includes(step))
-      index.value = stepNames.value.indexOf(step);
+    if (stepNames.value.includes(step)) index.value = stepNames.value.indexOf(step);
   }
   function goToNext() {
-    if (isLast.value)
-      return;
+    if (isLast.value) return;
     index.value++;
   }
   function goToPrevious() {
-    if (isFirst.value)
-      return;
+    if (isFirst.value) return;
     index.value--;
   }
   function goBackTo(step) {
-    if (isAfter(step))
-      goTo(step);
+    if (isAfter(step)) goTo(step);
   }
   function isNext(step) {
     return stepNames.value.indexOf(step) === index.value + 1;
@@ -2858,19 +2512,47 @@ function useStepper(steps, initialStep) {
 function useThrottledRefHistory(source, options = {}) {
   const { throttle = 200, trailing = true } = options;
   const filter = throttleFilter(throttle, trailing);
-  const history = useRefHistory(source, { ...options, eventFilter: filter });
-  return {
-    ...history
-  };
+  return { ...useRefHistory(source, {
+    ...options,
+    eventFilter: filter
+  }) };
 }
 const DEFAULT_UNITS = [
-  { max: 6e4, value: 1e3, name: "second" },
-  { max: 276e4, value: 6e4, name: "minute" },
-  { max: 72e6, value: 36e5, name: "hour" },
-  { max: 5184e5, value: 864e5, name: "day" },
-  { max: 24192e5, value: 6048e5, name: "week" },
-  { max: 28512e6, value: 2592e6, name: "month" },
-  { max: Number.POSITIVE_INFINITY, value: 31536e6, name: "year" }
+  {
+    max: 6e4,
+    value: 1e3,
+    name: "second"
+  },
+  {
+    max: 276e4,
+    value: 6e4,
+    name: "minute"
+  },
+  {
+    max: 72e6,
+    value: 36e5,
+    name: "hour"
+  },
+  {
+    max: 5184e5,
+    value: 864e5,
+    name: "day"
+  },
+  {
+    max: 24192e5,
+    value: 6048e5,
+    name: "week"
+  },
+  {
+    max: 28512e6,
+    value: 2592e6,
+    name: "month"
+  },
+  {
+    max: Number.POSITIVE_INFINITY,
+    value: 31536e6,
+    name: "year"
+  }
 ];
 const DEFAULT_MESSAGES = {
   justNow: "just now",
@@ -2890,93 +2572,70 @@ function DEFAULT_FORMATTER(date) {
 }
 // @__NO_SIDE_EFFECTS__
 function useTimeAgo(time, options = {}) {
-  const {
-    controls: exposeControls = false,
-    updateInterval = 3e4
-  } = options;
-  const { now: now2, ...controls } = /* @__PURE__ */ useNow({ interval: updateInterval, controls: true });
+  const { controls: exposeControls = false, updateInterval = 3e4 } = options;
+  const { now: now2, ...controls } = /* @__PURE__ */ useNow({
+    interval: updateInterval,
+    controls: true
+  });
   const timeAgo = reactivity.computed(() => formatTimeAgo(new Date(reactivity.toValue(time)), options, reactivity.toValue(now2)));
-  if (exposeControls) {
-    return {
-      timeAgo,
-      ...controls
-    };
-  } else {
-    return timeAgo;
-  }
+  if (exposeControls) return {
+    timeAgo,
+    ...controls
+  };
+  else return timeAgo;
 }
 function formatTimeAgo(from, options = {}, now2 = Date.now()) {
-  var _a;
-  const {
-    max,
-    messages = DEFAULT_MESSAGES,
-    fullDateFormatter = DEFAULT_FORMATTER,
-    units = DEFAULT_UNITS,
-    showSecond = false,
-    rounding = "round"
-  } = options;
+  const { max, messages = DEFAULT_MESSAGES, fullDateFormatter = DEFAULT_FORMATTER, units = DEFAULT_UNITS, showSecond = false, rounding = "round" } = options;
   const roundFn = typeof rounding === "number" ? (n) => +n.toFixed(rounding) : Math[rounding];
   const diff = +now2 - +from;
   const absDiff = Math.abs(diff);
-  function getValue(diff2, unit) {
-    return roundFn(Math.abs(diff2) / unit.value);
+  function getValue$1(diff$1, unit) {
+    return roundFn(Math.abs(diff$1) / unit.value);
   }
-  function format(diff2, unit) {
-    const val = getValue(diff2, unit);
-    const past = diff2 > 0;
+  function format(diff$1, unit) {
+    const val = getValue$1(diff$1, unit);
+    const past = diff$1 > 0;
     const str = applyFormat(unit.name, val, past);
     return applyFormat(past ? "past" : "future", str, past);
   }
   function applyFormat(name, val, isPast) {
     const formatter = messages[name];
-    if (typeof formatter === "function")
-      return formatter(val, isPast);
+    if (typeof formatter === "function") return formatter(val, isPast);
     return formatter.replace("{0}", val.toString());
   }
-  if (absDiff < 6e4 && !showSecond)
-    return messages.justNow;
-  if (typeof max === "number" && absDiff > max)
-    return fullDateFormatter(new Date(from));
+  if (absDiff < 6e4 && !showSecond) return messages.justNow;
+  if (typeof max === "number" && absDiff > max) return fullDateFormatter(new Date(from));
   if (typeof max === "string") {
-    const unitMax = (_a = units.find((i) => i.name === max)) == null ? void 0 : _a.max;
-    if (unitMax && absDiff > unitMax)
-      return fullDateFormatter(new Date(from));
+    var _units$find;
+    const unitMax = (_units$find = units.find((i) => i.name === max)) === null || _units$find === void 0 ? void 0 : _units$find.max;
+    if (unitMax && absDiff > unitMax) return fullDateFormatter(new Date(from));
   }
   for (const [idx, unit] of units.entries()) {
-    const val = getValue(diff, unit);
-    if (val <= 0 && units[idx - 1])
-      return format(diff, units[idx - 1]);
-    if (absDiff < unit.max)
-      return format(diff, unit);
+    if (getValue$1(diff, unit) <= 0 && units[idx - 1]) return format(diff, units[idx - 1]);
+    if (absDiff < unit.max) return format(diff, unit);
   }
   return messages.invalid;
 }
 function useTimeoutPoll(fn, interval, options = {}) {
-  const {
-    immediate = true,
-    immediateCallback = false
-  } = options;
+  const { immediate = true, immediateCallback = false } = options;
   const { start } = useTimeoutFn(loop, interval, { immediate });
   const isActive = reactivity.shallowRef(false);
   async function loop() {
-    if (!isActive.value)
-      return;
+    if (!isActive.value) return;
     await fn();
     start();
   }
   function resume() {
     if (!isActive.value) {
       isActive.value = true;
-      if (immediateCallback)
-        fn();
+      if (immediateCallback) fn();
       start();
     }
   }
   function pause() {
     isActive.value = false;
   }
-  if (immediate && isClient)
-    resume();
+  if (immediate && isClient) resume();
   tryOnScopeDispose(pause);
   return {
     isActive,
@@ -2985,13 +2644,7 @@ function useTimeoutPoll(fn, interval, options = {}) {
   };
 }
 function useTimestamp(options = {}) {
-  const {
-    controls: exposeControls = false,
-    offset = 0,
-    immediate = true,
-    interval = "requestAnimationFrame",
-    callback
-  } = options;
+  const { controls: exposeControls = false, offset = 0, immediate = true, interval = "requestAnimationFrame", callback } = options;
   const ts = reactivity.shallowRef(timestamp() + offset);
   const update = () => ts.value = timestamp() + offset;
   const cb = callback ? () => {
@@ -2999,50 +2652,32 @@ function useTimestamp(options = {}) {
     callback(ts.value);
   } : update;
   const controls = interval === "requestAnimationFrame" ? useRafFn(cb, { immediate }) : useIntervalFn(cb, interval, { immediate });
-  if (exposeControls) {
-    return {
-      timestamp: ts,
-      ...controls
-    };
-  } else {
-    return ts;
-  }
+  if (exposeControls) return {
+    timestamp: ts,
+    ...controls
+  };
+  else return ts;
 }
 function useUrlSearchParams(mode = "history", options = {}) {
-  const {
-    initialValue = {},
-    removeNullishValues = true,
-    removeFalsyValues = false,
-    write: enableWrite = true,
-    writeMode = "replace",
-    window: window2 = defaultWindow,
-    stringify = (params) => params.toString()
-  } = options;
-  if (!window2)
-    return reactivity.reactive(initialValue);
+  const { initialValue = {}, removeNullishValues = true, removeFalsyValues = false, write: enableWrite = true, writeMode = "replace", window: window$1 = defaultWindow, stringify = (params) => params.toString() } = options;
+  if (!window$1) return reactivity.reactive(initialValue);
   const state = reactivity.reactive({});
   function getRawParams() {
-    if (mode === "history") {
-      return window2.location.search || "";
-    } else if (mode === "hash") {
-      const hash = window2.location.hash || "";
+    if (mode === "history") return window$1.location.search || "";
+    else if (mode === "hash") {
+      const hash = window$1.location.hash || "";
       const index = hash.indexOf("?");
       return index > 0 ? hash.slice(index) : "";
-    } else {
-      return (window2.location.hash || "").replace(/^#/, "");
-    }
+    } else return (window$1.location.hash || "").replace(/^#/, "");
   }
   function constructQuery(params) {
     const stringified = stringify(params);
-    if (mode === "history")
-      return `${stringified ? `?${stringified}` : ""}${window2.location.hash || ""}`;
-    if (mode === "hash-params")
-      return `${window2.location.search || ""}${stringified ? `#${stringified}` : ""}`;
-    const hash = window2.location.hash || "#";
+    if (mode === "history") return `${stringified ? `?${stringified}` : ""}${window$1.location.hash || ""}`;
+    if (mode === "hash-params") return `${window$1.location.search || ""}${stringified ? `#${stringified}` : ""}`;
+    const hash = window$1.location.hash || "#";
     const index = hash.indexOf("?");
-    if (index > 0)
-      return `${window2.location.search || ""}${hash.slice(0, index)}${stringified ? `?${stringified}` : ""}`;
-    return `${window2.location.search || ""}${hash}${stringified ? `?${stringified}` : ""}`;
+    if (index > 0) return `${window$1.location.search || ""}${hash.slice(0, index)}${stringified ? `?${stringified}` : ""}`;
+    return `${window$1.location.search || ""}${hash}${stringified ? `?${stringified}` : ""}`;
   }
   function read() {
     return new URLSearchParams(getRawParams());
@@ -3056,79 +2691,43 @@ function useUrlSearchParams(mode = "history", options = {}) {
     }
     Array.from(unusedKeys).forEach((key) => delete state[key]);
   }
-  const { pause, resume } = watchPausable(
-    state,
-    () => {
-      const params = new URLSearchParams("");
-      Object.keys(state).forEach((key) => {
-        const mapEntry = state[key];
-        if (Array.isArray(mapEntry))
-          mapEntry.forEach((value) => params.append(key, value));
-        else if (removeNullishValues && mapEntry == null)
-          params.delete(key);
-        else if (removeFalsyValues && !mapEntry)
-          params.delete(key);
-        else
-          params.set(key, mapEntry);
-      });
-      write(params, false);
-    },
-    { deep: true }
-  );
+  const { pause, resume } = pausableWatch(state, () => {
+    const params = new URLSearchParams("");
+    Object.keys(state).forEach((key) => {
+      const mapEntry = state[key];
+      if (Array.isArray(mapEntry)) mapEntry.forEach((value) => params.append(key, value));
+      else if (removeNullishValues && mapEntry == null) params.delete(key);
+      else if (removeFalsyValues && !mapEntry) params.delete(key);
+      else params.set(key, mapEntry);
+    });
+    write(params, false);
+  }, { deep: true });
   function write(params, shouldUpdate, shouldWriteHistory = true) {
     pause();
-    if (shouldUpdate)
-      updateState(params);
-    if (writeMode === "replace") {
-      window2.history.replaceState(
-        window2.history.state,
-        window2.document.title,
-        window2.location.pathname + constructQuery(params)
-      );
-    } else {
-      if (shouldWriteHistory) {
-        window2.history.pushState(
-          window2.history.state,
-          window2.document.title,
-          window2.location.pathname + constructQuery(params)
-        );
-      }
-    }
+    if (shouldUpdate) updateState(params);
+    if (writeMode === "replace") window$1.history.replaceState(window$1.history.state, window$1.document.title, window$1.location.pathname + constructQuery(params));
+    else if (shouldWriteHistory) window$1.history.pushState(window$1.history.state, window$1.document.title, window$1.location.pathname + constructQuery(params));
     reactivity.nextTick(() => resume());
   }
   function onChanged() {
-    if (!enableWrite)
-      return;
+    if (!enableWrite) return;
     write(read(), true, false);
   }
   const listenerOptions = { passive: true };
-  useEventListener(window2, "popstate", onChanged, listenerOptions);
-  if (mode !== "history")
-    useEventListener(window2, "hashchange", onChanged, listenerOptions);
+  useEventListener(window$1, "popstate", onChanged, listenerOptions);
+  if (mode !== "history") useEventListener(window$1, "hashchange", onChanged, listenerOptions);
   const initial = read();
-  if (initial.keys().next().value)
-    updateState(initial);
-  else
-    Object.assign(state, initialValue);
+  if (initial.keys().next().value) updateState(initial);
+  else Object.assign(state, initialValue);
   return state;
 }
 const DEFAULT_PING_MESSAGE = "ping";
 function resolveNestedOptions(options) {
-  if (options === true)
-    return {};
+  if (options === true) return {};
   return options;
 }
 function useWebSocket(url, options = {}) {
-  const {
-    onConnected,
-    onDisconnected,
-    onError,
-    onMessage,
-    immediate = true,
-    autoConnect = true,
-    autoClose = true,
-    protocols = []
-  } = options;
+  const { onConnected, onDisconnected, onError, onMessage, immediate = true, autoConnect = true, autoClose = true, protocols = [] } = options;
   const data = reactivity.ref(null);
   const status = reactivity.shallowRef("CLOSED");
   const wsRef = reactivity.ref();
@@ -3142,8 +2741,7 @@ function useWebSocket(url, options = {}) {
   let pongTimeoutWait;
   const _sendBuffer = () => {
     if (bufferedData.length && wsRef.value && status.value === "OPEN") {
-      for (const buffer of bufferedData)
-        wsRef.value.send(buffer);
+      for (const buffer of bufferedData) wsRef.value.send(buffer);
       bufferedData = [];
     }
   };
@@ -3159,113 +2757,87 @@ function useWebSocket(url, options = {}) {
   };
   const close = (code = 1e3, reason) => {
     resetRetry();
-    if (!isClient && !isWorker || !wsRef.value)
-      return;
+    if (!isClient && !isWorker || !wsRef.value) return;
     explicitlyClosed = true;
     resetHeartbeat();
-    heartbeatPause == null ? void 0 : heartbeatPause();
+    heartbeatPause === null || heartbeatPause === void 0 || heartbeatPause();
     wsRef.value.close(code, reason);
     wsRef.value = void 0;
   };
-  const send = (data2, useBuffer = true) => {
+  const send = (data$1, useBuffer = true) => {
     if (!wsRef.value || status.value !== "OPEN") {
-      if (useBuffer)
-        bufferedData.push(data2);
+      if (useBuffer) bufferedData.push(data$1);
       return false;
     }
     _sendBuffer();
-    wsRef.value.send(data2);
+    wsRef.value.send(data$1);
     return true;
   };
   const _init = () => {
-    if (explicitlyClosed || typeof urlRef.value === "undefined")
-      return;
+    if (explicitlyClosed || typeof urlRef.value === "undefined") return;
     const ws = new WebSocket(urlRef.value, protocols);
     wsRef.value = ws;
     status.value = "CONNECTING";
     ws.onopen = () => {
       status.value = "OPEN";
       retried = 0;
-      onConnected == null ? void 0 : onConnected(ws);
-      heartbeatResume == null ? void 0 : heartbeatResume();
+      onConnected === null || onConnected === void 0 || onConnected(ws);
+      heartbeatResume === null || heartbeatResume === void 0 || heartbeatResume();
       _sendBuffer();
     };
     ws.onclose = (ev) => {
       status.value = "CLOSED";
       resetHeartbeat();
-      heartbeatPause == null ? void 0 : heartbeatPause();
-      onDisconnected == null ? void 0 : onDisconnected(ws, ev);
+      heartbeatPause === null || heartbeatPause === void 0 || heartbeatPause();
+      onDisconnected === null || onDisconnected === void 0 || onDisconnected(ws, ev);
       if (!explicitlyClosed && options.autoReconnect && (wsRef.value == null || ws === wsRef.value)) {
-        const {
-          retries = -1,
-          delay = 1e3,
-          onFailed
-        } = resolveNestedOptions(options.autoReconnect);
-        const checkRetires = typeof retries === "function" ? retries : () => typeof retries === "number" && (retries < 0 || retried < retries);
-        if (checkRetires(retried)) {
+        const { retries = -1, delay = 1e3, onFailed } = resolveNestedOptions(options.autoReconnect);
+        if ((typeof retries === "function" ? retries : () => typeof retries === "number" && (retries < 0 || retried < retries))(retried)) {
           retried += 1;
-          retryTimeout = setTimeout(_init, delay);
-        } else {
-          onFailed == null ? void 0 : onFailed();
-        }
+          const delayTime = typeof delay === "function" ? delay(retried) : delay;
+          retryTimeout = setTimeout(_init, delayTime);
+        } else onFailed === null || onFailed === void 0 || onFailed();
       }
     };
     ws.onerror = (e) => {
-      onError == null ? void 0 : onError(ws, e);
+      onError === null || onError === void 0 || onError(ws, e);
     };
     ws.onmessage = (e) => {
       if (options.heartbeat) {
         resetHeartbeat();
-        const {
-          message = DEFAULT_PING_MESSAGE,
-          responseMessage = message
-        } = resolveNestedOptions(options.heartbeat);
-        if (e.data === reactivity.toValue(responseMessage))
-          return;
+        const { message = DEFAULT_PING_MESSAGE, responseMessage = message } = resolveNestedOptions(options.heartbeat);
+        if (e.data === reactivity.toValue(responseMessage)) return;
       }
       data.value = e.data;
-      onMessage == null ? void 0 : onMessage(ws, e);
+      onMessage === null || onMessage === void 0 || onMessage(ws, e);
     };
   };
   if (options.heartbeat) {
-    const {
-      message = DEFAULT_PING_MESSAGE,
-      interval = 1e3,
-      pongTimeout = 1e3
-    } = resolveNestedOptions(options.heartbeat);
-    const { pause, resume } = useIntervalFn(
-      () => {
-        send(reactivity.toValue(message), false);
-        if (pongTimeoutWait != null)
-          return;
-        pongTimeoutWait = setTimeout(() => {
-          close();
-          explicitlyClosed = false;
-        }, pongTimeout);
-      },
-      interval,
-      { immediate: false }
-    );
+    const { message = DEFAULT_PING_MESSAGE, interval = 1e3, pongTimeout = 1e3 } = resolveNestedOptions(options.heartbeat);
+    const { pause, resume } = useIntervalFn(() => {
+      send(reactivity.toValue(message), false);
+      if (pongTimeoutWait != null) return;
+      pongTimeoutWait = setTimeout(() => {
+        close();
+        explicitlyClosed = false;
+      }, pongTimeout);
+    }, interval, { immediate: false });
     heartbeatPause = pause;
     heartbeatResume = resume;
   }
   if (autoClose) {
-    if (isClient)
-      useEventListener("beforeunload", () => close(), { passive: true });
+    if (isClient) useEventListener("beforeunload", () => close(), { passive: true });
     tryOnScopeDispose(close);
   }
   const open = () => {
-    if (!isClient && !isWorker)
-      return;
+    if (!isClient && !isWorker) return;
     close();
     explicitlyClosed = false;
     retried = 0;
     _init();
   };
-  if (immediate)
-    open();
-  if (autoConnect)
-    reactivity.watch(urlRef, open);
+  if (immediate) open();
+  if (autoConnect) reactivity.watch(urlRef, open);
   return {
     data,
     status,
@@ -3276,21 +2848,17 @@ function useWebSocket(url, options = {}) {
   };
 }
 function depsParser(deps, localDeps) {
-  if (deps.length === 0 && localDeps.length === 0)
-    return "";
+  if (deps.length === 0 && localDeps.length === 0) return "";
   const depsString = deps.map((dep) => `'${dep}'`).toString();
   const depsFunctionString = localDeps.filter((dep) => typeof dep === "function").map((fn) => {
     const str = fn.toString();
-    if (str.trim().startsWith("function")) {
-      return str;
-    } else {
-      const name = fn.name;
-      return `const ${name} = ${str}`;
-    }
+    if (str.trim().startsWith("function")) return str;
+    else return `const ${fn.name} = ${str}`;
   }).join(";");
   const importString = `importScripts(${depsString});`;
   return `${depsString.trim() === "" ? "" : importString} ${depsFunctionString}`;
 }
+var depsParser_default = depsParser;
 function jobRunner(userFunc) {
   return (e) => {
     const userFuncArgs = e.data[0];
@@ -3301,37 +2869,33 @@ function jobRunner(userFunc) {
     });
   };
 }
+var jobRunner_default = jobRunner;
 function createWorkerBlobUrl(fn, deps, localDeps) {
-  const blobCode = `${depsParser(deps, localDeps)}; onmessage=(${jobRunner})(${fn})`;
+  const blobCode = `${depsParser_default(deps, localDeps)}; onmessage=(${jobRunner_default})(${fn})`;
   const blob = new Blob([blobCode], { type: "text/javascript" });
-  const url = URL.createObjectURL(blob);
-  return url;
+  return URL.createObjectURL(blob);
 }
+var createWorkerBlobUrl_default = createWorkerBlobUrl;
 function useWebWorkerFn(fn, options = {}) {
-  const {
-    dependencies = [],
-    localDependencies = [],
-    timeout,
-    window: window2 = defaultWindow
-  } = options;
+  const { dependencies = [], localDependencies = [], timeout, window: window$1 = defaultWindow } = options;
   const worker = reactivity.ref();
   const workerStatus = reactivity.shallowRef("PENDING");
   const promise = reactivity.ref({});
   const timeoutId = reactivity.shallowRef();
   const workerTerminate = (status = "PENDING") => {
-    if (worker.value && worker.value._url && window2) {
+    if (worker.value && worker.value._url && window$1) {
       worker.value.terminate();
       URL.revokeObjectURL(worker.value._url);
       promise.value = {};
       worker.value = void 0;
-      window2.clearTimeout(timeoutId.value);
+      window$1.clearTimeout(timeoutId.value);
       workerStatus.value = status;
     }
   };
   workerTerminate();
   tryOnScopeDispose(workerTerminate);
   const generateWorker = () => {
-    const blobUrl = createWorkerBlobUrl(fn, dependencies, localDependencies);
+    const blobUrl = createWorkerBlobUrl_default(fn, dependencies, localDependencies);
     const newWorker = new Worker(blobUrl);
     newWorker._url = blobUrl;
     newWorker.onmessage = (e) => {
@@ -3357,28 +2921,21 @@ function useWebWorkerFn(fn, options = {}) {
       reject(e);
       workerTerminate("ERROR");
     };
-    if (timeout) {
-      timeoutId.value = setTimeout(
-        () => workerTerminate("TIMEOUT_EXPIRED"),
-        timeout
-      );
-    }
+    if (timeout) timeoutId.value = setTimeout(() => workerTerminate("TIMEOUT_EXPIRED"), timeout);
     return newWorker;
   };
   const callWorker = (...fnArgs) => new Promise((resolve, reject) => {
-    var _a;
+    var _worker$value;
     promise.value = {
       resolve,
       reject
     };
-    (_a = worker.value) == null ? void 0 : _a.postMessage([[...fnArgs]]);
+    (_worker$value = worker.value) === null || _worker$value === void 0 || _worker$value.postMessage([[...fnArgs]]);
     workerStatus.value = "RUNNING";
   });
   const workerFn = (...fnArgs) => {
     if (workerStatus.value === "RUNNING") {
-      console.error(
-        "[useWebWorkerFn] You can only run one instance of the worker at a time."
-      );
+      console.error("[useWebWorkerFn] You can only run one instance of the worker at a time.");
       return Promise.reject();
     }
     worker.value = generateWorker();
@@ -3391,28 +2948,32 @@ function useWebWorkerFn(fn, options = {}) {
   };
 }
 exports.assert = assert;
-exports.asyncComputed = computedAsync;
-exports.autoResetRef = refAutoReset;
+exports.asyncComputed = asyncComputed;
+exports.autoResetRef = autoResetRef;
 exports.bypassFilter = bypassFilter;
 exports.camelize = camelize;
 exports.clamp = clamp;
 exports.cloneFnJSON = cloneFnJSON;
 exports.computedAsync = computedAsync;
+exports.computedEager = computedEager;
 exports.computedWithControl = computedWithControl;
 exports.containsProp = containsProp;
-exports.controlledComputed = computedWithControl;
+exports.controlledComputed = controlledComputed;
 exports.controlledRef = controlledRef;
 exports.createEventHook = createEventHook;
 exports.createFetch = createFetch;
 exports.createFilterWrapper = createFilterWrapper;
 exports.createGlobalState = createGlobalState;
-exports.createReactiveFn = reactify;
+exports.createInjectionState = createInjectionState;
+exports.createReactiveFn = createReactiveFn;
+exports.createRef = createRef;
 exports.createSharedComposable = createSharedComposable;
 exports.createSingletonPromise = createSingletonPromise;
 exports.createUnrefFn = createUnrefFn;
 exports.debounceFilter = debounceFilter;
-exports.debouncedRef = refDebounced;
-exports.debouncedWatch = watchDebounced;
+exports.debouncedRef = debouncedRef;
+exports.debouncedWatch = debouncedWatch;
+exports.eagerComputed = eagerComputed;
 exports.extendRef = extendRef;
 exports.formatDate = formatDate;
 exports.formatTimeAgo = formatTimeAgo;
@@ -3421,8 +2982,9 @@ exports.getLifeCycleTarget = getLifeCycleTarget;
 exports.hasOwn = hasOwn;
 exports.hyphenate = hyphenate;
 exports.identity = identity;
-exports.ignorableWatch = watchIgnorable;
+exports.ignorableWatch = ignorableWatch;
 exports.increaseWithUnit = increaseWithUnit;
+exports.injectLocal = injectLocal;
 exports.invoke = invoke;
 exports.isDef = isDef;
 exports.isDefined = isDefined;
@@ -3436,8 +2998,10 @@ exports.objectEntries = objectEntries;
 exports.objectOmit = objectOmit;
 exports.objectPick = objectPick;
 exports.pausableFilter = pausableFilter;
-exports.pausableWatch = watchPausable;
+exports.pausableWatch = pausableWatch;
 exports.promiseTimeout = promiseTimeout;
+exports.provideLocal = provideLocal;
+exports.pxValue = pxValue;
 exports.rand = rand;
 exports.reactify = reactify;
 exports.reactifyObject = reactifyObject;
@@ -3447,21 +3011,25 @@ exports.reactivePick = reactivePick;
 exports.refAutoReset = refAutoReset;
 exports.refDebounced = refDebounced;
 exports.refDefault = refDefault;
+exports.refManualReset = refManualReset;
 exports.refThrottled = refThrottled;
 exports.refWithControl = refWithControl;
-exports.resolveRef = resolveRef;
-exports.resolveUnref = resolveUnref;
 exports.set = set;
 exports.syncRef = syncRef;
 exports.syncRefs = syncRefs;
 exports.throttleFilter = throttleFilter;
-exports.throttledRef = refThrottled;
-exports.throttledWatch = watchThrottled;
+exports.throttledRef = throttledRef;
+exports.throttledWatch = throttledWatch;
+exports.timestamp = timestamp;
+exports.toArray = toArray;
 exports.toReactive = toReactive;
 exports.toRef = toRef;
 exports.toRefs = toRefs;
-exports.toValue = toValue;
+exports.tryOnBeforeMount = tryOnBeforeMount;
+exports.tryOnBeforeUnmount = tryOnBeforeUnmount;
+exports.tryOnMounted = tryOnMounted;
 exports.tryOnScopeDispose = tryOnScopeDispose;
+exports.tryOnUnmounted = tryOnUnmounted;
 exports.until = until;
 exports.useArrayDifference = useArrayDifference;
 exports.useArrayEvery = useArrayEvery;
@@ -3484,7 +3052,7 @@ exports.useCloned = useCloned;
 exports.useCounter = useCounter;
 exports.useCycleList = useCycleList;
 exports.useDateFormat = useDateFormat;
-exports.useDebounce = refDebounced;
+exports.useDebounce = useDebounce;
 exports.useDebounceFn = useDebounceFn;
 exports.useDebouncedRefHistory = useDebouncedRefHistory;
 exports.useEventBus = useEventBus;
@@ -3501,7 +3069,7 @@ exports.usePrevious = usePrevious;
 exports.useRefHistory = useRefHistory;
 exports.useSorted = useSorted;
 exports.useStepper = useStepper;
-exports.useThrottle = refThrottled;
+exports.useThrottle = useThrottle;
 exports.useThrottleFn = useThrottleFn;
 exports.useThrottledRefHistory = useThrottledRefHistory;
 exports.useTimeAgo = useTimeAgo;