@gct-paas/core-web 0.1.4-dev.0 → 0.1.4-dev.2

package/es/node_modules/.pnpm/{@vueuse_shared@10.11.1_vue@3.5.13_typescript@5.8.3_ → @vueuse_shared@13.7.0_vue@3.5.18_typescript@5.9.2_}/node_modules/@vueuse/shared/index.mjs

@@ -1,5 +1,4 @@
-import { isVue3, isVue2, set as set$1 } from '../../../../vue-demi@0.14.10_vue@3.5.13_typescript@5.8.3_/node_modules/vue-demi/lib/index.mjs';
-import { shallowRef, watchEffect, readonly, ref, watch, customRef, getCurrentScope, onScopeDispose, effectScope, getCurrentInstance, provide, inject, version, isRef, unref, computed, reactive, toRefs as toRefs$1, toRef as toRef$1, onBeforeMount, nextTick, onBeforeUnmount, onMounted, onUnmounted, isReactive } from 'vue';
+import { shallowRef, watchEffect, readonly, watch, customRef, getCurrentScope, onScopeDispose, effectScope, getCurrentInstance, hasInjectionContext, inject, provide, ref, isRef, unref, toValue as toValue$1, computed, reactive, toRefs as toRefs$1, toRef as toRef$1, shallowReadonly, onBeforeMount, nextTick, onBeforeUnmount, onMounted, onUnmounted, isReactive } from 'vue';
 
 function computedEager(fn, options) {
   var _a;
@@ -13,16 +12,16 @@ function computedEager(fn, options) {
   return readonly(result);
 }
 
-function computedWithControl(source, fn) {
+function computedWithControl(source, fn, options = {}) {
   let v = void 0;
   let track;
   let trigger;
-  const dirty = ref(true);
+  let dirty = true;
   const update = () => {
-    dirty.value = true;
+    dirty = true;
     trigger();
   };
-  watch(source, update, { flush: "sync" });
+  watch(source, update, { flush: "sync", ...options });
   const get = typeof fn === "function" ? fn : fn.get;
   const set = typeof fn === "function" ? void 0 : fn.set;
   const result = customRef((_track, _trigger) => {
@@ -30,9 +29,9 @@ function computedWithControl(source, fn) {
     trigger = _trigger;
     return {
       get() {
-        if (dirty.value) {
-          v = get();
-          dirty.value = false;
+        if (dirty) {
+          v = get(v);
+          dirty = false;
         }
         track();
         return v;
@@ -42,8 +41,7 @@ function computedWithControl(source, fn) {
       }
     };
   });
-  if (Object.isExtensible(result))
-    result.trigger = update;
+  result.trigger = update;
   return result;
 }
 
@@ -55,11 +53,15 @@ function tryOnScopeDispose(fn) {
   return false;
 }
 
+// @__NO_SIDE_EFFECTS__
 function createEventHook() {
   const fns = /* @__PURE__ */ new Set();
   const off = (fn) => {
     fns.delete(fn);
   };
+  const clear = () => {
+    fns.clear();
+  };
   const on = (fn) => {
     fns.add(fn);
     const offFn = () => off(fn);
@@ -74,10 +76,12 @@ function createEventHook() {
   return {
     on,
     off,
-    trigger
+    trigger,
+    clear
   };
 }
 
+// @__NO_SIDE_EFFECTS__
 function createGlobalState(stateFactory) {
   let initialized = false;
   let state;
@@ -93,7 +97,18 @@ function createGlobalState(stateFactory) {
 
 const localProvidedStateMap = /* @__PURE__ */ new WeakMap();
 
-const provideLocal = (key, value) => {
+const injectLocal = /* @__NO_SIDE_EFFECTS__ */ (...args) => {
+  var _a;
+  const key = args[0];
+  const instance = (_a = getCurrentInstance()) == null ? void 0 : _a.proxy;
+  if (instance == null && !hasInjectionContext())
+    throw new Error("injectLocal must be called in setup");
+  if (instance && localProvidedStateMap.has(instance) && key in localProvidedStateMap.get(instance))
+    return localProvidedStateMap.get(instance)[key];
+  return inject(...args);
+};
+
+function provideLocal(key, value) {
   var _a;
   const instance = (_a = getCurrentInstance()) == null ? void 0 : _a.proxy;
   if (instance == null)
@@ -102,20 +117,10 @@ const provideLocal = (key, value) => {
     localProvidedStateMap.set(instance, /* @__PURE__ */ Object.create(null));
   const localProvidedState = localProvidedStateMap.get(instance);
   localProvidedState[key] = value;
-  provide(key, value);
-};
-
-const injectLocal = (...args) => {
-  var _a;
-  const key = args[0];
-  const instance = (_a = getCurrentInstance()) == null ? void 0 : _a.proxy;
-  if (instance == null)
-    throw new Error("injectLocal must be called in setup");
-  if (localProvidedStateMap.has(instance) && key in localProvidedStateMap.get(instance))
-    return localProvidedStateMap.get(instance)[key];
-  return inject(...args);
-};
+  return provide(key, value);
+}
 
+// @__NO_SIDE_EFFECTS__
 function createInjectionState(composable, options) {
   const key = (options == null ? void 0 : options.injectionKey) || Symbol(composable.name || "InjectionState");
   const defaultValue = options == null ? void 0 : options.defaultValue;
@@ -128,6 +133,16 @@ function createInjectionState(composable, options) {
   return [useProvidingState, useInjectedState];
 }
 
+// @__NO_SIDE_EFFECTS__
+function createRef(value, deep) {
+  if (deep === true) {
+    return ref(value);
+  } else {
+    return shallowRef(value);
+  }
+}
+
+// @__NO_SIDE_EFFECTS__
 function createSharedComposable(composable) {
   let subscribers = 0;
   let state;
@@ -142,7 +157,7 @@ function createSharedComposable(composable) {
   };
   return (...args) => {
     subscribers += 1;
-    if (!state) {
+    if (!scope) {
       scope = effectScope(true);
       state = scope.run(() => composable(...args));
     }
@@ -152,11 +167,6 @@ function createSharedComposable(composable) {
 }
 
 function extendRef(ref, extend, { enumerable = false, unwrap = true } = {}) {
-  if (!isVue3 && !version.startsWith("2.7.")) {
-    if (process.env.NODE_ENV !== "production")
-      throw new Error("[VueUse] extendRef only works in Vue 2.7 or above.");
-    return;
-  }
   for (const [key, value] of Object.entries(extend)) {
     if (key === "value")
       continue;
@@ -187,6 +197,7 @@ function isDefined(v) {
   return unref(v) != null;
 }
 
+// @__NO_SIDE_EFFECTS__
 function makeDestructurable(obj, arr) {
   if (typeof Symbol !== "undefined") {
     const clone = { ...obj };
@@ -208,18 +219,15 @@ function makeDestructurable(obj, arr) {
   }
 }
 
-function toValue(r) {
-  return typeof r === "function" ? r() : unref(r);
-}
-const resolveUnref = toValue;
-
+// @__NO_SIDE_EFFECTS__
 function reactify(fn, options) {
-  const unrefFn = (options == null ? void 0 : options.computedGetter) === false ? unref : toValue;
+  const unrefFn = (options == null ? void 0 : options.computedGetter) === false ? unref : toValue$1;
   return function(...args) {
     return computed(() => fn.apply(this, args.map((i) => unrefFn(i))));
   };
 }
 
+// @__NO_SIDE_EFFECTS__
 function reactifyObject(obj, optionsOrKeys = {}) {
   let keys = [];
   let options;
@@ -283,7 +291,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(toRefs$1(obj)).filter(([k, v]) => !predicate(toValue(v), k))) : Object.fromEntries(Object.entries(toRefs$1(obj)).filter((e) => !flatKeys.includes(e[0]))));
+  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(toRefs$1(obj)).filter(([k, v]) => !predicate(toValue$1(v), k))) : Object.fromEntries(Object.entries(toRefs$1(obj)).filter((e) => !flatKeys.includes(e[0]))));
 }
 
 const isClient = typeof window !== "undefined" && typeof document !== "undefined";
@@ -313,6 +321,46 @@ function getIsIOS() {
   return isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((_b = window == null ? void 0 : window.navigator) == null ? void 0 : _b.maxTouchPoints) > 2 && /iPad|Macintosh/.test(window == null ? void 0 : window.navigator.userAgent));
 }
 
+function toRef(...args) {
+  if (args.length !== 1)
+    return toRef$1(...args);
+  const r = args[0];
+  return typeof r === "function" ? readonly(customRef(() => ({ get: r, set: noop }))) : ref(r);
+}
+const resolveRef = toRef;
+
+function reactivePick(obj, ...keys) {
+  const flatKeys = keys.flat();
+  const predicate = flatKeys[0];
+  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(toRefs$1(obj)).filter(([k, v]) => predicate(toValue$1(v), k))) : Object.fromEntries(flatKeys.map((k) => [k, toRef(obj, k)])));
+}
+
+function refAutoReset(defaultValue, afterMs = 1e4) {
+  return customRef((track, trigger) => {
+    let value = toValue$1(defaultValue);
+    let timer;
+    const resetAfter = () => setTimeout(() => {
+      value = toValue$1(defaultValue);
+      trigger();
+    }, toValue$1(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) => {
@@ -333,32 +381,34 @@ function debounceFilter(ms, options = {}) {
     lastRejector();
     lastRejector = noop;
   };
+  let lastInvoker;
   const filter = (invoke) => {
-    const duration = toValue(ms);
-    const maxDuration = toValue(options.maxWait);
+    const duration = toValue$1(ms);
+    const maxDuration = toValue$1(options.maxWait);
     if (timer)
       _clearTimeout(timer);
     if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
       if (maxTimer) {
         _clearTimeout(maxTimer);
-        maxTimer = null;
+        maxTimer = void 0;
       }
       return Promise.resolve(invoke());
     }
     return new Promise((resolve, reject) => {
       lastRejector = options.rejectOnCancel ? reject : resolve;
+      lastInvoker = invoke;
       if (maxDuration && !maxTimer) {
         maxTimer = setTimeout(() => {
           if (timer)
             _clearTimeout(timer);
-          maxTimer = null;
-          resolve(invoke());
+          maxTimer = void 0;
+          resolve(lastInvoker());
         }, maxDuration);
       }
       timer = setTimeout(() => {
         if (maxTimer)
           _clearTimeout(maxTimer);
-        maxTimer = null;
+        maxTimer = void 0;
         resolve(invoke());
       }, duration);
     });
@@ -388,7 +438,7 @@ function throttleFilter(...args) {
     }
   };
   const filter = (_invoke) => {
-    const duration = toValue(ms);
+    const duration = toValue$1(ms);
     const elapsed = Date.now() - lastExec;
     const invoke = () => {
       return lastValue = _invoke();
@@ -419,8 +469,11 @@ function throttleFilter(...args) {
   };
   return filter;
 }
-function pausableFilter(extendFilter = bypassFilter) {
-  const isActive = ref(true);
+function pausableFilter(extendFilter = bypassFilter, options = {}) {
+  const {
+    initialState = "active"
+  } = options;
+  const isActive = toRef(initialState === "active");
   function pause() {
     isActive.value = false;
   }
@@ -434,26 +487,6 @@ function pausableFilter(extendFilter = bypassFilter) {
   return { isActive: readonly(isActive), pause, resume, eventFilter };
 }
 
-const directiveHooks = {
-  mounted: isVue3 ? "mounted" : "inserted",
-  updated: isVue3 ? "updated" : "componentUpdated",
-  unmounted: isVue3 ? "unmounted" : "unbind"
-};
-
-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)
@@ -497,6 +530,9 @@ function increaseWithUnit(target, delta) {
     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) {
@@ -514,50 +550,29 @@ function objectOmit(obj, keys, omitUndefined = false) {
 function objectEntries(obj) {
   return Object.entries(obj);
 }
-function getLifeCycleTarget(target) {
-  return target || getCurrentInstance();
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
 }
 
-function toRef(...args) {
-  if (args.length !== 1)
-    return toRef$1(...args);
-  const r = args[0];
-  return typeof r === "function" ? readonly(customRef(() => ({ get: r, set: noop }))) : ref(r);
-}
-const resolveRef = toRef;
-
-function reactivePick(obj, ...keys) {
-  const flatKeys = keys.flat();
-  const predicate = flatKeys[0];
-  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(toRefs$1(obj)).filter(([k, v]) => predicate(toValue(v), k))) : Object.fromEntries(flatKeys.map((k) => [k, toRef(obj, k)])));
+function 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 refAutoReset(defaultValue, afterMs = 1e4) {
-  return customRef((track, trigger) => {
-    let value = toValue(defaultValue);
-    let timer;
-    const resetAfter = () => setTimeout(() => {
-      value = toValue(defaultValue);
-      trigger();
-    }, toValue(afterMs));
-    tryOnScopeDispose(() => {
-      clearTimeout(timer);
-    });
-    return {
-      get() {
-        track();
-        return value;
-      },
-      set(newValue) {
-        value = newValue;
-        trigger();
-        clearTimeout(timer);
-        timer = resetAfter();
-      }
-    };
-  });
+function getLifeCycleTarget(target) {
+  return target || getCurrentInstance();
 }
 
+// @__NO_SIDE_EFFECTS__
 function useDebounceFn(fn, ms = 200, options = {}) {
   return createFilterWrapper(
     debounceFilter(ms, options),
@@ -566,14 +581,15 @@ function useDebounceFn(fn, ms = 200, options = {}) {
 }
 
 function refDebounced(value, ms = 200, options = {}) {
-  const debounced = ref(value.value);
+  const debounced = ref(toValue$1(value));
   const updater = useDebounceFn(() => {
     debounced.value = value.value;
   }, ms, options);
   watch(value, () => updater());
-  return debounced;
+  return shallowReadonly(debounced);
 }
 
+// @__NO_SIDE_EFFECTS__
 function refDefault(source, defaultValue) {
   return computed({
     get() {
@@ -586,6 +602,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),
@@ -596,7 +613,7 @@ 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 = ref(value.value);
+  const throttled = ref(toValue$1(value));
   const updater = useThrottleFn(() => {
     throttled.value = value.value;
   }, delay, trailing, leading);
@@ -604,6 +621,7 @@ function refThrottled(value, delay = 200, trailing = true, leading = true) {
   return throttled;
 }
 
+// @__NO_SIDE_EFFECTS__
 function refWithControl(initial, options = {}) {
   let source = initial;
   let track;
@@ -662,12 +680,8 @@ function set(...args) {
     ref.value = value;
   }
   if (args.length === 3) {
-    if (isVue2) {
-      set$1(...args);
-    } else {
-      const [target, key, value] = args;
-      target[key] = value;
-    }
+    const [target, key, value] = args;
+    target[key] = value;
   }
 }
 
@@ -689,9 +703,10 @@ function watchWithFilter(source, cb, options = {}) {
 function watchPausable(source, cb, options = {}) {
   const {
     eventFilter: filter,
+    initialState = "active",
     ...watchOptions
   } = options;
-  const { eventFilter, pause, resume, isActive } = pausableFilter(filter);
+  const { eventFilter, pause, resume, isActive } = pausableFilter(filter, { initialState });
   const stop = watchWithFilter(
     source,
     cb,
@@ -748,11 +763,10 @@ function syncRefs(source, targets, options = {}) {
     deep = false,
     immediate = true
   } = options;
-  if (!Array.isArray(targets))
-    targets = [targets];
+  const targetsArray = toArray(targets);
   return watch(
     source,
-    (newValue) => targets.forEach((target) => target.value = newValue),
+    (newValue) => targetsArray.forEach((target) => target.value = newValue),
     { flush, deep, immediate }
   );
 }
@@ -768,7 +782,7 @@ function toRefs(objectRef, options = {}) {
       },
       set(v) {
         var _a;
-        const replaceRef = (_a = toValue(options.replaceRef)) != null ? _a : true;
+        const replaceRef = (_a = toValue$1(options.replaceRef)) != null ? _a : true;
         if (replaceRef) {
           if (Array.isArray(objectRef.value)) {
             const copy = [...objectRef.value];
@@ -788,6 +802,9 @@ function toRefs(objectRef, options = {}) {
   return result;
 }
 
+const toValue = toValue$1;
+const resolveUnref = toValue$1;
+
 function tryOnBeforeMount(fn, sync = true, target) {
   const instance = getLifeCycleTarget(target);
   if (instance)
@@ -805,7 +822,7 @@ function tryOnBeforeUnmount(fn, target) {
 }
 
 function tryOnMounted(fn, sync = true, target) {
-  const instance = getLifeCycleTarget();
+  const instance = getLifeCycleTarget(target);
   if (instance)
     onMounted(fn, target);
   else if (sync)
@@ -828,7 +845,10 @@ function createUntil(r, isNot = false) {
         r,
         (v) => {
           if (condition(v) !== isNot) {
-            stop == null ? void 0 : stop();
+            if (stop)
+              stop();
+            else
+              nextTick(() => stop == null ? void 0 : stop());
             resolve(v);
           }
         },
@@ -842,7 +862,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(() => toValue$1(r)).finally(() => stop == null ? void 0 : stop())
       );
     }
     return Promise.race(promises);
@@ -857,7 +877,10 @@ function createUntil(r, isNot = false) {
         [r, value],
         ([v1, v2]) => {
           if (isNot !== (v1 === v2)) {
-            stop == null ? void 0 : stop();
+            if (stop)
+              stop();
+            else
+              nextTick(() => stop == null ? void 0 : stop());
             resolve(v1);
           }
         },
@@ -871,9 +894,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(() => toValue$1(r)).finally(() => {
           stop == null ? void 0 : stop();
-          return toValue(r);
+          return toValue$1(r);
         })
       );
     }
@@ -894,7 +917,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(toValue$1(value));
     }, options);
   }
   function changed(options) {
@@ -907,7 +930,7 @@ function createUntil(r, isNot = false) {
       return count >= n;
     }, options);
   }
-  if (Array.isArray(toValue(r))) {
+  if (Array.isArray(toValue$1(r))) {
     const instance = {
       toMatch,
       toContains,
@@ -942,34 +965,48 @@ function until(r) {
 function defaultComparator(value, othVal) {
   return value === othVal;
 }
+// @__NO_SIDE_EFFECTS__
 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 computed(() => toValue(list).filter((x) => toValue(values).findIndex((y) => compareFn(x, y)) === -1));
+  const diff1 = computed(() => toValue$1(list).filter((x) => toValue$1(values).findIndex((y) => compareFn(x, y)) === -1));
+  if (symmetric) {
+    const diff2 = computed(() => toValue$1(values).filter((x) => toValue$1(list).findIndex((y) => compareFn(x, y)) === -1));
+    return computed(() => symmetric ? [...toValue$1(diff1), ...toValue$1(diff2)] : toValue$1(diff1));
+  } else {
+    return diff1;
+  }
 }
 
+// @__NO_SIDE_EFFECTS__
 function useArrayEvery(list, fn) {
-  return computed(() => toValue(list).every((element, index, array) => fn(toValue(element), index, array)));
+  return computed(() => toValue$1(list).every((element, index, array) => fn(toValue$1(element), index, array)));
 }
 
+// @__NO_SIDE_EFFECTS__
 function useArrayFilter(list, fn) {
-  return computed(() => toValue(list).map((i) => toValue(i)).filter(fn));
+  return computed(() => toValue$1(list).map((i) => toValue$1(i)).filter(fn));
 }
 
+// @__NO_SIDE_EFFECTS__
 function useArrayFind(list, fn) {
-  return computed(() => toValue(
-    toValue(list).find((element, index, array) => fn(toValue(element), index, array))
+  return computed(() => toValue$1(
+    toValue$1(list).find((element, index, array) => fn(toValue$1(element), index, array))
   ));
 }
 
+// @__NO_SIDE_EFFECTS__
 function useArrayFindIndex(list, fn) {
-  return computed(() => toValue(list).findIndex((element, index, array) => fn(toValue(element), index, array)));
+  return computed(() => toValue$1(list).findIndex((element, index, array) => fn(toValue$1(element), index, array)));
 }
 
 function findLast(arr, cb) {
@@ -980,15 +1017,17 @@ function findLast(arr, cb) {
   }
   return void 0;
 }
+// @__NO_SIDE_EFFECTS__
 function useArrayFindLast(list, fn) {
-  return computed(() => toValue(
-    !Array.prototype.findLast ? findLast(toValue(list), (element, index, array) => fn(toValue(element), index, array)) : toValue(list).findLast((element, index, array) => fn(toValue(element), index, array))
+  return computed(() => toValue$1(
+    !Array.prototype.findLast ? findLast(toValue$1(list), (element, index, array) => fn(toValue$1(element), index, array)) : toValue$1(list).findLast((element, index, array) => fn(toValue$1(element), index, array))
   ));
 }
 
 function isArrayIncludesOptions(obj) {
   return isObject(obj) && containsProp(obj, "formIndex", "comparator");
 }
+// @__NO_SIDE_EFFECTS__
 function useArrayIncludes(...args) {
   var _a;
   const list = args[0];
@@ -1001,35 +1040,39 @@ function useArrayIncludes(...args) {
   }
   if (typeof comparator === "string") {
     const key = comparator;
-    comparator = (element, value2) => element[key] === toValue(value2);
+    comparator = (element, value2) => element[key] === toValue$1(value2);
   }
-  comparator = comparator != null ? comparator : (element, value2) => element === toValue(value2);
-  return computed(() => toValue(list).slice(formIndex).some((element, index, array) => comparator(
-    toValue(element),
-    toValue(value),
+  comparator = comparator != null ? comparator : (element, value2) => element === toValue$1(value2);
+  return computed(() => toValue$1(list).slice(formIndex).some((element, index, array) => comparator(
+    toValue$1(element),
+    toValue$1(value),
     index,
-    toValue(array)
+    toValue$1(array)
   )));
 }
 
+// @__NO_SIDE_EFFECTS__
 function useArrayJoin(list, separator) {
-  return computed(() => toValue(list).map((i) => toValue(i)).join(toValue(separator)));
+  return computed(() => toValue$1(list).map((i) => toValue$1(i)).join(toValue$1(separator)));
 }
 
+// @__NO_SIDE_EFFECTS__
 function useArrayMap(list, fn) {
-  return computed(() => toValue(list).map((i) => toValue(i)).map(fn));
+  return computed(() => toValue$1(list).map((i) => toValue$1(i)).map(fn));
 }
 
+// @__NO_SIDE_EFFECTS__
 function useArrayReduce(list, reducer, ...args) {
-  const reduceCallback = (sum, value, index) => reducer(toValue(sum), toValue(value), index);
+  const reduceCallback = (sum, value, index) => reducer(toValue$1(sum), toValue$1(value), index);
   return computed(() => {
-    const resolved = toValue(list);
-    return args.length ? resolved.reduce(reduceCallback, toValue(args[0])) : resolved.reduce(reduceCallback);
+    const resolved = toValue$1(list);
+    return args.length ? resolved.reduce(reduceCallback, typeof args[0] === "function" ? toValue$1(args[0]()) : toValue$1(args[0])) : resolved.reduce(reduceCallback);
   });
 }
 
+// @__NO_SIDE_EFFECTS__
 function useArraySome(list, fn) {
-  return computed(() => toValue(list).some((element, index, array) => fn(toValue(element), index, array)));
+  return computed(() => toValue$1(list).some((element, index, array) => fn(toValue$1(element), index, array)));
 }
 
 function uniq(array) {
@@ -1042,16 +1085,17 @@ function uniqueElementsBy(array, fn) {
     return acc;
   }, []);
 }
+// @__NO_SIDE_EFFECTS__
 function useArrayUnique(list, compareFn) {
   return computed(() => {
-    const resolvedList = toValue(list).map((element) => toValue(element));
+    const resolvedList = toValue$1(list).map((element) => toValue$1(element));
     return compareFn ? uniqueElementsBy(resolvedList, compareFn) : uniq(resolvedList);
   });
 }
 
 function useCounter(initialValue = 0, options = {}) {
   let _initialValue = unref(initialValue);
-  const count = ref(initialValue);
+  const count = shallowRef(initialValue);
   const {
     max = Number.POSITIVE_INFINITY,
     min = Number.NEGATIVE_INFINITY
@@ -1064,11 +1108,11 @@ function useCounter(initialValue = 0, options = {}) {
     _initialValue = val;
     return set(val);
   };
-  return { count, inc, dec, get, set, reset };
+  return { count: shallowReadonly(count), inc, dec, get, set, reset };
 }
 
 const REGEX_PARSE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[T\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/i;
-const REGEX_FORMAT = /[YMDHhms]o|\[([^\]]+)\]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a{1,2}|A{1,2}|m{1,2}|s{1,2}|Z{1,2}|SSS/g;
+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)
@@ -1091,6 +1135,10 @@ function formatDate(date, formatStr, options = {}) {
   const milliseconds = date.getMilliseconds();
   const day = date.getDay();
   const meridiem = (_a = options.customMeridiem) != null ? _a : defaultMeridiem;
+  const stripTimeZone = (dateString) => {
+    var _a2;
+    return (_a2 = dateString.split(" ")[1]) != null ? _a2 : "";
+  };
   const matches = {
     Yo: () => formatOrdinal(years),
     YY: () => String(years).slice(-2),
@@ -1098,8 +1146,8 @@ function formatDate(date, formatStr, options = {}) {
     M: () => month + 1,
     Mo: () => formatOrdinal(month + 1),
     MM: () => `${month + 1}`.padStart(2, "0"),
-    MMM: () => date.toLocaleDateString(options.locales, { month: "short" }),
-    MMMM: () => date.toLocaleDateString(options.locales, { month: "long" }),
+    MMM: () => date.toLocaleDateString(toValue$1(options.locales), { month: "short" }),
+    MMMM: () => date.toLocaleDateString(toValue$1(options.locales), { month: "long" }),
     D: () => String(days),
     Do: () => formatOrdinal(days),
     DD: () => `${days}`.padStart(2, "0"),
@@ -1117,13 +1165,17 @@ function formatDate(date, formatStr, options = {}) {
     ss: () => `${seconds}`.padStart(2, "0"),
     SSS: () => `${milliseconds}`.padStart(3, "0"),
     d: () => day,
-    dd: () => date.toLocaleDateString(options.locales, { weekday: "narrow" }),
-    ddd: () => date.toLocaleDateString(options.locales, { weekday: "short" }),
-    dddd: () => date.toLocaleDateString(options.locales, { weekday: "long" }),
+    dd: () => date.toLocaleDateString(toValue$1(options.locales), { weekday: "narrow" }),
+    ddd: () => date.toLocaleDateString(toValue$1(options.locales), { weekday: "short" }),
+    dddd: () => date.toLocaleDateString(toValue$1(options.locales), { weekday: "long" }),
     A: () => meridiem(hours, minutes),
     AA: () => meridiem(hours, minutes, false, true),
     a: () => meridiem(hours, minutes, true),
-    aa: () => meridiem(hours, minutes, true, true)
+    aa: () => meridiem(hours, minutes, true, true),
+    z: () => stripTimeZone(date.toLocaleDateString(toValue$1(options.locales), { timeZoneName: "shortOffset" })),
+    zz: () => stripTimeZone(date.toLocaleDateString(toValue$1(options.locales), { timeZoneName: "shortOffset" })),
+    zzz: () => stripTimeZone(date.toLocaleDateString(toValue$1(options.locales), { timeZoneName: "shortOffset" })),
+    zzzz: () => stripTimeZone(date.toLocaleDateString(toValue$1(options.locales), { timeZoneName: "longOffset" }))
   };
   return formatStr.replace(REGEX_FORMAT, (match, $1) => {
     var _a2, _b;
@@ -1147,8 +1199,9 @@ function normalizeDate(date) {
   }
   return new Date(date);
 }
+// @__NO_SIDE_EFFECTS__
 function useDateFormat(date, formatStr = "HH:mm:ss", options = {}) {
-  return computed(() => formatDate(normalizeDate(toValue(date)), toValue(formatStr), options));
+  return computed(() => formatDate(normalizeDate(toValue$1(date)), toValue$1(formatStr), options));
 }
 
 function useIntervalFn(cb, interval = 1e3, options = {}) {
@@ -1157,7 +1210,7 @@ function useIntervalFn(cb, interval = 1e3, options = {}) {
     immediateCallback = false
   } = options;
   let timer = null;
-  const isActive = ref(false);
+  const isActive = shallowRef(false);
   function clean() {
     if (timer) {
       clearInterval(timer);
@@ -1169,14 +1222,15 @@ function useIntervalFn(cb, interval = 1e3, options = {}) {
     clean();
   }
   function resume() {
-    const intervalValue = toValue(interval);
+    const intervalValue = toValue$1(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();
@@ -1189,7 +1243,7 @@ function useIntervalFn(cb, interval = 1e3, options = {}) {
   }
   tryOnScopeDispose(pause);
   return {
-    isActive,
+    isActive: shallowReadonly(isActive),
     pause,
     resume
   };
@@ -1201,7 +1255,7 @@ function useInterval(interval = 1e3, options = {}) {
     immediate = true,
     callback
   } = options;
-  const counter = ref(0);
+  const counter = shallowRef(0);
   const update = () => counter.value += 1;
   const reset = () => {
     counter.value = 0;
@@ -1216,36 +1270,37 @@ function useInterval(interval = 1e3, options = {}) {
   );
   if (exposeControls) {
     return {
-      counter,
+      counter: shallowReadonly(counter),
       reset,
       ...controls
     };
   } else {
-    return counter;
+    return shallowReadonly(counter);
   }
 }
 
 function useLastChanged(source, options = {}) {
   var _a;
-  const ms = ref((_a = options.initialValue) != null ? _a : null);
+  const ms = shallowRef((_a = options.initialValue) != null ? _a : null);
   watch(
     source,
     () => ms.value = timestamp(),
     options
   );
-  return ms;
+  return shallowReadonly(ms);
 }
 
 function useTimeoutFn(cb, interval, options = {}) {
   const {
-    immediate = true
+    immediate = true,
+    immediateCallback = false
   } = options;
-  const isPending = ref(false);
-  let timer = null;
+  const isPending = shallowRef(false);
+  let timer;
   function clear() {
     if (timer) {
       clearTimeout(timer);
-      timer = null;
+      timer = void 0;
     }
   }
   function stop() {
@@ -1253,13 +1308,15 @@ function useTimeoutFn(cb, interval, options = {}) {
     clear();
   }
   function start(...args) {
+    if (immediateCallback)
+      cb();
     clear();
     isPending.value = true;
     timer = setTimeout(() => {
       isPending.value = false;
-      timer = null;
+      timer = void 0;
       cb(...args);
-    }, toValue(interval));
+    }, toValue$1(interval));
   }
   if (immediate) {
     isPending.value = true;
@@ -1268,7 +1325,7 @@ function useTimeoutFn(cb, interval, options = {}) {
   }
   tryOnScopeDispose(stop);
   return {
-    isPending: readonly(isPending),
+    isPending: shallowReadonly(isPending),
     start,
     stop
   };
@@ -1295,6 +1352,7 @@ function useTimeout(interval = 1e3, options = {}) {
   }
 }
 
+// @__NO_SIDE_EFFECTS__
 function useToNumber(value, options = {}) {
   const {
     method = "parseFloat",
@@ -1302,8 +1360,10 @@ function useToNumber(value, options = {}) {
     nanToZero
   } = options;
   return computed(() => {
-    let resolved = toValue(value);
-    if (typeof resolved === "string")
+    let resolved = toValue$1(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;
@@ -1311,24 +1371,26 @@ function useToNumber(value, options = {}) {
   });
 }
 
+// @__NO_SIDE_EFFECTS__
 function useToString(value) {
-  return computed(() => `${toValue(value)}`);
+  return computed(() => `${toValue$1(value)}`);
 }
 
+// @__NO_SIDE_EFFECTS__
 function useToggle(initialValue = false, options = {}) {
   const {
     truthyValue = true,
     falsyValue = false
   } = options;
   const valueIsRef = isRef(initialValue);
-  const _value = ref(initialValue);
+  const _value = shallowRef(initialValue);
   function toggle(value) {
     if (arguments.length) {
       _value.value = value;
       return _value.value;
     } else {
-      const truthy = toValue(truthyValue);
-      _value.value = _value.value === truthy ? toValue(falsyValue) : truthy;
+      const truthy = toValue$1(truthyValue);
+      _value.value = _value.value === truthy ? toValue$1(falsyValue) : truthy;
       return _value.value;
     }
   }
@@ -1339,7 +1401,7 @@ function useToggle(initialValue = false, options = {}) {
 }
 
 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) ? [] : [...typeof source === "function" ? source() : Array.isArray(source) ? source : toValue$1(source)];
   return watch(source, (newList, _, onCleanup) => {
     const oldListRemains = Array.from({ length: oldList.length });
     const added = [];
@@ -1366,12 +1428,12 @@ function watchAtMost(source, cb, options) {
     count,
     ...watchOptions
   } = options;
-  const current = ref(0);
+  const current = shallowRef(0);
   const stop = watchWithFilter(
     source,
     (...args) => {
       current.value += 1;
-      if (current.value >= toValue(count))
+      if (current.value >= toValue$1(count))
         nextTick(() => stop());
       cb(...args);
     },
@@ -1420,50 +1482,50 @@ function watchIgnorable(source, cb, options = {}) {
   let ignorePrevAsyncUpdates;
   let stop;
   if (watchOptions.flush === "sync") {
-    const ignore = ref(false);
+    let ignore = false;
     ignorePrevAsyncUpdates = () => {
     };
     ignoreUpdates = (updater) => {
-      ignore.value = true;
+      ignore = true;
       updater();
-      ignore.value = false;
+      ignore = false;
     };
     stop = watch(
       source,
       (...args) => {
-        if (!ignore.value)
+        if (!ignore)
           filteredCb(...args);
       },
       watchOptions
     );
   } else {
     const disposables = [];
-    const ignoreCounter = ref(0);
-    const syncCounter = ref(0);
+    let ignoreCounter = 0;
+    let syncCounter = 0;
     ignorePrevAsyncUpdates = () => {
-      ignoreCounter.value = syncCounter.value;
+      ignoreCounter = syncCounter;
     };
     disposables.push(
       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(
       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);
@@ -1490,11 +1552,14 @@ function watchImmediate(source, cb, options) {
 }
 
 function watchOnce(source, cb, options) {
-  const stop = watch(source, (...args) => {
-    nextTick(() => stop());
-    return cb(...args);
-  }, options);
-  return stop;
+  return watch(
+    source,
+    cb,
+    {
+      ...options,
+      once: true
+    }
+  );
 }
 
 function watchThrottled(source, cb, options = {}) {
@@ -1548,8 +1613,8 @@ function getWatchSources(sources) {
   if (isReactive(sources))
     return sources;
   if (Array.isArray(sources))
-    return sources.map((item) => toValue(item));
-  return toValue(sources);
+    return sources.map((item) => toValue$1(item));
+  return toValue$1(sources);
 }
 function getOldValue(source) {
   return Array.isArray(source) ? source.map(() => void 0) : void 0;
@@ -1573,4 +1638,4 @@ function whenever(source, cb, options) {
   return stop;
 }
 
-export { assert, refAutoReset as autoResetRef, bypassFilter, camelize, clamp, computedEager, computedWithControl, containsProp, computedWithControl as controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, reactify as createReactiveFn, createSharedComposable, createSingletonPromise, debounceFilter, refDebounced as debouncedRef, watchDebounced as debouncedWatch, directiveHooks, computedEager as eagerComputed, extendRef, formatDate, get, getLifeCycleTarget, hasOwn, hyphenate, identity, watchIgnorable as ignorableWatch, increaseWithUnit, injectLocal, invoke, isClient, isDef, isDefined, isIOS, isObject, isWorker, makeDestructurable, noop, normalizeDate, notNullish, now, objectEntries, objectOmit, objectPick, pausableFilter, watchPausable as pausableWatch, promiseTimeout, provideLocal, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refThrottled, refWithControl, resolveRef, resolveUnref, set, syncRef, syncRefs, throttleFilter, refThrottled as throttledRef, watchThrottled as throttledWatch, timestamp, toReactive, toRef, toRefs, toValue, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayDifference, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayFindLast, useArrayIncludes, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useArrayUnique, useCounter, useDateFormat, refDebounced as useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, refThrottled as useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToNumber, useToString, useToggle, watchArray, watchAtMost, watchDebounced, watchDeep, watchIgnorable, watchImmediate, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };
+export { assert, refAutoReset as autoResetRef, bypassFilter, camelize, clamp, computedEager, computedWithControl, containsProp, computedWithControl as controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, reactify as createReactiveFn, createRef, createSharedComposable, createSingletonPromise, debounceFilter, refDebounced as debouncedRef, watchDebounced as debouncedWatch, computedEager as eagerComputed, extendRef, formatDate, get, getLifeCycleTarget, hasOwn, hyphenate, identity, watchIgnorable as ignorableWatch, increaseWithUnit, injectLocal, invoke, isClient, isDef, isDefined, isIOS, isObject, isWorker, makeDestructurable, noop, normalizeDate, notNullish, now, objectEntries, objectOmit, objectPick, pausableFilter, watchPausable as pausableWatch, promiseTimeout, provideLocal, pxValue, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refThrottled, refWithControl, resolveRef, resolveUnref, set, syncRef, syncRefs, throttleFilter, refThrottled as throttledRef, watchThrottled as throttledWatch, timestamp, toArray, toReactive, toRef, toRefs, toValue, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayDifference, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayFindLast, useArrayIncludes, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useArrayUnique, useCounter, useDateFormat, refDebounced as useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, refThrottled as useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToNumber, useToString, useToggle, watchArray, watchAtMost, watchDebounced, watchDeep, watchIgnorable, watchImmediate, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };