@reactive-vscode/vueuse 0.2.8 → 0.2.10

package/dist/index.cjs

@@ -46,6 +46,9 @@ function createEventHook() {
   const off = (fn) => {
     fns.delete(fn);
   };
+  const clear = () => {
+    fns.clear();
+  };
   const on = (fn) => {
     fns.add(fn);
     const offFn = () => off(fn);
@@ -60,7 +63,8 @@ function createEventHook() {
   return {
     on,
     off,
-    trigger
+    trigger,
+    clear
   };
 }
 function createGlobalState(stateFactory) {
@@ -145,12 +149,8 @@ function makeDestructurable(obj, arr) {
     return Object.assign([...arr], obj);
   }
 }
-function toValue(r) {
-  return typeof r === "function" ? r() : reactivity.unref(r);
-}
-const resolveUnref = toValue;
 function reactify(fn, options) {
-  const unrefFn = (options == null ? void 0 : options.computedGetter) === false ? reactivity.unref : toValue;
+  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))));
   };
@@ -215,7 +215,7 @@ function reactiveComputed(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(toValue(v), k))) : Object.fromEntries(Object.entries(reactivity.toRefs(obj)).filter((e) => !flatKeys.includes(e[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]))));
 }
 const isClient = typeof window !== "undefined" && typeof document !== "undefined";
 const isWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
@@ -258,9 +258,10 @@ function debounceFilter(ms, options = {}) {
     lastRejector();
     lastRejector = noop;
   };
+  let lastInvoker;
   const filter = (invoke2) => {
-    const duration = toValue(ms);
-    const maxDuration = toValue(options.maxWait);
+    const duration = reactivity.toValue(ms);
+    const maxDuration = reactivity.toValue(options.maxWait);
     if (timer)
       _clearTimeout(timer);
     if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
@@ -272,12 +273,13 @@ function debounceFilter(ms, options = {}) {
     }
     return new Promise((resolve, reject) => {
       lastRejector = options.rejectOnCancel ? reject : resolve;
+      lastInvoker = invoke2;
       if (maxDuration && !maxTimer) {
         maxTimer = setTimeout(() => {
           if (timer)
             _clearTimeout(timer);
           maxTimer = null;
-          resolve(invoke2());
+          resolve(lastInvoker());
         }, maxDuration);
       }
       timer = setTimeout(() => {
@@ -313,7 +315,7 @@ function throttleFilter(...args) {
     }
   };
   const filter = (_invoke) => {
-    const duration = toValue(ms);
+    const duration = reactivity.toValue(ms);
     const elapsed = Date.now() - lastExec;
     const invoke2 = () => {
       return lastValue = _invoke();
@@ -434,6 +436,9 @@ function objectEntries(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);
@@ -444,16 +449,16 @@ 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(toValue(v), k))) : Object.fromEntries(flatKeys.map((k) => [k, toRef(obj, k)])));
+  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 = toValue(defaultValue);
+    let value = reactivity.toValue(defaultValue);
     let timer;
     const resetAfter = () => setTimeout(() => {
-      value = toValue(defaultValue);
+      value = reactivity.toValue(defaultValue);
       trigger();
-    }, toValue(afterMs));
+    }, reactivity.toValue(afterMs));
     tryOnScopeDispose(() => {
       clearTimeout(timer);
     });
@@ -569,10 +574,8 @@ function set(...args) {
     ref.value = value;
   }
   if (args.length === 3) {
-    {
-      const [target, key, value] = args;
-      target[key] = value;
-    }
+    const [target, key, value] = args;
+    target[key] = value;
   }
 }
 function watchWithFilter(source, cb, options = {}) {
@@ -649,8 +652,7 @@ function syncRefs(source, targets, options = {}) {
     deep = false,
     immediate = true
   } = options;
-  if (!Array.isArray(targets))
-    targets = [targets];
+  targets = toArray(targets);
   return reactivity.watch(
     source,
     (newValue) => targets.forEach((target) => target.value = newValue),
@@ -668,7 +670,7 @@ function toRefs(objectRef, options = {}) {
       },
       set(v) {
         var _a;
-        const replaceRef = (_a = toValue(options.replaceRef)) != null ? _a : true;
+        const replaceRef = (_a = reactivity.toValue(options.replaceRef)) != null ? _a : true;
         if (replaceRef) {
           if (Array.isArray(objectRef.value)) {
             const copy = [...objectRef.value];
@@ -687,6 +689,8 @@ function toRefs(objectRef, options = {}) {
   }
   return result;
 }
+const toValue = reactivity.toValue;
+const resolveUnref = reactivity.toValue;
 function tryOnMounted(fn, sync = true, target) {
   if (sync)
     fn();
@@ -718,7 +722,7 @@ function createUntil(r, isNot = false) {
     const promises = [watcher];
     if (timeout != null) {
       promises.push(
-        promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => stop == null ? void 0 : stop())
+        promiseTimeout(timeout, throwOnTimeout).then(() => reactivity.toValue(r)).finally(() => stop == null ? void 0 : stop())
       );
     }
     return Promise.race(promises);
@@ -750,9 +754,9 @@ function createUntil(r, isNot = false) {
     const promises = [watcher];
     if (timeout != null) {
       promises.push(
-        promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => {
+        promiseTimeout(timeout, throwOnTimeout).then(() => reactivity.toValue(r)).finally(() => {
           stop == null ? void 0 : stop();
-          return toValue(r);
+          return reactivity.toValue(r);
         })
       );
     }
@@ -773,7 +777,7 @@ function createUntil(r, isNot = false) {
   function toContains(value, options) {
     return toMatch((v) => {
       const array = Array.from(v);
-      return array.includes(value) || array.includes(toValue(value));
+      return array.includes(value) || array.includes(reactivity.toValue(value));
     }, options);
   }
   function changed(options) {
@@ -786,7 +790,7 @@ function createUntil(r, isNot = false) {
       return count >= n;
     }, options);
   }
-  if (Array.isArray(toValue(r))) {
+  if (Array.isArray(reactivity.toValue(r))) {
     const instance = {
       toMatch,
       toContains,
@@ -821,29 +825,38 @@ function defaultComparator(value, othVal) {
   return value === othVal;
 }
 function useArrayDifference(...args) {
-  var _a;
+  var _a, _b;
   const list = args[0];
   const values = args[1];
   let compareFn = (_a = args[2]) != null ? _a : defaultComparator;
+  const {
+    symmetric = false
+  } = (_b = args[3]) != null ? _b : {};
   if (typeof compareFn === "string") {
     const key = compareFn;
     compareFn = (value, othVal) => value[key] === othVal[key];
   }
-  return reactivity.computed(() => toValue(list).filter((x) => toValue(values).findIndex((y) => compareFn(x, y)) === -1));
+  const diff1 = reactivity.computed(() => reactivity.toValue(list).filter((x) => reactivity.toValue(values).findIndex((y) => compareFn(x, y)) === -1));
+  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;
+  }
 }
 function useArrayEvery(list, fn) {
-  return reactivity.computed(() => toValue(list).every((element, index, array) => fn(toValue(element), index, array)));
+  return reactivity.computed(() => reactivity.toValue(list).every((element, index, array) => fn(reactivity.toValue(element), index, array)));
 }
 function useArrayFilter(list, fn) {
-  return reactivity.computed(() => toValue(list).map((i) => toValue(i)).filter(fn));
+  return reactivity.computed(() => reactivity.toValue(list).map((i) => reactivity.toValue(i)).filter(fn));
 }
 function useArrayFind(list, fn) {
-  return reactivity.computed(() => toValue(
-    toValue(list).find((element, index, array) => fn(toValue(element), index, array))
+  return reactivity.computed(() => reactivity.toValue(
+    reactivity.toValue(list).find((element, index, array) => fn(reactivity.toValue(element), index, array))
   ));
 }
 function useArrayFindIndex(list, fn) {
-  return reactivity.computed(() => toValue(list).findIndex((element, index, array) => fn(toValue(element), index, array)));
+  return reactivity.computed(() => reactivity.toValue(list).findIndex((element, index, array) => fn(reactivity.toValue(element), index, array)));
 }
 function findLast(arr, cb) {
   let index = arr.length;
@@ -854,8 +867,8 @@ function findLast(arr, cb) {
   return void 0;
 }
 function useArrayFindLast(list, fn) {
-  return reactivity.computed(() => toValue(
-    !Array.prototype.findLast ? findLast(toValue(list), (element, index, array) => fn(toValue(element), index, array)) : toValue(list).findLast((element, index, array) => fn(toValue(element), index, array))
+  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) {
@@ -873,31 +886,31 @@ function useArrayIncludes(...args) {
   }
   if (typeof comparator === "string") {
     const key = comparator;
-    comparator = (element, value2) => element[key] === toValue(value2);
+    comparator = (element, value2) => element[key] === reactivity.toValue(value2);
   }
-  comparator = comparator != null ? comparator : (element, value2) => element === toValue(value2);
-  return reactivity.computed(() => toValue(list).slice(formIndex).some((element, index, array) => comparator(
-    toValue(element),
-    toValue(value),
+  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,
-    toValue(array)
+    reactivity.toValue(array)
   )));
 }
 function useArrayJoin(list, separator) {
-  return reactivity.computed(() => toValue(list).map((i) => toValue(i)).join(toValue(separator)));
+  return reactivity.computed(() => reactivity.toValue(list).map((i) => reactivity.toValue(i)).join(reactivity.toValue(separator)));
 }
 function useArrayMap(list, fn) {
-  return reactivity.computed(() => toValue(list).map((i) => toValue(i)).map(fn));
+  return reactivity.computed(() => reactivity.toValue(list).map((i) => reactivity.toValue(i)).map(fn));
 }
 function useArrayReduce(list, reducer, ...args) {
-  const reduceCallback = (sum, value, index) => reducer(toValue(sum), toValue(value), index);
+  const reduceCallback = (sum, value, index) => reducer(reactivity.toValue(sum), reactivity.toValue(value), index);
   return reactivity.computed(() => {
-    const resolved = toValue(list);
-    return args.length ? resolved.reduce(reduceCallback, toValue(args[0])) : resolved.reduce(reduceCallback);
+    const resolved = reactivity.toValue(list);
+    return args.length ? resolved.reduce(reduceCallback, typeof args[0] === "function" ? reactivity.toValue(args[0]()) : reactivity.toValue(args[0])) : resolved.reduce(reduceCallback);
   });
 }
 function useArraySome(list, fn) {
-  return reactivity.computed(() => toValue(list).some((element, index, array) => fn(toValue(element), index, array)));
+  return reactivity.computed(() => reactivity.toValue(list).some((element, index, array) => fn(reactivity.toValue(element), index, array)));
 }
 function uniq(array) {
   return Array.from(new Set(array));
@@ -911,7 +924,7 @@ function uniqueElementsBy(array, fn) {
 }
 function useArrayUnique(list, compareFn) {
   return reactivity.computed(() => {
-    const resolvedList = toValue(list).map((element) => toValue(element));
+    const resolvedList = reactivity.toValue(list).map((element) => reactivity.toValue(element));
     return compareFn ? uniqueElementsBy(resolvedList, compareFn) : uniq(resolvedList);
   });
 }
@@ -963,8 +976,8 @@ function formatDate(date, formatStr, options = {}) {
     M: () => month + 1,
     Mo: () => formatOrdinal(month + 1),
     MM: () => `${month + 1}`.padStart(2, "0"),
-    MMM: () => date.toLocaleDateString(toValue(options.locales), { month: "short" }),
-    MMMM: () => date.toLocaleDateString(toValue(options.locales), { month: "long" }),
+    MMM: () => date.toLocaleDateString(reactivity.toValue(options.locales), { month: "short" }),
+    MMMM: () => date.toLocaleDateString(reactivity.toValue(options.locales), { month: "long" }),
     D: () => String(days),
     Do: () => formatOrdinal(days),
     DD: () => `${days}`.padStart(2, "0"),
@@ -982,9 +995,9 @@ function formatDate(date, formatStr, options = {}) {
     ss: () => `${seconds}`.padStart(2, "0"),
     SSS: () => `${milliseconds}`.padStart(3, "0"),
     d: () => day,
-    dd: () => date.toLocaleDateString(toValue(options.locales), { weekday: "narrow" }),
-    ddd: () => date.toLocaleDateString(toValue(options.locales), { weekday: "short" }),
-    dddd: () => date.toLocaleDateString(toValue(options.locales), { weekday: "long" }),
+    dd: () => date.toLocaleDateString(reactivity.toValue(options.locales), { weekday: "narrow" }),
+    ddd: () => date.toLocaleDateString(reactivity.toValue(options.locales), { weekday: "short" }),
+    dddd: () => date.toLocaleDateString(reactivity.toValue(options.locales), { weekday: "long" }),
     A: () => meridiem(hours, minutes),
     AA: () => meridiem(hours, minutes, false, true),
     a: () => meridiem(hours, minutes, true),
@@ -1013,7 +1026,7 @@ function normalizeDate(date) {
   return new Date(date);
 }
 function useDateFormat(date, formatStr = "HH:mm:ss", options = {}) {
-  return reactivity.computed(() => formatDate(normalizeDate(toValue(date)), toValue(formatStr), options));
+  return reactivity.computed(() => formatDate(normalizeDate(reactivity.toValue(date)), reactivity.toValue(formatStr), options));
 }
 function useIntervalFn(cb, interval = 1e3, options = {}) {
   const {
@@ -1033,14 +1046,15 @@ function useIntervalFn(cb, interval = 1e3, options = {}) {
     clean();
   }
   function resume() {
-    const intervalValue = toValue(interval);
+    const intervalValue = reactivity.toValue(interval);
     if (intervalValue <= 0)
       return;
     isActive.value = true;
     if (immediateCallback)
       cb();
     clean();
-    timer = setInterval(cb, intervalValue);
+    if (isActive.value)
+      timer = setInterval(cb, intervalValue);
   }
   if (immediate && isClient)
     resume();
@@ -1120,7 +1134,7 @@ function useTimeoutFn(cb, interval, options = {}) {
       isPending.value = false;
       timer = null;
       cb(...args);
-    }, toValue(interval));
+    }, reactivity.toValue(interval));
   }
   if (immediate) {
     isPending.value = true;
@@ -1161,8 +1175,10 @@ function useToNumber(value, options = {}) {
     nanToZero
   } = options;
   return reactivity.computed(() => {
-    let resolved = toValue(value);
-    if (typeof resolved === "string")
+    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;
@@ -1170,7 +1186,7 @@ function useToNumber(value, options = {}) {
   });
 }
 function useToString(value) {
-  return reactivity.computed(() => `${toValue(value)}`);
+  return reactivity.computed(() => `${reactivity.toValue(value)}`);
 }
 function useToggle(initialValue = false, options = {}) {
   const {
@@ -1184,8 +1200,8 @@ function useToggle(initialValue = false, options = {}) {
       _value.value = value;
       return _value.value;
     } else {
-      const truthy = toValue(truthyValue);
-      _value.value = _value.value === truthy ? toValue(falsyValue) : truthy;
+      const truthy = reactivity.toValue(truthyValue);
+      _value.value = _value.value === truthy ? reactivity.toValue(falsyValue) : truthy;
       return _value.value;
     }
   }
@@ -1195,7 +1211,7 @@ function useToggle(initialValue = false, options = {}) {
     return [_value, toggle];
 }
 function watchArray(source, cb, options) {
-  let oldList = (options == null ? void 0 : options.immediate) ? [] : [...source instanceof Function ? source() : Array.isArray(source) ? source : toValue(source)];
+  let oldList = (options == null ? void 0 : options.immediate) ? [] : [...source instanceof Function ? source() : Array.isArray(source) ? source : reactivity.toValue(source)];
   return reactivity.watch(source, (newList, _, onCleanup) => {
     const oldListRemains = Array.from({ length: oldList.length });
     const added = [];
@@ -1226,7 +1242,7 @@ function watchAtMost(source, cb, options) {
     source,
     (...args) => {
       current.value += 1;
-      if (current.value >= toValue(count))
+      if (current.value >= reactivity.toValue(count))
         reactivity.nextTick(() => stop());
       cb(...args);
     },
@@ -1396,8 +1412,8 @@ function getWatchSources(sources) {
   if (reactivity.isReactive(sources))
     return sources;
   if (Array.isArray(sources))
-    return sources.map((item) => toValue(item));
-  return toValue(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;
@@ -1478,61 +1494,60 @@ function computedAsync(evaluationCallback, initialState, optionsOrRef) {
 }
 function createUnrefFn(fn) {
   return function(...args) {
-    return fn.apply(this, args.map((i) => toValue(i)));
+    return fn.apply(this, args.map((i) => reactivity.toValue(i)));
   };
 }
 const defaultWindow = isClient ? window : void 0;
 function unrefElement(elRef) {
   var _a;
-  const plain = toValue(elRef);
+  const plain = reactivity.toValue(elRef);
   return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
 }
 function useEventListener(...args) {
-  let target;
-  let events2;
-  let listeners;
-  let options;
-  if (typeof args[0] === "string" || Array.isArray(args[0])) {
-    [events2, listeners, options] = args;
-    target = defaultWindow;
-  } else {
-    [target, events2, listeners, options] = args;
-  }
-  if (!target)
-    return noop;
-  if (!Array.isArray(events2))
-    events2 = [events2];
-  if (!Array.isArray(listeners))
-    listeners = [listeners];
   const cleanups = [];
   const cleanup = () => {
     cleanups.forEach((fn) => fn());
     cleanups.length = 0;
   };
-  const register = (el, event, listener, options2) => {
-    el.addEventListener(event, listener, options2);
-    return () => el.removeEventListener(event, listener, options2);
+  const register = (el, event, listener, options) => {
+    el.addEventListener(event, listener, options);
+    return () => el.removeEventListener(event, listener, options);
   };
-  const stopWatch = reactivity.watch(
-    () => [unrefElement(target), toValue(options)],
-    ([el, options2]) => {
+  const firstParamTargets = reactivity.computed(() => {
+    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 (!el)
+      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(options2) ? { ...options2 } : options2;
+      const optionsClone = isObject(raw_options) ? { ...raw_options } : raw_options;
       cleanups.push(
-        ...events2.flatMap((event) => {
-          return listeners.map((listener) => register(el, event, listener, optionsClone));
-        })
+        ...raw_targets.flatMap(
+          (el) => raw_events.flatMap(
+            (event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone))
+          )
+        )
       );
     },
-    { immediate: true, flush: "post" }
+    { flush: "post" }
   );
   const stop = () => {
     stopWatch();
     cleanup();
   };
-  tryOnScopeDispose(stop);
+  tryOnScopeDispose(cleanup);
   return stop;
 }
 function useMounted() {
@@ -1553,7 +1568,9 @@ function useRafFn(fn, options = {}) {
     window: window2 = defaultWindow
   } = options;
   const isActive = reactivity.ref(false);
-  const intervalLimit = fpsLimit ? 1e3 / fpsLimit : null;
+  const intervalLimit = reactivity.computed(() => {
+    return fpsLimit ? 1e3 / reactivity.toValue(fpsLimit) : null;
+  });
   let previousFrameTimestamp = 0;
   let rafId = null;
   function loop(timestamp2) {
@@ -1562,7 +1579,7 @@ function useRafFn(fn, options = {}) {
     if (!previousFrameTimestamp)
       previousFrameTimestamp = timestamp2;
     const delta = timestamp2 - previousFrameTimestamp;
-    if (intervalLimit && delta < intervalLimit) {
+    if (intervalLimit.value && delta < intervalLimit.value) {
       rafId = window2.requestAnimationFrame(loop);
       return;
     }
@@ -1703,8 +1720,9 @@ function useAsyncState(promise, initialState, options) {
     }
     return state.value;
   }
-  if (immediate)
+  if (immediate) {
     execute(delay);
+  }
   const shell = {
     state,
     isReady,
@@ -1751,7 +1769,7 @@ function useBase64(target, options) {
       return;
     promise.value = new Promise((resolve, reject) => {
       try {
-        const _target = toValue(target);
+        const _target = reactivity.toValue(target);
         if (_target == null) {
           resolve("");
         } else if (typeof _target === "string") {
@@ -1784,7 +1802,9 @@ function useBase64(target, options) {
         reject(error);
       }
     });
-    promise.value.then((res) => base64.value = res);
+    promise.value.then((res) => {
+      base64.value = (options == null ? void 0 : options.dataUrl) === false ? res.replace(/^data:.*?;base64,/, "") : res;
+    });
     return promise.value;
   }
   if (reactivity.isRef(target) || typeof target === "function")
@@ -1842,15 +1862,18 @@ function useBroadcastChannel(options) {
     tryOnMounted(() => {
       error.value = null;
       channel.value = new BroadcastChannel(name);
-      channel.value.addEventListener("message", (e) => {
+      const listenerOptions = {
+        passive: true
+      };
+      useEventListener(channel, "message", (e) => {
         data.value = e.data;
-      }, { passive: true });
-      channel.value.addEventListener("messageerror", (e) => {
+      }, listenerOptions);
+      useEventListener(channel, "messageerror", (e) => {
         error.value = e;
-      }, { passive: true });
-      channel.value.addEventListener("close", () => {
+      }, listenerOptions);
+      useEventListener(channel, "close", () => {
         isClosed.value = true;
-      });
+      }, listenerOptions);
     });
   }
   tryOnScopeDispose(() => {
@@ -1879,6 +1902,8 @@ function cloneFnJSON(source) {
 }
 function useCloned(source, options = {}) {
   const cloned = reactivity.ref({});
+  const isModified = reactivity.ref(false);
+  let _lastSync = false;
   const {
     manual,
     clone = cloneFnJSON,
@@ -1886,8 +1911,20 @@ function useCloned(source, options = {}) {
     deep = true,
     immediate = true
   } = options;
+  reactivity.watch(cloned, () => {
+    if (_lastSync) {
+      _lastSync = false;
+      return;
+    }
+    isModified.value = true;
+  }, {
+    deep: true,
+    flush: "sync"
+  });
   function sync() {
-    cloned.value = clone(toValue(source));
+    _lastSync = true;
+    isModified.value = false;
+    cloned.value = clone(reactivity.toValue(source));
   }
   if (!manual && (reactivity.isRef(source) || typeof source === "function")) {
     reactivity.watch(source, sync, {
@@ -1898,7 +1935,7 @@ function useCloned(source, options = {}) {
   } else {
     sync();
   }
-  return { cloned, sync };
+  return { cloned, isModified, sync };
 }
 function useCycleList(list, options) {
   const state = reactivity.shallowRef(getInitialValue());
@@ -1935,7 +1972,7 @@ function useCycleList(list, options) {
   }
   function getInitialValue() {
     var _a, _b;
-    return (_b = toValue((_a = options == null ? void 0 : options.initialValue) != null ? _a : toValue(list)[0])) != null ? _b : void 0;
+    return (_b = reactivity.toValue((_a = options == null ? void 0 : options.initialValue) != null ? _a : reactivity.toValue(list)[0])) != null ? _b : void 0;
   }
   reactivity.watch(listRef, () => set2(index.value));
   return {
@@ -2169,8 +2206,8 @@ function createFetch(config = {}) {
   const _fetchOptions = config.fetchOptions || {};
   function useFactoryFetch(url, ...args) {
     const computedUrl = reactivity.computed(() => {
-      const baseUrl = toValue(config.baseUrl);
-      const targetUrl = toValue(url);
+      const baseUrl = reactivity.toValue(config.baseUrl);
+      const targetUrl = reactivity.toValue(url);
       return baseUrl && !isAbsoluteURL(targetUrl) ? joinPaths(baseUrl, targetUrl) : targetUrl;
     });
     let options = _options;
@@ -2282,10 +2319,11 @@ function useFetch(url, ...args) {
       method: config.method,
       headers: {}
     };
-    if (config.payload) {
+    const payload = reactivity.toValue(config.payload);
+    if (payload) {
       const headers = headersToObject(defaultFetchOptions.headers);
-      const payload = toValue(config.payload);
-      if (!config.payloadType && payload && Object.getPrototypeOf(payload) === Object.prototype && !(payload instanceof FormData))
+      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;
@@ -2293,7 +2331,7 @@ function useFetch(url, ...args) {
     }
     let isCanceled = false;
     const context = {
-      url: toValue(url),
+      url: reactivity.toValue(url),
       options: {
         ...defaultFetchOptions,
         ...fetchOptions
@@ -2332,7 +2370,9 @@ function useFetch(url, ...args) {
       if (options.afterFetch) {
         ({ data: responseData } = await options.afterFetch({
           data: responseData,
-          response: fetchResponse
+          response: fetchResponse,
+          context,
+          execute
         }));
       }
       data.value = responseData;
@@ -2344,7 +2384,9 @@ function useFetch(url, ...args) {
         ({ error: errorData, data: responseData } = await options.onFetchError({
           data: responseData,
           error: fetchError,
-          response: response.value
+          response: response.value,
+          context,
+          execute
         }));
       }
       error.value = errorData;
@@ -2428,7 +2470,7 @@ function useFetch(url, ...args) {
   }
   function waitUntilFinished() {
     return new Promise((resolve, reject) => {
-      until(isFinished).toBe(true).then(() => resolve(shell)).catch((error2) => reject(error2));
+      until(isFinished).toBe(true).then(() => resolve(shell)).catch(reject);
     });
   }
   function setType(type) {
@@ -2455,8 +2497,12 @@ function useFetch(url, ...args) {
   };
 }
 function joinPaths(start, end) {
-  if (!start.endsWith("/") && !end.startsWith("/"))
+  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"];
@@ -2486,13 +2532,14 @@ function useIdle(timeout = oneMinute, options = {}) {
   );
   if (window2) {
     const document2 = window2.document;
+    const listenerOptions = { passive: true };
     for (const event of events2)
-      useEventListener(window2, event, onEvent, { passive: true });
+      useEventListener(window2, event, onEvent, listenerOptions);
     if (listenForVisibilityChange) {
       useEventListener(document2, "visibilitychange", () => {
         if (!document2.hidden)
           onEvent();
-      });
+      }, listenerOptions);
     }
     reset();
   }
@@ -2527,7 +2574,7 @@ function useObjectUrl(object) {
     url.value = void 0;
   };
   reactivity.watch(
-    () => toValue(object),
+    () => reactivity.toValue(object),
     (newObject) => {
       release();
       if (newObject)
@@ -2540,14 +2587,14 @@ function useObjectUrl(object) {
 }
 function useClamp(value, min, max) {
   if (typeof value === "function" || reactivity.isReadonly(value))
-    return reactivity.computed(() => clamp(toValue(value), toValue(min), toValue(max)));
+    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, toValue(min), toValue(max));
+      return _value.value = clamp(_value.value, reactivity.toValue(min), reactivity.toValue(max));
     },
     set(value2) {
-      _value.value = clamp(value2, toValue(min), toValue(max));
+      _value.value = clamp(value2, reactivity.toValue(min), reactivity.toValue(max));
     }
   });
 }
@@ -2563,7 +2610,7 @@ function useOffsetPagination(options) {
   const currentPageSize = useClamp(pageSize, 1, Number.POSITIVE_INFINITY);
   const pageCount = reactivity.computed(() => Math.max(
     1,
-    Math.ceil(toValue(total) / toValue(currentPageSize))
+    Math.ceil(reactivity.toValue(total) / reactivity.toValue(currentPageSize))
   ));
   const currentPage = useClamp(page, 1, pageCount);
   const isFirstPage = reactivity.computed(() => currentPage.value === 1);
@@ -2638,9 +2685,9 @@ function useSorted(...args) {
     sortFn = defaultSortFn
   } = options;
   if (!dirty)
-    return reactivity.computed(() => sortFn([...toValue(source)], compareFn));
+    return reactivity.computed(() => sortFn([...reactivity.toValue(source)], compareFn));
   reactivity.watchEffect(() => {
-    const result = sortFn(toValue(source), compareFn);
+    const result = sortFn(reactivity.toValue(source), compareFn);
     if (reactivity.isRef(source))
       source.value = result;
     else
@@ -2761,7 +2808,7 @@ function useTimeAgo(time, options = {}) {
     updateInterval = 3e4
   } = options;
   const { now: now2, ...controls } = useNow({ interval: updateInterval, controls: true });
-  const timeAgo = reactivity.computed(() => formatTimeAgo(new Date(toValue(time)), options, toValue(now2)));
+  const timeAgo = reactivity.computed(() => formatTimeAgo(new Date(reactivity.toValue(time)), options, reactivity.toValue(now2)));
   if (exposeControls) {
     return {
       timeAgo,
@@ -2817,7 +2864,10 @@ function formatTimeAgo(from, options = {}, now2 = Date.now()) {
   }
   return messages.invalid;
 }
-function useTimeoutPoll(fn, interval, timeoutPollOptions) {
+function useTimeoutPoll(fn, interval, options = {}) {
+  const {
+    immediate = true
+  } = options;
   const { start } = useTimeoutFn(loop, interval, { immediate: false });
   const isActive = reactivity.ref(false);
   async function loop() {
@@ -2835,7 +2885,7 @@ function useTimeoutPoll(fn, interval, timeoutPollOptions) {
   function pause() {
     isActive.value = false;
   }
-  if (timeoutPollOptions == null ? void 0 : timeoutPollOptions.immediate)
+  if (immediate && isClient)
     resume();
   tryOnScopeDispose(pause);
   return {
@@ -2874,6 +2924,7 @@ function useUrlSearchParams(mode = "history", options = {}) {
     removeNullishValues = true,
     removeFalsyValues = false,
     write: enableWrite = true,
+    writeMode = "replace",
     window: window2 = defaultWindow
   } = options;
   if (!window2)
@@ -2899,8 +2950,8 @@ function useUrlSearchParams(mode = "history", options = {}) {
     const hash = window2.location.hash || "#";
     const index = hash.indexOf("?");
     if (index > 0)
-      return `${hash.slice(0, index)}${stringified ? `?${stringified}` : ""}`;
-    return `${hash}${stringified ? `?${stringified}` : ""}`;
+      return `${window2.location.search || ""}${hash.slice(0, index)}${stringified ? `?${stringified}` : ""}`;
+    return `${window2.location.search || ""}${hash}${stringified ? `?${stringified}` : ""}`;
   }
   function read() {
     return new URLSearchParams(getRawParams());
@@ -2929,7 +2980,7 @@ function useUrlSearchParams(mode = "history", options = {}) {
         else
           params.set(key, mapEntry);
       });
-      write(params);
+      write(params, false);
     },
     { deep: true }
   );
@@ -2937,11 +2988,19 @@ function useUrlSearchParams(mode = "history", options = {}) {
     pause();
     if (shouldUpdate)
       updateState(params);
-    window2.history.replaceState(
-      window2.history.state,
-      window2.document.title,
-      window2.location.pathname + constructQuery(params)
-    );
+    if (writeMode === "replace") {
+      window2.history.replaceState(
+        window2.history.state,
+        window2.document.title,
+        window2.location.pathname + constructQuery(params)
+      );
+    } else {
+      window2.history.pushState(
+        window2.history.state,
+        window2.document.title,
+        window2.location.pathname + constructQuery(params)
+      );
+    }
     resume();
   }
   function onChanged() {
@@ -2949,9 +3008,10 @@ function useUrlSearchParams(mode = "history", options = {}) {
       return;
     write(read(), true);
   }
-  useEventListener(window2, "popstate", onChanged, false);
+  const listenerOptions = { passive: true };
+  useEventListener(window2, "popstate", onChanged, listenerOptions);
   if (mode !== "history")
-    useEventListener(window2, "hashchange", onChanged, false);
+    useEventListener(window2, "hashchange", onChanged, listenerOptions);
   const initial = read();
   if (initial.keys().next().value)
     updateState(initial);
@@ -2972,6 +3032,7 @@ function useWebSocket(url, options = {}) {
     onError,
     onMessage,
     immediate = true,
+    autoConnect = true,
     autoClose = true,
     protocols = []
   } = options;
@@ -2984,6 +3045,7 @@ function useWebSocket(url, options = {}) {
   let explicitlyClosed = false;
   let retried = 0;
   let bufferedData = [];
+  let retryTimeout;
   let pongTimeoutWait;
   const _sendBuffer = () => {
     if (bufferedData.length && wsRef.value && status.value === "OPEN") {
@@ -2992,12 +3054,19 @@ function useWebSocket(url, options = {}) {
       bufferedData = [];
     }
   };
+  const resetRetry = () => {
+    if (retryTimeout != null) {
+      clearTimeout(retryTimeout);
+      retryTimeout = void 0;
+    }
+  };
   const resetHeartbeat = () => {
     clearTimeout(pongTimeoutWait);
     pongTimeoutWait = void 0;
   };
   const close = (code = 1e3, reason) => {
-    if (!isClient || !wsRef.value)
+    resetRetry();
+    if (!isClient && !isWorker || !wsRef.value)
       return;
     explicitlyClosed = true;
     resetHeartbeat();
@@ -3031,7 +3100,7 @@ function useWebSocket(url, options = {}) {
     ws.onclose = (ev) => {
       status.value = "CLOSED";
       onDisconnected == null ? void 0 : onDisconnected(ws, ev);
-      if (!explicitlyClosed && options.autoReconnect && ws === wsRef.value) {
+      if (!explicitlyClosed && options.autoReconnect && (wsRef.value == null || ws === wsRef.value)) {
         const {
           retries = -1,
           delay = 1e3,
@@ -3039,9 +3108,9 @@ function useWebSocket(url, options = {}) {
         } = resolveNestedOptions(options.autoReconnect);
         if (typeof retries === "number" && (retries < 0 || retried < retries)) {
           retried += 1;
-          setTimeout(_init, delay);
+          retryTimeout = setTimeout(_init, delay);
         } else if (typeof retries === "function" && retries()) {
-          setTimeout(_init, delay);
+          retryTimeout = setTimeout(_init, delay);
         } else {
           onFailed == null ? void 0 : onFailed();
         }
@@ -3057,7 +3126,7 @@ function useWebSocket(url, options = {}) {
           message = DEFAULT_PING_MESSAGE,
           responseMessage = message
         } = resolveNestedOptions(options.heartbeat);
-        if (e.data === responseMessage)
+        if (e.data === reactivity.toValue(responseMessage))
           return;
       }
       data.value = e.data;
@@ -3072,7 +3141,7 @@ function useWebSocket(url, options = {}) {
     } = resolveNestedOptions(options.heartbeat);
     const { pause, resume } = useIntervalFn(
       () => {
-        send(message, false);
+        send(reactivity.toValue(message), false);
         if (pongTimeoutWait != null)
           return;
         pongTimeoutWait = setTimeout(() => {
@@ -3088,7 +3157,7 @@ function useWebSocket(url, options = {}) {
   }
   if (autoClose) {
     if (isClient)
-      useEventListener("beforeunload", () => close());
+      useEventListener("beforeunload", () => close(), { passive: true });
     tryOnScopeDispose(close);
   }
   const open = () => {
@@ -3101,7 +3170,8 @@ function useWebSocket(url, options = {}) {
   };
   if (immediate)
     open();
-  reactivity.watch(urlRef, open);
+  if (autoConnect)
+    reactivity.watch(urlRef, open);
   return {
     data,
     status,