@reactive-vscode/vueuse 0.3.1 → 0.3.3

package/dist/index.cjs

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const reactivity = require("@reactive-vscode/reactivity");
-function computedWithControl(source, fn) {
+function computedWithControl(source, fn, options = {}) {
   let v = void 0;
   let track;
   let trigger;
-  const dirty = reactivity.shallowRef(true);
+  let dirty = true;
   const update = () => {
-    dirty.value = true;
+    dirty = true;
     trigger();
   };
-  reactivity.watch(source, update, { flush: "sync" });
+  reactivity.watch(source, update, { flush: "sync", ...options });
   const get2 = typeof fn === "function" ? fn : fn.get;
   const set2 = typeof fn === "function" ? void 0 : fn.set;
   const result = reactivity.customRef((_track, _trigger) => {
@@ -18,9 +18,9 @@ function computedWithControl(source, fn) {
     trigger = _trigger;
     return {
       get() {
-        if (dirty.value) {
+        if (dirty) {
           v = get2(v);
-          dirty.value = false;
+          dirty = false;
         }
         track();
         return v;
@@ -30,8 +30,7 @@ function computedWithControl(source, fn) {
       }
     };
   });
-  if (Object.isExtensible(result))
-    result.trigger = update;
+  result.trigger = update;
   return result;
 }
 function tryOnScopeDispose(fn) {
@@ -41,6 +40,7 @@ function tryOnScopeDispose(fn) {
   }
   return false;
 }
+// @__NO_SIDE_EFFECTS__
 function createEventHook() {
   const fns = /* @__PURE__ */ new Set();
   const off = (fn) => {
@@ -67,6 +67,7 @@ function createEventHook() {
     clear
   };
 }
+// @__NO_SIDE_EFFECTS__
 function createGlobalState(stateFactory) {
   let initialized = false;
   let state;
@@ -79,6 +80,7 @@ function createGlobalState(stateFactory) {
     return state;
   };
 }
+// @__NO_SIDE_EFFECTS__
 function createRef(value, deep) {
   if (deep === true) {
     return reactivity.ref(value);
@@ -86,6 +88,7 @@ function createRef(value, deep) {
     return reactivity.shallowRef(value);
   }
 }
+// @__NO_SIDE_EFFECTS__
 function createSharedComposable(composable) {
   let subscribers = 0;
   let state;
@@ -136,6 +139,7 @@ function get(obj, key) {
 function isDefined(v) {
   return reactivity.unref(v) != null;
 }
+// @__NO_SIDE_EFFECTS__
 function makeDestructurable(obj, arr) {
   if (typeof Symbol !== "undefined") {
     const clone = { ...obj };
@@ -156,12 +160,14 @@ function makeDestructurable(obj, arr) {
     return Object.assign([...arr], obj);
   }
 }
+// @__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;
@@ -179,7 +185,7 @@ function reactifyObject(obj, optionsOrKeys = {}) {
       const value = obj[key];
       return [
         key,
-        typeof value === "function" ? reactify(value.bind(obj), options) : value
+        typeof value === "function" ? /* @__PURE__ */ reactify(value.bind(obj), options) : value
       ];
     })
   );
@@ -245,6 +251,43 @@ const rand = (min, max) => {
   return Math.floor(Math.random() * (max - min + 1)) + min;
 };
 const hasOwn = (val, key) => Object.prototype.hasOwnProperty.call(val, key);
+function 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();
+      }
+    };
+  });
+}
 function createFilterWrapper(filter, fn) {
   function wrapper(...args) {
     return new Promise((resolve, reject) => {
@@ -274,7 +317,7 @@ function debounceFilter(ms, options = {}) {
     if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
       if (maxTimer) {
         _clearTimeout(maxTimer);
-        maxTimer = null;
+        maxTimer = void 0;
       }
       return Promise.resolve(invoke2());
     }
@@ -285,14 +328,14 @@ function debounceFilter(ms, options = {}) {
         maxTimer = setTimeout(() => {
           if (timer)
             _clearTimeout(timer);
-          maxTimer = null;
+          maxTimer = void 0;
           resolve(lastInvoker());
         }, maxDuration);
       }
       timer = setTimeout(() => {
         if (maxTimer)
           _clearTimeout(maxTimer);
-        maxTimer = null;
+        maxTimer = void 0;
         resolve(invoke2());
       }, duration);
     });
@@ -370,19 +413,6 @@ function pausableFilter(extendFilter = bypassFilter, options = {}) {
   };
   return { isActive: reactivity.readonly(isActive), pause, resume, eventFilter };
 }
-function cacheStringFunction(fn) {
-  const cache = /* @__PURE__ */ Object.create(null);
-  return (str) => {
-    const hit = cache[str];
-    return hit || (cache[str] = fn(str));
-  };
-}
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
-const camelizeRE = /-(\w)/g;
-const camelize = cacheStringFunction((str) => {
-  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
-});
 function promiseTimeout(ms, throwOnTimeout = false, reason = "Timeout") {
   return new Promise((resolve, reject) => {
     if (throwOnTimeout)
@@ -443,49 +473,26 @@ function objectOmit(obj, keys, omitUndefined = false) {
 function objectEntries(obj) {
   return Object.entries(obj);
 }
-function getLifeCycleTarget(target) {
-  return target || null;
-}
 function toArray(value) {
   return Array.isArray(value) ? value : [value];
 }
-function 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 cacheStringFunction(fn) {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return (str) => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  };
 }
-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 hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
+const camelizeRE = /-(\w)/g;
+const camelize = cacheStringFunction((str) => {
+  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
+});
+function getLifeCycleTarget(target) {
+  return target || null;
 }
+// @__NO_SIDE_EFFECTS__
 function useDebounceFn(fn, ms = 200, options = {}) {
   return createFilterWrapper(
     debounceFilter(ms, options),
@@ -493,13 +500,14 @@ function useDebounceFn(fn, ms = 200, options = {}) {
   );
 }
 function refDebounced(value, ms = 200, options = {}) {
-  const debounced = reactivity.ref(value.value);
-  const updater = useDebounceFn(() => {
+  const debounced = reactivity.ref(reactivity.toValue(value));
+  const updater = /* @__PURE__ */ useDebounceFn(() => {
     debounced.value = value.value;
   }, ms, options);
   reactivity.watch(value, () => updater());
-  return debounced;
+  return reactivity.shallowReadonly(debounced);
 }
+// @__NO_SIDE_EFFECTS__
 function refDefault(source, defaultValue) {
   return reactivity.computed({
     get() {
@@ -511,6 +519,7 @@ function refDefault(source, defaultValue) {
     }
   });
 }
+// @__NO_SIDE_EFFECTS__
 function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
   return createFilterWrapper(
     throttleFilter(ms, trailing, leading, rejectOnCancel),
@@ -520,13 +529,14 @@ function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnC
 function refThrottled(value, delay = 200, trailing = true, leading = true) {
   if (delay <= 0)
     return value;
-  const throttled = reactivity.ref(value.value);
-  const updater = useThrottleFn(() => {
+  const throttled = reactivity.ref(reactivity.toValue(value));
+  const updater = /* @__PURE__ */ useThrottleFn(() => {
     throttled.value = value.value;
   }, delay, trailing, leading);
   reactivity.watch(value, () => updater());
   return throttled;
 }
+// @__NO_SIDE_EFFECTS__
 function refWithControl(initial, options = {}) {
   let source = initial;
   let track;
@@ -703,7 +713,10 @@ function toRefs(objectRef, options = {}) {
 const toValue = reactivity.toValue;
 const resolveUnref = reactivity.toValue;
 function tryOnMounted(fn, sync = true, target) {
-  if (sync)
+  const instance = getLifeCycleTarget(target);
+  if (instance)
+    ;
+  else if (sync)
     fn();
   else
     reactivity.nextTick(fn);
@@ -835,6 +848,7 @@ function until(r) {
 function defaultComparator(value, othVal) {
   return value === othVal;
 }
+// @__NO_SIDE_EFFECTS__
 function useArrayDifference(...args) {
   var _a, _b;
   const list = args[0];
@@ -855,17 +869,21 @@ function useArrayDifference(...args) {
     return diff1;
   }
 }
+// @__NO_SIDE_EFFECTS__
 function useArrayEvery(list, fn) {
   return reactivity.computed(() => reactivity.toValue(list).every((element, index, array) => fn(reactivity.toValue(element), index, array)));
 }
+// @__NO_SIDE_EFFECTS__
 function useArrayFilter(list, fn) {
   return reactivity.computed(() => reactivity.toValue(list).map((i) => reactivity.toValue(i)).filter(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))
   ));
 }
+// @__NO_SIDE_EFFECTS__
 function useArrayFindIndex(list, fn) {
   return reactivity.computed(() => reactivity.toValue(list).findIndex((element, index, array) => fn(reactivity.toValue(element), index, array)));
 }
@@ -877,6 +895,7 @@ function findLast(arr, cb) {
   }
   return void 0;
 }
+// @__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))
@@ -885,6 +904,7 @@ function useArrayFindLast(list, fn) {
 function isArrayIncludesOptions(obj) {
   return isObject(obj) && containsProp(obj, "formIndex", "comparator");
 }
+// @__NO_SIDE_EFFECTS__
 function useArrayIncludes(...args) {
   var _a;
   const list = args[0];
@@ -907,12 +927,15 @@ function useArrayIncludes(...args) {
     reactivity.toValue(array)
   )));
 }
+// @__NO_SIDE_EFFECTS__
 function useArrayJoin(list, separator) {
   return reactivity.computed(() => reactivity.toValue(list).map((i) => reactivity.toValue(i)).join(reactivity.toValue(separator)));
 }
+// @__NO_SIDE_EFFECTS__
 function useArrayMap(list, fn) {
   return reactivity.computed(() => reactivity.toValue(list).map((i) => reactivity.toValue(i)).map(fn));
 }
+// @__NO_SIDE_EFFECTS__
 function useArrayReduce(list, reducer, ...args) {
   const reduceCallback = (sum, value, index) => reducer(reactivity.toValue(sum), reactivity.toValue(value), index);
   return reactivity.computed(() => {
@@ -920,6 +943,7 @@ function useArrayReduce(list, reducer, ...args) {
     return args.length ? resolved.reduce(reduceCallback, typeof args[0] === "function" ? reactivity.toValue(args[0]()) : reactivity.toValue(args[0])) : resolved.reduce(reduceCallback);
   });
 }
+// @__NO_SIDE_EFFECTS__
 function useArraySome(list, fn) {
   return reactivity.computed(() => reactivity.toValue(list).some((element, index, array) => fn(reactivity.toValue(element), index, array)));
 }
@@ -933,6 +957,7 @@ function uniqueElementsBy(array, fn) {
     return acc;
   }, []);
 }
+// @__NO_SIDE_EFFECTS__
 function useArrayUnique(list, compareFn) {
   return reactivity.computed(() => {
     const resolvedList = reactivity.toValue(list).map((element) => reactivity.toValue(element));
@@ -954,7 +979,7 @@ function useCounter(initialValue = 0, options = {}) {
     _initialValue = val;
     return set2(val);
   };
-  return { count, inc, dec, get: get2, set: set2, 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;
@@ -1044,6 +1069,7 @@ function normalizeDate(date) {
   }
   return new Date(date);
 }
+// @__NO_SIDE_EFFECTS__
 function useDateFormat(date, formatStr = "HH:mm:ss", options = {}) {
   return reactivity.computed(() => formatDate(normalizeDate(reactivity.toValue(date)), reactivity.toValue(formatStr), options));
 }
@@ -1086,7 +1112,7 @@ function useIntervalFn(cb, interval = 1e3, options = {}) {
   }
   tryOnScopeDispose(pause);
   return {
-    isActive,
+    isActive: reactivity.shallowReadonly(isActive),
     pause,
     resume
   };
@@ -1112,12 +1138,12 @@ function useInterval(interval = 1e3, options = {}) {
   );
   if (exposeControls) {
     return {
-      counter,
+      counter: reactivity.shallowReadonly(counter),
       reset,
       ...controls
     };
   } else {
-    return counter;
+    return reactivity.shallowReadonly(counter);
   }
 }
 function useLastChanged(source, options = {}) {
@@ -1128,7 +1154,7 @@ function useLastChanged(source, options = {}) {
     () => ms.value = timestamp(),
     options
   );
-  return ms;
+  return reactivity.shallowReadonly(ms);
 }
 function useTimeoutFn(cb, interval, options = {}) {
   const {
@@ -1136,11 +1162,11 @@ function useTimeoutFn(cb, interval, options = {}) {
     immediateCallback = false
   } = options;
   const isPending = reactivity.shallowRef(false);
-  let timer = null;
+  let timer;
   function clear() {
     if (timer) {
       clearTimeout(timer);
-      timer = null;
+      timer = void 0;
     }
   }
   function stop() {
@@ -1154,7 +1180,7 @@ function useTimeoutFn(cb, interval, options = {}) {
     isPending.value = true;
     timer = setTimeout(() => {
       isPending.value = false;
-      timer = null;
+      timer = void 0;
       cb(...args);
     }, reactivity.toValue(interval));
   }
@@ -1165,7 +1191,7 @@ function useTimeoutFn(cb, interval, options = {}) {
   }
   tryOnScopeDispose(stop);
   return {
-    isPending: reactivity.readonly(isPending),
+    isPending: reactivity.shallowReadonly(isPending),
     start,
     stop
   };
@@ -1190,6 +1216,7 @@ function useTimeout(interval = 1e3, options = {}) {
     return ready;
   }
 }
+// @__NO_SIDE_EFFECTS__
 function useToNumber(value, options = {}) {
   const {
     method = "parseFloat",
@@ -1207,9 +1234,11 @@ function useToNumber(value, options = {}) {
     return resolved;
   });
 }
+// @__NO_SIDE_EFFECTS__
 function useToString(value) {
   return reactivity.computed(() => `${reactivity.toValue(value)}`);
 }
+// @__NO_SIDE_EFFECTS__
 function useToggle(initialValue = false, options = {}) {
   const {
     truthyValue = true,
@@ -1310,50 +1339,50 @@ function watchIgnorable(source, cb, options = {}) {
   let ignorePrevAsyncUpdates;
   let stop;
   if (watchOptions.flush === "sync") {
-    const ignore = reactivity.shallowRef(false);
+    let ignore = false;
     ignorePrevAsyncUpdates = () => {
     };
     ignoreUpdates = (updater) => {
-      ignore.value = true;
+      ignore = true;
       updater();
-      ignore.value = false;
+      ignore = false;
     };
     stop = reactivity.watch(
       source,
       (...args) => {
-        if (!ignore.value)
+        if (!ignore)
           filteredCb(...args);
       },
       watchOptions
     );
   } else {
     const disposables = [];
-    const ignoreCounter = reactivity.shallowRef(0);
-    const syncCounter = reactivity.shallowRef(0);
+    let ignoreCounter = 0;
+    let syncCounter = 0;
     ignorePrevAsyncUpdates = () => {
-      ignoreCounter.value = syncCounter.value;
+      ignoreCounter = syncCounter;
     };
     disposables.push(
       reactivity.watch(
         source,
         () => {
-          syncCounter.value++;
+          syncCounter++;
         },
         { ...watchOptions, flush: "sync" }
       )
     );
     ignoreUpdates = (updater) => {
-      const syncCounterPrev = syncCounter.value;
+      const syncCounterPrev = syncCounter;
       updater();
-      ignoreCounter.value += syncCounter.value - syncCounterPrev;
+      ignoreCounter += syncCounter - syncCounterPrev;
     };
     disposables.push(
       reactivity.watch(
         source,
         (...args) => {
-          const ignore = ignoreCounter.value > 0 && ignoreCounter.value === syncCounter.value;
-          ignoreCounter.value = 0;
-          syncCounter.value = 0;
+          const ignore = ignoreCounter > 0 && ignoreCounter === syncCounter;
+          ignoreCounter = 0;
+          syncCounter = 0;
           if (ignore)
             return;
           filteredCb(...args);
@@ -1378,11 +1407,14 @@ function watchImmediate(source, cb, options) {
   );
 }
 function watchOnce(source, cb, options) {
-  const stop = reactivity.watch(source, (...args) => {
-    reactivity.nextTick(() => stop());
-    return cb(...args);
-  }, options);
-  return stop;
+  return reactivity.watch(
+    source,
+    cb,
+    {
+      ...options,
+      once: true
+    }
+  );
 }
 function watchThrottled(source, cb, options = {}) {
   const {
@@ -1458,6 +1490,7 @@ function whenever(source, cb, options) {
   return stop;
 }
 function computedAsync(evaluationCallback, initialState, optionsOrRef) {
+  var _a;
   let options;
   if (reactivity.isRef(optionsOrRef)) {
     options = {
@@ -1468,9 +1501,10 @@ function computedAsync(evaluationCallback, initialState, optionsOrRef) {
   }
   const {
     lazy = false,
+    flush = "pre",
     evaluating = void 0,
     shallow = true,
-    onError = noop
+    onError = (_a = globalThis.reportError) != null ? _a : noop
   } = options;
   const started = reactivity.shallowRef(!lazy);
   const current = shallow ? reactivity.shallowRef(initialState) : reactivity.ref(initialState);
@@ -1504,7 +1538,7 @@ function computedAsync(evaluationCallback, initialState, optionsOrRef) {
         evaluating.value = false;
       hasFinished = true;
     }
-  });
+  }, { flush });
   if (lazy) {
     return reactivity.computed(() => {
       started.value = true;
@@ -1514,6 +1548,7 @@ function computedAsync(evaluationCallback, initialState, optionsOrRef) {
     return current;
   }
 }
+// @__NO_SIDE_EFFECTS__
 function createUnrefFn(fn) {
   return function(...args) {
     return fn.apply(this, args.map((i) => reactivity.toValue(i)));
@@ -1572,12 +1607,14 @@ function useEventListener(...args) {
   tryOnScopeDispose(cleanup);
   return stop;
 }
+// @__NO_SIDE_EFFECTS__
 function useMounted() {
   const isMounted = reactivity.shallowRef(false);
   return isMounted;
 }
+// @__NO_SIDE_EFFECTS__
 function useSupported(callback) {
-  const isMounted = useMounted();
+  const isMounted = /* @__PURE__ */ useMounted();
   return reactivity.computed(() => {
     isMounted.value;
     return Boolean(callback());
@@ -1711,10 +1748,11 @@ function whenAborted(signal) {
   });
 }
 function useAsyncState(promise, initialState, options) {
+  var _a;
   const {
     immediate = true,
     delay = 0,
-    onError = noop,
+    onError = (_a = globalThis.reportError) != null ? _a : noop,
     onSuccess = noop,
     resetOnExecute = true,
     shallow = true,
@@ -1726,7 +1764,7 @@ function useAsyncState(promise, initialState, options) {
   const error = reactivity.shallowRef(void 0);
   async function execute(delay2 = 0, ...args) {
     if (resetOnExecute)
-      state.value = initialState;
+      state.value = reactivity.toValue(initialState);
     error.value = void 0;
     isReady.value = false;
     isLoading.value = true;
@@ -1756,7 +1794,8 @@ function useAsyncState(promise, initialState, options) {
     isReady,
     isLoading,
     error,
-    execute
+    execute,
+    executeImmediate: (...args) => execute(0, ...args)
   };
   function waitUntilIsLoaded() {
     return new Promise((resolve, reject) => {
@@ -1872,7 +1911,7 @@ function useBroadcastChannel(options) {
     name,
     window: window2 = defaultWindow
   } = options;
-  const isSupported = useSupported(() => window2 && "BroadcastChannel" in window2);
+  const isSupported = /* @__PURE__ */ useSupported(() => window2 && "BroadcastChannel" in window2);
   const isClosed = reactivity.shallowRef(false);
   const channel = reactivity.ref();
   const data = reactivity.ref();
@@ -1919,7 +1958,7 @@ function useBroadcastChannel(options) {
 }
 function useCached(refValue, comparator = (a, b) => a === b, options) {
   const { deepRefs = true, ...watchOptions } = options || {};
-  const cachedValue = createRef(refValue.value, deepRefs);
+  const cachedValue = /* @__PURE__ */ createRef(refValue.value, deepRefs);
   reactivity.watch(() => refValue.value, (value) => {
     if (!comparator(value, cachedValue.value))
       cachedValue.value = value;
@@ -2095,7 +2134,8 @@ function useRefHistory(source, options = {}) {
   const {
     deep = false,
     flush = "pre",
-    eventFilter
+    eventFilter,
+    shouldCommit = () => true
   } = options;
   const {
     eventFilter: composedFilter,
@@ -2103,6 +2143,7 @@ function useRefHistory(source, options = {}) {
     resume: resumeTracking,
     isActive: isTracking
   } = pausableFilter(eventFilter);
+  let lastRawValue = source.value;
   const {
     ignoreUpdates,
     ignorePrevAsyncUpdates,
@@ -2116,12 +2157,16 @@ function useRefHistory(source, options = {}) {
     ignorePrevAsyncUpdates();
     ignoreUpdates(() => {
       source2.value = value;
+      lastRawValue = value;
     });
   }
   const manualHistory = useManualRefHistory(source, { ...options, clone: options.clone || deep, setSource });
   const { clear, commit: manualCommit } = manualHistory;
   function commit() {
     ignorePrevAsyncUpdates();
+    if (!shouldCommit(lastRawValue, source.value))
+      return;
+    lastRawValue = source.value;
     manualCommit();
   }
   function resume(commitNow) {
@@ -2160,6 +2205,7 @@ function useDebouncedRefHistory(source, options = {}) {
   };
 }
 const events = /* @__PURE__ */ new Map();
+// @__NO_SIDE_EFFECTS__
 function useEventBus(key) {
   const scope = reactivity.getCurrentScope();
   function on(listener) {
@@ -2281,7 +2327,7 @@ function createFetch(config = {}) {
   return useFactoryFetch;
 }
 function useFetch(url, ...args) {
-  var _a;
+  var _a, _b;
   const supportsAbort = typeof AbortController === "function";
   let fetchOptions = {};
   let options = {
@@ -2306,13 +2352,13 @@ function useFetch(url, ...args) {
       options = { ...options, ...args[1] };
   }
   const {
-    fetch = (_a = defaultWindow) == null ? void 0 : _a.fetch,
+    fetch = (_b = (_a = defaultWindow) == null ? void 0 : _a.fetch) != null ? _b : globalThis == null ? void 0 : globalThis.fetch,
     initialData,
     timeout
   } = options;
-  const responseEvent = createEventHook();
-  const errorEvent = createEventHook();
-  const finallyEvent = createEventHook();
+  const responseEvent = /* @__PURE__ */ createEventHook();
+  const errorEvent = /* @__PURE__ */ createEventHook();
+  const finallyEvent = /* @__PURE__ */ createEventHook();
   const isFinished = reactivity.shallowRef(false);
   const isFetching = reactivity.shallowRef(false);
   const aborted = reactivity.shallowRef(false);
@@ -2323,9 +2369,9 @@ function useFetch(url, ...args) {
   const canAbort = reactivity.computed(() => supportsAbort && isFetching.value);
   let controller;
   let timer;
-  const abort = () => {
+  const abort = (reason) => {
     if (supportsAbort) {
-      controller == null ? void 0 : controller.abort();
+      controller == null ? void 0 : controller.abort(reason);
       controller = new AbortController();
       controller.signal.onabort = () => aborted.value = true;
       fetchOptions = {
@@ -2342,7 +2388,7 @@ function useFetch(url, ...args) {
     timer = useTimeoutFn(abort, timeout, { immediate: false });
   let executeCounter = 0;
   const execute = async (throwOnFailed = false) => {
-    var _a2, _b;
+    var _a2, _b2;
     abort();
     loading(true);
     error.value = null;
@@ -2391,7 +2437,7 @@ function useFetch(url, ...args) {
         ...context.options,
         headers: {
           ...headersToObject(defaultFetchOptions.headers),
-          ...headersToObject((_b = context.options) == null ? void 0 : _b.headers)
+          ...headersToObject((_b2 = context.options) == null ? void 0 : _b2.headers)
         }
       }
     ).then(async (fetchResponse) => {
@@ -2576,7 +2622,8 @@ function useIdle(timeout = oneMinute, options = {}) {
           onEvent();
       }, listenerOptions);
     }
-    reset();
+    if (!initialState)
+      reset();
   }
   return {
     idle,
@@ -2584,14 +2631,16 @@ function useIdle(timeout = oneMinute, options = {}) {
     reset
   };
 }
+// @__NO_SIDE_EFFECTS__
 function useNow(options = {}) {
   const {
     controls: exposeControls = false,
-    interval = "requestAnimationFrame"
+    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: true }) : useIntervalFn(update, interval, { immediate: true });
+  const controls = interval === "requestAnimationFrame" ? useRafFn(update, { immediate }) : useIntervalFn(update, interval, { immediate });
   if (exposeControls) {
     return {
       now: now2,
@@ -2620,6 +2669,7 @@ function useObjectUrl(object) {
   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)));
@@ -2642,12 +2692,12 @@ function useOffsetPagination(options) {
     onPageSizeChange = noop,
     onPageCountChange = noop
   } = options;
-  const currentPageSize = useClamp(pageSize, 1, Number.POSITIVE_INFINITY);
+  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 currentPage = useClamp(page, 1, pageCount);
+  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)) {
@@ -2730,6 +2780,7 @@ function useSorted(...args) {
   });
   return source;
 }
+// @__NO_SIDE_EFFECTS__
 function useStepper(steps, initialStep) {
   const stepsRef = reactivity.ref(steps);
   const stepNames = reactivity.computed(() => Array.isArray(stepsRef.value) ? stepsRef.value : Object.keys(stepsRef.value));
@@ -2837,12 +2888,13 @@ const DEFAULT_MESSAGES = {
 function DEFAULT_FORMATTER(date) {
   return date.toISOString().slice(0, 10);
 }
+// @__NO_SIDE_EFFECTS__
 function useTimeAgo(time, options = {}) {
   const {
     controls: exposeControls = false,
     updateInterval = 3e4
   } = options;
-  const { now: now2, ...controls } = useNow({ interval: updateInterval, controls: true });
+  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 {
@@ -2963,7 +3015,8 @@ function useUrlSearchParams(mode = "history", options = {}) {
     removeFalsyValues = false,
     write: enableWrite = true,
     writeMode = "replace",
-    window: window2 = defaultWindow
+    window: window2 = defaultWindow,
+    stringify = (params) => params.toString()
   } = options;
   if (!window2)
     return reactivity.reactive(initialValue);
@@ -2980,7 +3033,7 @@ function useUrlSearchParams(mode = "history", options = {}) {
     }
   }
   function constructQuery(params) {
-    const stringified = params.toString();
+    const stringified = stringify(params);
     if (mode === "history")
       return `${stringified ? `?${stringified}` : ""}${window2.location.hash || ""}`;
     if (mode === "hash-params")
@@ -3022,7 +3075,7 @@ function useUrlSearchParams(mode = "history", options = {}) {
     },
     { deep: true }
   );
-  function write(params, shouldUpdate) {
+  function write(params, shouldUpdate, shouldWriteHistory = true) {
     pause();
     if (shouldUpdate)
       updateState(params);
@@ -3033,18 +3086,20 @@ function useUrlSearchParams(mode = "history", options = {}) {
         window2.location.pathname + constructQuery(params)
       );
     } else {
-      window2.history.pushState(
-        window2.history.state,
-        window2.document.title,
-        window2.location.pathname + constructQuery(params)
-      );
+      if (shouldWriteHistory) {
+        window2.history.pushState(
+          window2.history.state,
+          window2.document.title,
+          window2.location.pathname + constructQuery(params)
+        );
+      }
     }
-    resume();
+    reactivity.nextTick(() => resume());
   }
   function onChanged() {
     if (!enableWrite)
       return;
-    write(read(), true);
+    write(read(), true, false);
   }
   const listenerOptions = { passive: true };
   useEventListener(window2, "popstate", onChanged, listenerOptions);