@maizzle/framework 6.0.0-rc.9 → 6.0.0

package/dist/server/ui/.vite/deps/@vueuse_shared.js

@@ -0,0 +1,1859 @@
+import { $n as toRef$1, Bt as onUnmounted, Gn as reactive, Hn as onScopeDispose, It as onMounted, Kn as readonly, Ln as isReactive, Mt as onBeforeUnmount, Nn as effectScope, Pn as getCurrentScope, St as inject, W as computed, Wt as provide, Xn as shallowRef, Yn as shallowReadonly, _n as watch, dt as getCurrentInstance, er as toRefs$1, gt as hasInjectionContext, jn as customRef, jt as onBeforeMount, kt as nextTick, qn as ref, rr as unref, tr as toValue, vn as watchEffect, zn as isRef } from "./vue.runtime.esm-bundler-DaqjATE_.js";
+//#region ../../home/cosmin/Work/maizzle/framework/node_modules/@vueuse/shared/dist/index.js
+/**
+*
+* @deprecated This function will be removed in future version.
+*
+* Note: If you are using Vue 3.4+, you can straight use computed instead.
+* Because in Vue 3.4+, if computed new value does not change,
+* computed, effect, watch, watchEffect, render dependencies will not be triggered.
+* refer: https://github.com/vuejs/core/pull/5912
+*
+* @param fn effect function
+* @param options WatchOptionsBase
+* @returns readonly shallowRef
+*/
+function computedEager(fn, options) {
+	var _options$flush;
+	const result = shallowRef();
+	watchEffect(() => {
+		result.value = fn();
+	}, {
+		...options,
+		flush: (_options$flush = options === null || options === void 0 ? void 0 : options.flush) !== null && _options$flush !== void 0 ? _options$flush : "sync"
+	});
+	return readonly(result);
+}
+/** @deprecated use `computedEager` instead */
+var eagerComputed = computedEager;
+/**
+* Explicitly define the deps of computed.
+*
+* @param source
+* @param fn
+*/
+function computedWithControl(source, fn, options = {}) {
+	let v = void 0;
+	let track;
+	let trigger;
+	let dirty = true;
+	const update = () => {
+		dirty = true;
+		trigger();
+	};
+	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) => {
+		track = _track;
+		trigger = _trigger;
+		return {
+			get() {
+				if (dirty) {
+					v = get(v);
+					dirty = false;
+				}
+				track();
+				return v;
+			},
+			set(v) {
+				set === null || set === void 0 || set(v);
+			}
+		};
+	});
+	result.trigger = update;
+	return result;
+}
+/** @deprecated use `computedWithControl` instead */
+var controlledComputed = computedWithControl;
+/**
+* Utility for authoring disposable directives. Reactive effects created within `mounted` directive hook will be tracked and automatically disposed when directive is unmounted.
+*
+* @see https://vueuse.org/createDisposableDirective
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function createDisposableDirective(origin = {}) {
+	function isFunc(fn) {
+		return typeof fn === "function";
+	}
+	const normalisedOrigin = isFunc(origin) ? {
+		mounted: origin,
+		updated: origin
+	} : origin;
+	const { mounted, unmounted } = normalisedOrigin;
+	if (!isFunc(mounted)) return origin;
+	const scopeWeakMap = /* @__PURE__ */ new WeakMap();
+	return {
+		...normalisedOrigin,
+		mounted(el, binding, vNode, prevNode) {
+			var _scopeWeakMap$get;
+			const scope = (_scopeWeakMap$get = scopeWeakMap.get(el)) !== null && _scopeWeakMap$get !== void 0 ? _scopeWeakMap$get : effectScope();
+			scopeWeakMap.set(el, scope);
+			scope.run(() => {
+				mounted === null || mounted === void 0 || mounted(el, binding, vNode, prevNode);
+			});
+		},
+		unmounted(el, binding, vNode, prevNode) {
+			var _scopeWeakMap$get2;
+			(_scopeWeakMap$get2 = scopeWeakMap.get(el)) === null || _scopeWeakMap$get2 === void 0 || _scopeWeakMap$get2.stop();
+			scopeWeakMap.delete(el);
+			if (isFunc(unmounted)) unmounted(el, binding, vNode, prevNode);
+		}
+	};
+}
+/**
+* Call onScopeDispose() if it's inside an effect scope lifecycle, if not, do nothing
+*
+* @param fn
+*/
+function tryOnScopeDispose(fn, failSilently) {
+	if (getCurrentScope()) {
+		onScopeDispose(fn, failSilently);
+		return true;
+	}
+	return false;
+}
+/**
+* Utility for creating event hooks
+*
+* @see https://vueuse.org/createEventHook
+*
+* @__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);
+		tryOnScopeDispose(offFn);
+		return { off: offFn };
+	};
+	const trigger = (...args) => {
+		return Promise.all(Array.from(fns).map((fn) => fn(...args)));
+	};
+	return {
+		on,
+		off,
+		trigger,
+		clear
+	};
+}
+/**
+* Keep states in the global scope to be reusable across Vue instances.
+*
+* @see https://vueuse.org/createGlobalState
+* @param stateFactory A factory function to create the state
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function createGlobalState(stateFactory) {
+	let initialized = false;
+	let state;
+	const scope = effectScope(true);
+	return ((...args) => {
+		if (!initialized) {
+			state = scope.run(() => stateFactory(...args));
+			initialized = true;
+		}
+		return state;
+	});
+}
+var localProvidedStateMap = /* @__PURE__ */ new WeakMap();
+/**
+* On the basis of `inject`, it is allowed to directly call inject to obtain the value after call provide in the same component.
+*
+* @example
+* ```ts
+* injectLocal('MyInjectionKey', 1)
+* const injectedValue = injectLocal('MyInjectionKey') // injectedValue === 1
+* ```
+*
+* @__NO_SIDE_EFFECTS__
+*/
+var injectLocal = (...args) => {
+	var _getCurrentInstance;
+	const key = args[0];
+	const instance = (_getCurrentInstance = getCurrentInstance()) === null || _getCurrentInstance === void 0 ? void 0 : _getCurrentInstance.proxy;
+	const owner = instance !== null && instance !== void 0 ? instance : getCurrentScope();
+	if (owner == null && !hasInjectionContext()) throw new Error("injectLocal must be called in setup");
+	if (owner && localProvidedStateMap.has(owner) && key in localProvidedStateMap.get(owner)) return localProvidedStateMap.get(owner)[key];
+	return inject(...args);
+};
+/**
+* On the basis of `provide`, it is allowed to directly call inject to obtain the value after call provide in the same component.
+*
+* @example
+* ```ts
+* provideLocal('MyInjectionKey', 1)
+* const injectedValue = injectLocal('MyInjectionKey') // injectedValue === 1
+* ```
+*/
+function provideLocal(key, value) {
+	var _getCurrentInstance;
+	const instance = (_getCurrentInstance = getCurrentInstance()) === null || _getCurrentInstance === void 0 ? void 0 : _getCurrentInstance.proxy;
+	const owner = instance !== null && instance !== void 0 ? instance : getCurrentScope();
+	if (owner == null) throw new Error("provideLocal must be called in setup");
+	if (!localProvidedStateMap.has(owner)) localProvidedStateMap.set(owner, Object.create(null));
+	const localProvidedState = localProvidedStateMap.get(owner);
+	localProvidedState[key] = value;
+	return provide(key, value);
+}
+function createInjectionState(composable, options) {
+	const key = (options === null || options === void 0 ? void 0 : options.injectionKey) || Symbol(composable.name || "InjectionState");
+	const defaultValue = options === null || options === void 0 ? void 0 : options.defaultValue;
+	const useProvidingState = (...args) => {
+		const state = composable(...args);
+		provideLocal(key, state);
+		return state;
+	};
+	const useInjectedState = () => injectLocal(key, defaultValue);
+	return [useProvidingState, useInjectedState];
+}
+/**
+* Returns a `deepRef` or `shallowRef` depending on the `deep` param.
+*
+* @example createRef(1) // ShallowRef<number>
+* @example createRef(1, false) // ShallowRef<number>
+* @example createRef(1, true) // Ref<number>
+* @example createRef("string") // ShallowRef<string>
+* @example createRef<"A"|"B">("A", true) // Ref<"A"|"B">
+*
+* @param value
+* @param deep
+* @returns the `deepRef` or `shallowRef`
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function createRef(value, deep) {
+	if (deep === true) return ref(value);
+	else return shallowRef(value);
+}
+var isClient = typeof window !== "undefined" && typeof document !== "undefined";
+var isWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+var isDef = (val) => typeof val !== "undefined";
+var notNullish = (val) => val != null;
+var assert = (condition, ...infos) => {
+	if (!condition) console.warn(...infos);
+};
+var toString = Object.prototype.toString;
+var isObject = (val) => toString.call(val) === "[object Object]";
+var now = () => Date.now();
+var timestamp = () => +Date.now();
+var clamp = (n, min, max) => Math.min(max, Math.max(min, n));
+var noop = () => {};
+var rand = (min, max) => {
+	min = Math.ceil(min);
+	max = Math.floor(max);
+	return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+var hasOwn = (val, key) => Object.hasOwn(val, key);
+var isIOS = /* @__PURE__ */ getIsIOS();
+function getIsIOS() {
+	var _window, _window2, _window3;
+	return isClient && !!((_window = window) === null || _window === void 0 || (_window = _window.navigator) === null || _window === void 0 ? void 0 : _window.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((_window2 = window) === null || _window2 === void 0 || (_window2 = _window2.navigator) === null || _window2 === void 0 ? void 0 : _window2.maxTouchPoints) > 2 && /iPad|Macintosh/.test((_window3 = window) === null || _window3 === void 0 ? void 0 : _window3.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);
+}
+/**
+* @internal
+*/
+function createFilterWrapper(filter, fn) {
+	function wrapper(...args) {
+		return new Promise((resolve, reject) => {
+			Promise.resolve(filter(() => fn.apply(this, args), {
+				fn,
+				thisArg: this,
+				args
+			})).then(resolve).catch(reject);
+		});
+	}
+	return wrapper;
+}
+var bypassFilter = (invoke) => {
+	return invoke();
+};
+/**
+* Create an EventFilter that debounce the events
+*/
+function debounceFilter(ms, options = {}) {
+	let timer;
+	let maxTimer;
+	let lastRejector = noop;
+	const _clearTimeout = (timer) => {
+		clearTimeout(timer);
+		lastRejector();
+		lastRejector = noop;
+	};
+	let lastInvoker;
+	const filter = (invoke) => {
+		const duration = toValue(ms);
+		const maxDuration = toValue(options.maxWait);
+		if (timer) _clearTimeout(timer);
+		if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
+			if (maxTimer) {
+				_clearTimeout(maxTimer);
+				maxTimer = 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 = void 0;
+				resolve(lastInvoker());
+			}, maxDuration);
+			timer = setTimeout(() => {
+				if (maxTimer) _clearTimeout(maxTimer);
+				maxTimer = void 0;
+				resolve(invoke());
+			}, duration);
+		});
+	};
+	return filter;
+}
+function throttleFilter(...args) {
+	let lastExec = 0;
+	let timer;
+	let isLeading = true;
+	let lastRejector = noop;
+	let lastValue;
+	let ms;
+	let trailing;
+	let leading;
+	let rejectOnCancel;
+	if (!isRef(args[0]) && typeof args[0] === "object") ({delay: ms, trailing = true, leading = true, rejectOnCancel = false} = args[0]);
+	else [ms, trailing = true, leading = true, rejectOnCancel = false] = args;
+	const clear = () => {
+		if (timer) {
+			clearTimeout(timer);
+			timer = void 0;
+			lastRejector();
+			lastRejector = noop;
+		}
+	};
+	const filter = (_invoke) => {
+		const duration = toValue(ms);
+		const elapsed = Date.now() - lastExec;
+		const invoke = () => {
+			return lastValue = _invoke();
+		};
+		clear();
+		if (duration <= 0) {
+			lastExec = Date.now();
+			return invoke();
+		}
+		if (elapsed > duration) {
+			lastExec = Date.now();
+			if (leading || !isLeading) invoke();
+		} else if (trailing) lastValue = new Promise((resolve, reject) => {
+			lastRejector = rejectOnCancel ? reject : resolve;
+			timer = setTimeout(() => {
+				lastExec = Date.now();
+				isLeading = true;
+				resolve(invoke());
+				clear();
+			}, Math.max(0, duration - elapsed));
+		});
+		if (!leading && !timer) timer = setTimeout(() => isLeading = true, duration);
+		isLeading = false;
+		return lastValue;
+	};
+	return filter;
+}
+/**
+* EventFilter that gives extra controls to pause and resume the filter
+*
+* @param extendFilter  Extra filter to apply when the PausableFilter is active, default to none
+* @param options Options to configure the filter
+*/
+function pausableFilter(extendFilter = bypassFilter, options = {}) {
+	const { initialState = "active" } = options;
+	const isActive = toRef(initialState === "active");
+	function pause() {
+		isActive.value = false;
+	}
+	function resume() {
+		isActive.value = true;
+	}
+	const eventFilter = (...args) => {
+		if (isActive.value) extendFilter(...args);
+	};
+	return {
+		isActive: shallowReadonly(isActive),
+		pause,
+		resume,
+		eventFilter
+	};
+}
+function promiseTimeout(ms, throwOnTimeout = false, reason = "Timeout") {
+	return new Promise((resolve, reject) => {
+		if (throwOnTimeout) setTimeout(reject, ms, reason);
+		else setTimeout(resolve, ms);
+	});
+}
+function identity(arg) {
+	return arg;
+}
+/**
+* Create singleton promise function
+*
+* @example
+* ```
+* const promise = createSingletonPromise(async () => { ... })
+*
+* await promise()
+* await promise() // all of them will be bind to a single promise instance
+* await promise() // and be resolved together
+* ```
+*/
+function createSingletonPromise(fn) {
+	let _promise;
+	function wrapper() {
+		if (!_promise) _promise = fn();
+		return _promise;
+	}
+	wrapper.reset = async () => {
+		const _prev = _promise;
+		_promise = void 0;
+		if (_prev) await _prev;
+	};
+	return wrapper;
+}
+function invoke(fn) {
+	return fn();
+}
+function containsProp(obj, ...props) {
+	return props.some((k) => k in obj);
+}
+function increaseWithUnit(target, delta) {
+	var _target$match;
+	if (typeof target === "number") return target + delta;
+	const value = ((_target$match = target.match(/^-?\d+\.?\d*/)) === null || _target$match === void 0 ? void 0 : _target$match[0]) || "";
+	const unit = target.slice(value.length);
+	const result = Number.parseFloat(value) + delta;
+	if (Number.isNaN(result)) return target;
+	return result + unit;
+}
+/**
+* Get a px value for SSR use, do not rely on this method outside of SSR as REM unit is assumed at 16px, which might not be the case on the client
+*/
+function pxValue(px) {
+	return px.endsWith("rem") ? Number.parseFloat(px) * 16 : Number.parseFloat(px);
+}
+/**
+* Create a new subset object by giving keys
+*/
+function objectPick(obj, keys, omitUndefined = false) {
+	return keys.reduce((n, k) => {
+		if (k in obj) {
+			if (!omitUndefined || obj[k] !== void 0) n[k] = obj[k];
+		}
+		return n;
+	}, {});
+}
+/**
+* Create a new subset object by omit giving keys
+*/
+function objectOmit(obj, keys, omitUndefined = false) {
+	return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {
+		return (!omitUndefined || value !== void 0) && !keys.includes(key);
+	}));
+}
+function objectEntries(obj) {
+	return Object.entries(obj);
+}
+function toArray(value) {
+	return Array.isArray(value) ? value : [value];
+}
+function cacheStringFunction(fn) {
+	const cache = Object.create(null);
+	return ((str) => {
+		return cache[str] || (cache[str] = fn(str));
+	});
+}
+var hyphenateRE = /\B([A-Z])/g;
+var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
+var camelizeRE = /-(\w)/g;
+var camelize = cacheStringFunction((str) => {
+	return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
+});
+function getLifeCycleTarget(target) {
+	return target || getCurrentInstance();
+}
+/**
+* Make a composable function usable with multiple Vue instances.
+*
+* @see https://vueuse.org/createSharedComposable
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function createSharedComposable(composable) {
+	if (!isClient) return composable;
+	let subscribers = 0;
+	let state;
+	let scope;
+	const dispose = () => {
+		subscribers -= 1;
+		if (scope && subscribers <= 0) {
+			scope.stop();
+			state = void 0;
+			scope = void 0;
+		}
+	};
+	return ((...args) => {
+		subscribers += 1;
+		if (!scope) {
+			scope = effectScope(true);
+			state = scope.run(() => composable(...args));
+		}
+		tryOnScopeDispose(dispose);
+		return state;
+	});
+}
+function extendRef(ref, extend, { enumerable = false, unwrap = true } = {}) {
+	for (const [key, value] of Object.entries(extend)) {
+		if (key === "value") continue;
+		if (isRef(value) && unwrap) Object.defineProperty(ref, key, {
+			get() {
+				return value.value;
+			},
+			set(v) {
+				value.value = v;
+			},
+			enumerable
+		});
+		else Object.defineProperty(ref, key, {
+			value,
+			enumerable
+		});
+	}
+	return ref;
+}
+function get(obj, key) {
+	if (key == null) return unref(obj);
+	return unref(obj)[key];
+}
+function isDefined(v) {
+	return unref(v) != null;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function makeDestructurable(obj, arr) {
+	if (typeof Symbol !== "undefined") {
+		const clone = { ...obj };
+		Object.defineProperty(clone, Symbol.iterator, {
+			enumerable: false,
+			value() {
+				let index = 0;
+				return { next: () => ({
+					value: arr[index++],
+					done: index > arr.length
+				}) };
+			}
+		});
+		return clone;
+	} else return Object.assign([...arr], obj);
+}
+/**
+* Converts plain function into a reactive function.
+* The converted function accepts refs as it's arguments
+* and returns a ComputedRef, with proper typing.
+*
+* @param fn - Source function
+* @param options - Options
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function reactify(fn, options) {
+	const unrefFn = (options === null || options === void 0 ? void 0 : options.computedGetter) === false ? unref : toValue;
+	return function(...args) {
+		return computed(() => fn.apply(this, args.map((i) => unrefFn(i))));
+	};
+}
+/** @deprecated use `reactify` instead */
+var createReactiveFn = reactify;
+/**
+* Apply `reactify` to an object
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function reactifyObject(obj, optionsOrKeys = {}) {
+	let keys = [];
+	let options;
+	if (Array.isArray(optionsOrKeys)) keys = optionsOrKeys;
+	else {
+		options = optionsOrKeys;
+		const { includeOwnProperties = true } = optionsOrKeys;
+		keys.push(...Object.keys(obj));
+		if (includeOwnProperties) keys.push(...Object.getOwnPropertyNames(obj));
+	}
+	return Object.fromEntries(keys.map((key) => {
+		const value = obj[key];
+		return [key, typeof value === "function" ? reactify(value.bind(obj), options) : value];
+	}));
+}
+/**
+* Converts ref to reactive.
+*
+* @see https://vueuse.org/toReactive
+* @param objectRef A ref of object
+*/
+function toReactive(objectRef) {
+	if (!isRef(objectRef)) return reactive(objectRef);
+	return reactive(new Proxy({}, {
+		get(_, p, receiver) {
+			return unref(Reflect.get(objectRef.value, p, receiver));
+		},
+		set(_, p, value) {
+			if (isRef(objectRef.value[p]) && !isRef(value)) objectRef.value[p].value = value;
+			else objectRef.value[p] = value;
+			return true;
+		},
+		deleteProperty(_, p) {
+			return Reflect.deleteProperty(objectRef.value, p);
+		},
+		has(_, p) {
+			return Reflect.has(objectRef.value, p);
+		},
+		ownKeys() {
+			return Object.keys(objectRef.value);
+		},
+		getOwnPropertyDescriptor() {
+			return {
+				enumerable: true,
+				configurable: true
+			};
+		}
+	}));
+}
+/**
+* Computed reactive object.
+*/
+function reactiveComputed(fn) {
+	return toReactive(computed(fn));
+}
+/**
+* Reactively omit fields from a reactive object
+*
+* @see https://vueuse.org/reactiveOmit
+*/
+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]))));
+}
+/**
+* Reactively pick fields from a reactive object
+*
+* @see https://vueuse.org/reactivePick
+*/
+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)])));
+}
+/**
+* Create a ref which will be reset to the default value after some time.
+*
+* @see https://vueuse.org/refAutoReset
+* @param defaultValue The value which will be set.
+* @param afterMs      A zero-or-greater delay in milliseconds.
+*/
+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();
+			}
+		};
+	});
+}
+/** @deprecated use `refAutoReset` instead */
+var autoResetRef = refAutoReset;
+/**
+* Debounce execution of a function.
+*
+* @see https://vueuse.org/useDebounceFn
+* @param  fn          A function to be executed after delay milliseconds debounced.
+* @param  ms          A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
+* @param  options     Options
+*
+* @return A new, debounce, function.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useDebounceFn(fn, ms = 200, options = {}) {
+	return createFilterWrapper(debounceFilter(ms, options), fn);
+}
+/**
+* Debounce updates of a ref.
+*
+* @return A new debounced ref.
+*/
+function refDebounced(value, ms = 200, options = {}) {
+	const debounced = ref(toValue(value));
+	const updater = useDebounceFn(() => {
+		debounced.value = value.value;
+	}, ms, options);
+	watch(value, () => updater());
+	return shallowReadonly(debounced);
+}
+/** @deprecated use `refDebounced` instead */
+var debouncedRef = refDebounced;
+/** @deprecated use `refDebounced` instead */
+var useDebounce = refDebounced;
+/**
+* Apply default value to a ref.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function refDefault(source, defaultValue) {
+	return computed({
+		get() {
+			var _source$value;
+			return (_source$value = source.value) !== null && _source$value !== void 0 ? _source$value : defaultValue;
+		},
+		set(value) {
+			source.value = value;
+		}
+	});
+}
+/**
+* Create a ref with manual reset functionality.
+*
+* @see https://vueuse.org/refManualReset
+* @param defaultValue The value which will be set.
+*/
+function refManualReset(defaultValue) {
+	let value = toValue(defaultValue);
+	let trigger;
+	const reset = () => {
+		value = toValue(defaultValue);
+		trigger();
+	};
+	const refValue = customRef((track, _trigger) => {
+		trigger = _trigger;
+		return {
+			get() {
+				track();
+				return value;
+			},
+			set(newValue) {
+				value = newValue;
+				trigger();
+			}
+		};
+	});
+	refValue.reset = reset;
+	return refValue;
+}
+/**
+* Throttle execution of a function. Especially useful for rate limiting
+* execution of handlers on events like resize and scroll.
+*
+* @param   fn             A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,
+*                                    to `callback` when the throttled-function is executed.
+* @param   ms             A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
+*                                    (default value: 200)
+*
+* @param [trailing] if true, call fn again after the time is up (default value: false)
+*
+* @param [leading] if true, call fn on the leading edge of the ms timeout (default value: true)
+*
+* @param [rejectOnCancel] if true, reject the last call if it's been cancel (default value: false)
+*
+* @return  A new, throttled, function.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
+	return createFilterWrapper(throttleFilter(ms, trailing, leading, rejectOnCancel), fn);
+}
+/**
+* Throttle execution of a function. Especially useful for rate limiting
+* execution of handlers on events like resize and scroll.
+*
+* @param value Ref value to be watched with throttle effect
+* @param  delay  A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
+* @param trailing if true, update the value again after the delay time is up
+* @param leading if true, update the value on the leading edge of the ms timeout
+*/
+function refThrottled(value, delay = 200, trailing = true, leading = true) {
+	if (delay <= 0) return value;
+	const throttled = ref(toValue(value));
+	const updater = useThrottleFn(() => {
+		throttled.value = value.value;
+	}, delay, trailing, leading);
+	watch(value, () => updater());
+	return throttled;
+}
+/** @deprecated use `refThrottled` instead */
+var throttledRef = refThrottled;
+/** @deprecated use `refThrottled` instead */
+var useThrottle = refThrottled;
+/**
+* Fine-grained controls over ref and its reactivity.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function refWithControl(initial, options = {}) {
+	let source = initial;
+	let track;
+	let trigger;
+	const ref = customRef((_track, _trigger) => {
+		track = _track;
+		trigger = _trigger;
+		return {
+			get() {
+				return get();
+			},
+			set(v) {
+				set(v);
+			}
+		};
+	});
+	function get(tracking = true) {
+		if (tracking) track();
+		return source;
+	}
+	function set(value, triggering = true) {
+		var _options$onBeforeChan, _options$onChanged;
+		if (value === source) return;
+		const old = source;
+		if (((_options$onBeforeChan = options.onBeforeChange) === null || _options$onBeforeChan === void 0 ? void 0 : _options$onBeforeChan.call(options, value, old)) === false) return;
+		source = value;
+		(_options$onChanged = options.onChanged) === null || _options$onChanged === void 0 || _options$onChanged.call(options, value, old);
+		if (triggering) trigger();
+	}
+	/**
+	* Get the value without tracked in the reactivity system
+	*/
+	const untrackedGet = () => get(false);
+	/**
+	* Set the value without triggering the reactivity system
+	*/
+	const silentSet = (v) => set(v, false);
+	/**
+	* Get the value without tracked in the reactivity system.
+	*
+	* Alias for `untrackedGet()`
+	*/
+	const peek = () => get(false);
+	/**
+	* Set the value without triggering the reactivity system
+	*
+	* Alias for `silentSet(v)`
+	*/
+	const lay = (v) => set(v, false);
+	return extendRef(ref, {
+		get,
+		set,
+		untrackedGet,
+		silentSet,
+		peek,
+		lay
+	}, { enumerable: true });
+}
+/** @deprecated use `refWithControl` instead */
+var controlledRef = refWithControl;
+/**
+*  Shorthand for `ref.value = x`
+*/
+function set(...args) {
+	if (args.length === 2) {
+		const [ref, value] = args;
+		ref.value = value;
+	}
+	if (args.length === 3) {
+		const [target, key, value] = args;
+		target[key] = value;
+	}
+}
+function watchWithFilter(source, cb, options = {}) {
+	const { eventFilter = bypassFilter, ...watchOptions } = options;
+	return watch(source, createFilterWrapper(eventFilter, cb), watchOptions);
+}
+/** @deprecated Use Vue's built-in `watch` instead. This function will be removed in future version. */
+function watchPausable(source, cb, options = {}) {
+	const { eventFilter: filter, initialState = "active", ...watchOptions } = options;
+	const { eventFilter, pause, resume, isActive } = pausableFilter(filter, { initialState });
+	return {
+		stop: watchWithFilter(source, cb, {
+			...watchOptions,
+			eventFilter
+		}),
+		pause,
+		resume,
+		isActive
+	};
+}
+/** @deprecated Use Vue's built-in `watch` instead. This function will be removed in future version. */
+var pausableWatch = watchPausable;
+/**
+* Two-way refs synchronization.
+* From the set theory perspective to restrict the option's type
+* Check in the following order:
+* 1. L = R
+* 2. L ∩ R ≠ ∅
+* 3. L ⊆ R
+* 4. L ∩ R = ∅
+*/
+function syncRef(left, right, ...[options]) {
+	const { flush = "sync", deep = false, immediate = true, direction = "both", transform = {} } = options || {};
+	const watchers = [];
+	const transformLTR = "ltr" in transform && transform.ltr || ((v) => v);
+	const transformRTL = "rtl" in transform && transform.rtl || ((v) => v);
+	if (direction === "both" || direction === "ltr") watchers.push(watchPausable(left, (newValue) => {
+		watchers.forEach((w) => w.pause());
+		right.value = transformLTR(newValue);
+		watchers.forEach((w) => w.resume());
+	}, {
+		flush,
+		deep,
+		immediate
+	}));
+	if (direction === "both" || direction === "rtl") watchers.push(watchPausable(right, (newValue) => {
+		watchers.forEach((w) => w.pause());
+		left.value = transformRTL(newValue);
+		watchers.forEach((w) => w.resume());
+	}, {
+		flush,
+		deep,
+		immediate
+	}));
+	const stop = () => {
+		watchers.forEach((w) => w.stop());
+	};
+	return stop;
+}
+/**
+* Keep target ref(s) in sync with the source ref
+*
+* @param source source ref
+* @param targets
+*/
+function syncRefs(source, targets, options = {}) {
+	const { flush = "sync", deep = false, immediate = true } = options;
+	const targetsArray = toArray(targets);
+	return watch(source, (newValue) => targetsArray.forEach((target) => target.value = newValue), {
+		flush,
+		deep,
+		immediate
+	});
+}
+/**
+* Extended `toRefs` that also accepts refs of an object.
+*
+* @see https://vueuse.org/toRefs
+* @param objectRef A ref or normal object or array.
+* @param options Options
+*/
+function toRefs(objectRef, options = {}) {
+	if (!isRef(objectRef)) return toRefs$1(objectRef);
+	const result = Array.isArray(objectRef.value) ? Array.from({ length: objectRef.value.length }) : {};
+	for (const key in objectRef.value) result[key] = customRef(() => ({
+		get() {
+			return objectRef.value[key];
+		},
+		set(v) {
+			var _toValue;
+			if ((_toValue = toValue(options.replaceRef)) !== null && _toValue !== void 0 ? _toValue : true) if (Array.isArray(objectRef.value)) {
+				const copy = [...objectRef.value];
+				copy[key] = v;
+				objectRef.value = copy;
+			} else {
+				const newObject = {
+					...objectRef.value,
+					[key]: v
+				};
+				Object.setPrototypeOf(newObject, Object.getPrototypeOf(objectRef.value));
+				objectRef.value = newObject;
+			}
+			else objectRef.value[key] = v;
+		}
+	}));
+	return result;
+}
+/**
+* Call onBeforeMount() if it's inside a component lifecycle, if not, just call the function
+*
+* @param fn
+* @param sync if set to false, it will run in the nextTick() of Vue
+* @param target
+*/
+function tryOnBeforeMount(fn, sync = true, target) {
+	if (getLifeCycleTarget(target)) onBeforeMount(fn, target);
+	else if (sync) fn();
+	else nextTick(fn);
+}
+/**
+* Call onBeforeUnmount() if it's inside a component lifecycle, if not, do nothing
+*
+* @param fn
+* @param target
+*/
+function tryOnBeforeUnmount(fn, target) {
+	if (getLifeCycleTarget(target)) onBeforeUnmount(fn, target);
+}
+/**
+* Call onMounted() if it's inside a component lifecycle, if not, just call the function
+*
+* @param fn
+* @param sync if set to false, it will run in the nextTick() of Vue
+* @param target
+*/
+function tryOnMounted(fn, sync = true, target) {
+	if (getLifeCycleTarget(target)) onMounted(fn, target);
+	else if (sync) fn();
+	else nextTick(fn);
+}
+/**
+* Call onUnmounted() if it's inside a component lifecycle, if not, do nothing
+*
+* @param fn
+* @param target
+*/
+function tryOnUnmounted(fn, target) {
+	if (getLifeCycleTarget(target)) onUnmounted(fn, target);
+}
+function createUntil(r, isNot = false) {
+	function toMatch(condition, { flush = "sync", deep = false, timeout, throwOnTimeout } = {}) {
+		let stop = null;
+		const promises = [new Promise((resolve) => {
+			stop = watch(r, (v) => {
+				if (condition(v) !== isNot) {
+					if (stop) stop();
+					else nextTick(() => stop === null || stop === void 0 ? void 0 : stop());
+					resolve(v);
+				}
+			}, {
+				flush,
+				deep,
+				immediate: true
+			});
+		})];
+		if (timeout != null) promises.push(promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => stop === null || stop === void 0 ? void 0 : stop()));
+		return Promise.race(promises);
+	}
+	function toBe(value, options) {
+		if (!isRef(value)) return toMatch((v) => v === value, options);
+		const { flush = "sync", deep = false, timeout, throwOnTimeout } = options !== null && options !== void 0 ? options : {};
+		let stop = null;
+		const promises = [new Promise((resolve) => {
+			stop = watch([r, value], ([v1, v2]) => {
+				if (isNot !== (v1 === v2)) {
+					if (stop) stop();
+					else nextTick(() => stop === null || stop === void 0 ? void 0 : stop());
+					resolve(v1);
+				}
+			}, {
+				flush,
+				deep,
+				immediate: true
+			});
+		})];
+		if (timeout != null) promises.push(promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => {
+			stop === null || stop === void 0 || stop();
+			return toValue(r);
+		}));
+		return Promise.race(promises);
+	}
+	function toBeTruthy(options) {
+		return toMatch((v) => Boolean(v), options);
+	}
+	function toBeNull(options) {
+		return toBe(null, options);
+	}
+	function toBeUndefined(options) {
+		return toBe(void 0, options);
+	}
+	function toBeNaN(options) {
+		return toMatch(Number.isNaN, options);
+	}
+	function toContains(value, options) {
+		return toMatch((v) => {
+			const array = Array.from(v);
+			return array.includes(value) || array.includes(toValue(value));
+		}, options);
+	}
+	function changed(options) {
+		return changedTimes(1, options);
+	}
+	function changedTimes(n = 1, options) {
+		let count = -1;
+		return toMatch(() => {
+			count += 1;
+			return count >= n;
+		}, options);
+	}
+	if (Array.isArray(toValue(r))) return {
+		toMatch,
+		toContains,
+		changed,
+		changedTimes,
+		get not() {
+			return createUntil(r, !isNot);
+		}
+	};
+	else return {
+		toMatch,
+		toBe,
+		toBeTruthy,
+		toBeNull,
+		toBeNaN,
+		toBeUndefined,
+		changed,
+		changedTimes,
+		get not() {
+			return createUntil(r, !isNot);
+		}
+	};
+}
+function until(r) {
+	return createUntil(r);
+}
+function defaultComparator(value, othVal) {
+	return value === othVal;
+}
+/**
+* Reactive get array difference of two array
+* @see https://vueuse.org/useArrayDifference
+* @returns - the difference of two array
+* @param args
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useArrayDifference(...args) {
+	var _args$, _args$2;
+	const list = args[0];
+	const values = args[1];
+	let compareFn = (_args$ = args[2]) !== null && _args$ !== void 0 ? _args$ : defaultComparator;
+	const { symmetric = false } = (_args$2 = args[3]) !== null && _args$2 !== void 0 ? _args$2 : {};
+	if (typeof compareFn === "string") {
+		const key = compareFn;
+		compareFn = (value, othVal) => value[key] === othVal[key];
+	}
+	const diff1 = computed(() => toValue(list).filter((x) => toValue(values).findIndex((y) => compareFn(x, y)) === -1));
+	if (symmetric) {
+		const diff2 = computed(() => toValue(values).filter((x) => toValue(list).findIndex((y) => compareFn(x, y)) === -1));
+		return computed(() => symmetric ? [...toValue(diff1), ...toValue(diff2)] : toValue(diff1));
+	} else return diff1;
+}
+/**
+* Reactive `Array.every`
+*
+* @see https://vueuse.org/useArrayEvery
+* @param list - the array was called upon.
+* @param fn - a function to test each element.
+*
+* @returns **true** if the `fn` function returns a **truthy** value for every element from the array. Otherwise, **false**.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useArrayEvery(list, fn) {
+	return computed(() => toValue(list).every((element, index, array) => fn(toValue(element), index, array)));
+}
+/**
+* Reactive `Array.filter`
+*
+* @see https://vueuse.org/useArrayFilter
+* @param list - the array was called upon.
+* @param fn - a function that is called for every element of the given `list`. Each time `fn` executes, the returned value is added to the new array.
+*
+* @returns a shallow copy of a portion of the given array, filtered down to just the elements from the given array that pass the test implemented by the provided function. If no elements pass the test, an empty array will be returned.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useArrayFilter(list, fn) {
+	return computed(() => toValue(list).map((i) => toValue(i)).filter(fn));
+}
+/**
+* Reactive `Array.find`
+*
+* @see https://vueuse.org/useArrayFind
+* @param list - the array was called upon.
+* @param fn - a function to test each element.
+*
+* @returns the first element in the array that satisfies the provided testing function. Otherwise, undefined is returned.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useArrayFind(list, fn) {
+	return computed(() => toValue(toValue(list).find((element, index, array) => fn(toValue(element), index, array))));
+}
+/**
+* Reactive `Array.findIndex`
+*
+* @see https://vueuse.org/useArrayFindIndex
+* @param list - the array was called upon.
+* @param fn - a function to test each element.
+*
+* @returns the index of the first element in the array that passes the test. Otherwise, "-1".
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useArrayFindIndex(list, fn) {
+	return computed(() => toValue(list).findIndex((element, index, array) => fn(toValue(element), index, array)));
+}
+function findLast(arr, cb) {
+	let index = arr.length;
+	while (index-- > 0) if (cb(arr[index], index, arr)) return arr[index];
+}
+/**
+* Reactive `Array.findLast`
+*
+* @see https://vueuse.org/useArrayFindLast
+* @param list - the array was called upon.
+* @param fn - a function to test each element.
+*
+* @returns the last element in the array that satisfies the provided testing function. Otherwise, undefined is returned.
+*
+* @__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))));
+}
+function isArrayIncludesOptions(obj) {
+	return isObject(obj) && containsProp(obj, "formIndex", "comparator");
+}
+/**
+* Reactive `Array.includes`
+*
+* @see https://vueuse.org/useArrayIncludes
+*
+* @returns true if the `value` is found in the array. Otherwise, false.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useArrayIncludes(...args) {
+	var _comparator;
+	const list = args[0];
+	const value = args[1];
+	let comparator = args[2];
+	let formIndex = 0;
+	if (isArrayIncludesOptions(comparator)) {
+		var _comparator$fromIndex;
+		formIndex = (_comparator$fromIndex = comparator.fromIndex) !== null && _comparator$fromIndex !== void 0 ? _comparator$fromIndex : 0;
+		comparator = comparator.comparator;
+	}
+	if (typeof comparator === "string") {
+		const key = comparator;
+		comparator = (element, value) => element[key] === toValue(value);
+	}
+	comparator = (_comparator = comparator) !== null && _comparator !== void 0 ? _comparator : ((element, value) => element === toValue(value));
+	return computed(() => toValue(list).slice(formIndex).some((element, index, array) => comparator(toValue(element), toValue(value), index, toValue(array))));
+}
+/**
+* Reactive `Array.join`
+*
+* @see https://vueuse.org/useArrayJoin
+* @param list - the array was called upon.
+* @param separator - a string to separate each pair of adjacent elements of the array. If omitted, the array elements are separated with a comma (",").
+*
+* @returns a string with all array elements joined. If arr.length is 0, the empty string is returned.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useArrayJoin(list, separator) {
+	return computed(() => toValue(list).map((i) => toValue(i)).join(toValue(separator)));
+}
+/**
+* Reactive `Array.map`
+*
+* @see https://vueuse.org/useArrayMap
+* @param list - the array was called upon.
+* @param fn - a function that is called for every element of the given `list`. Each time `fn` executes, the returned value is added to the new array.
+*
+* @returns a new array with each element being the result of the callback function.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useArrayMap(list, fn) {
+	return computed(() => toValue(list).map((i) => toValue(i)).map(fn));
+}
+/**
+* Reactive `Array.reduce`
+*
+* @see https://vueuse.org/useArrayReduce
+* @param list - the array was called upon.
+* @param reducer - a "reducer" function.
+* @param args
+*
+* @returns the value that results from running the "reducer" callback function to completion over the entire array.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useArrayReduce(list, reducer, ...args) {
+	const reduceCallback = (sum, value, index) => reducer(toValue(sum), toValue(value), index);
+	return computed(() => {
+		const resolved = toValue(list);
+		return args.length ? resolved.reduce(reduceCallback, typeof args[0] === "function" ? toValue(args[0]()) : toValue(args[0])) : resolved.reduce(reduceCallback);
+	});
+}
+/**
+* Reactive `Array.some`
+*
+* @see https://vueuse.org/useArraySome
+* @param list - the array was called upon.
+* @param fn - a function to test each element.
+*
+* @returns **true** if the `fn` function returns a **truthy** value for any element from the array. Otherwise, **false**.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useArraySome(list, fn) {
+	return computed(() => toValue(list).some((element, index, array) => fn(toValue(element), index, array)));
+}
+function uniq(array) {
+	return Array.from(new Set(array));
+}
+function uniqueElementsBy(array, fn) {
+	return array.reduce((acc, v) => {
+		if (!acc.some((x) => fn(v, x, array))) acc.push(v);
+		return acc;
+	}, []);
+}
+/**
+* reactive unique array
+* @see https://vueuse.org/useArrayUnique
+* @param list - the array was called upon.
+* @param compareFn
+* @returns A computed ref that returns a unique array of items.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useArrayUnique(list, compareFn) {
+	return computed(() => {
+		const resolvedList = toValue(list).map((element) => toValue(element));
+		return compareFn ? uniqueElementsBy(resolvedList, compareFn) : uniq(resolvedList);
+	});
+}
+/**
+* Basic counter with utility functions.
+*
+* @see https://vueuse.org/useCounter
+* @param [initialValue]
+* @param options
+*/
+function useCounter(initialValue = 0, options = {}) {
+	let _initialValue = unref(initialValue);
+	const count = shallowRef(initialValue);
+	const { max = Number.POSITIVE_INFINITY, min = Number.NEGATIVE_INFINITY } = options;
+	const inc = (delta = 1) => count.value = Math.max(Math.min(max, count.value + delta), min);
+	const dec = (delta = 1) => count.value = Math.min(Math.max(min, count.value - delta), max);
+	const get = () => count.value;
+	const set = (val) => count.value = Math.max(min, Math.min(max, val));
+	const reset = (val = _initialValue) => {
+		_initialValue = val;
+		return set(val);
+	};
+	return {
+		count: shallowReadonly(count),
+		inc,
+		dec,
+		get,
+		set,
+		reset
+	};
+}
+var REGEX_PARSE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[T\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/i;
+var REGEX_FORMAT = /[YMDHhms]o|\[([^\]]+)\]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a{1,2}|A{1,2}|m{1,2}|s{1,2}|Z{1,2}|z{1,4}|SSS/g;
+function defaultMeridiem(hours, minutes, isLowercase, hasPeriod) {
+	let m = hours < 12 ? "AM" : "PM";
+	if (hasPeriod) m = m.split("").reduce((acc, curr) => acc += `${curr}.`, "");
+	return isLowercase ? m.toLowerCase() : m;
+}
+function formatOrdinal(num) {
+	const suffixes = [
+		"th",
+		"st",
+		"nd",
+		"rd"
+	];
+	const v = num % 100;
+	return num + (suffixes[(v - 20) % 10] || suffixes[v] || suffixes[0]);
+}
+function formatDate(date, formatStr, options = {}) {
+	var _options$customMeridi;
+	const years = date.getFullYear();
+	const month = date.getMonth();
+	const days = date.getDate();
+	const hours = date.getHours();
+	const minutes = date.getMinutes();
+	const seconds = date.getSeconds();
+	const milliseconds = date.getMilliseconds();
+	const day = date.getDay();
+	const meridiem = (_options$customMeridi = options.customMeridiem) !== null && _options$customMeridi !== void 0 ? _options$customMeridi : defaultMeridiem;
+	const stripTimeZone = (dateString) => {
+		var _dateString$split$;
+		return (_dateString$split$ = dateString.split(" ")[1]) !== null && _dateString$split$ !== void 0 ? _dateString$split$ : "";
+	};
+	const matches = {
+		Yo: () => formatOrdinal(years),
+		YY: () => String(years).slice(-2),
+		YYYY: () => years,
+		M: () => month + 1,
+		Mo: () => formatOrdinal(month + 1),
+		MM: () => `${month + 1}`.padStart(2, "0"),
+		MMM: () => date.toLocaleDateString(toValue(options.locales), { month: "short" }),
+		MMMM: () => date.toLocaleDateString(toValue(options.locales), { month: "long" }),
+		D: () => String(days),
+		Do: () => formatOrdinal(days),
+		DD: () => `${days}`.padStart(2, "0"),
+		H: () => String(hours),
+		Ho: () => formatOrdinal(hours),
+		HH: () => `${hours}`.padStart(2, "0"),
+		h: () => `${hours % 12 || 12}`.padStart(1, "0"),
+		ho: () => formatOrdinal(hours % 12 || 12),
+		hh: () => `${hours % 12 || 12}`.padStart(2, "0"),
+		m: () => String(minutes),
+		mo: () => formatOrdinal(minutes),
+		mm: () => `${minutes}`.padStart(2, "0"),
+		s: () => String(seconds),
+		so: () => formatOrdinal(seconds),
+		ss: () => `${seconds}`.padStart(2, "0"),
+		SSS: () => `${milliseconds}`.padStart(3, "0"),
+		d: () => day,
+		dd: () => date.toLocaleDateString(toValue(options.locales), { weekday: "narrow" }),
+		ddd: () => date.toLocaleDateString(toValue(options.locales), { weekday: "short" }),
+		dddd: () => date.toLocaleDateString(toValue(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),
+		z: () => stripTimeZone(date.toLocaleDateString(toValue(options.locales), { timeZoneName: "shortOffset" })),
+		zz: () => stripTimeZone(date.toLocaleDateString(toValue(options.locales), { timeZoneName: "shortOffset" })),
+		zzz: () => stripTimeZone(date.toLocaleDateString(toValue(options.locales), { timeZoneName: "shortOffset" })),
+		zzzz: () => stripTimeZone(date.toLocaleDateString(toValue(options.locales), { timeZoneName: "longOffset" }))
+	};
+	return formatStr.replace(REGEX_FORMAT, (match, $1) => {
+		var _ref, _matches$match;
+		return (_ref = $1 !== null && $1 !== void 0 ? $1 : (_matches$match = matches[match]) === null || _matches$match === void 0 ? void 0 : _matches$match.call(matches)) !== null && _ref !== void 0 ? _ref : match;
+	});
+}
+function normalizeDate(date) {
+	if (date === null) return /* @__PURE__ */ new Date(NaN);
+	if (date === void 0) return /* @__PURE__ */ new Date();
+	if (date instanceof Date) return new Date(date);
+	if (typeof date === "string" && !/Z$/i.test(date)) {
+		const d = date.match(REGEX_PARSE);
+		if (d) {
+			const m = d[2] - 1 || 0;
+			const ms = (d[7] || "0").substring(0, 3);
+			return new Date(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms);
+		}
+	}
+	return new Date(date);
+}
+/**
+* Get the formatted date according to the string of tokens passed in.
+*
+* @see https://vueuse.org/useDateFormat
+* @param date - The date to format, can either be a `Date` object, a timestamp, or a string
+* @param formatStr - The combination of tokens to format the date
+* @param options - UseDateFormatOptions
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useDateFormat(date, formatStr = "HH:mm:ss", options = {}) {
+	return computed(() => formatDate(normalizeDate(toValue(date)), toValue(formatStr), options));
+}
+/**
+* Wrapper for `setInterval` with controls
+*
+* @see https://vueuse.org/useIntervalFn
+* @param cb
+* @param interval
+* @param options
+*/
+function useIntervalFn(cb, interval = 1e3, options = {}) {
+	const { immediate = true, immediateCallback = false } = options;
+	let timer = null;
+	const isActive = shallowRef(false);
+	function clean() {
+		if (timer) {
+			clearInterval(timer);
+			timer = null;
+		}
+	}
+	function pause() {
+		isActive.value = false;
+		clean();
+	}
+	function resume() {
+		const intervalValue = toValue(interval);
+		if (intervalValue <= 0) return;
+		isActive.value = true;
+		if (immediateCallback) cb();
+		clean();
+		if (isActive.value) timer = setInterval(cb, intervalValue);
+	}
+	if (immediate && isClient) resume();
+	if (isRef(interval) || typeof interval === "function") tryOnScopeDispose(watch(interval, () => {
+		if (isActive.value && isClient) resume();
+	}));
+	tryOnScopeDispose(pause);
+	return {
+		isActive: shallowReadonly(isActive),
+		pause,
+		resume
+	};
+}
+function useInterval(interval = 1e3, options = {}) {
+	const { controls: exposeControls = false, immediate = true, callback } = options;
+	const counter = shallowRef(0);
+	const update = () => counter.value += 1;
+	const reset = () => {
+		counter.value = 0;
+	};
+	const controls = useIntervalFn(callback ? () => {
+		update();
+		callback(counter.value);
+	} : update, interval, { immediate });
+	if (exposeControls) return {
+		counter: shallowReadonly(counter),
+		reset,
+		...controls
+	};
+	else return shallowReadonly(counter);
+}
+function useLastChanged(source, options = {}) {
+	var _options$initialValue;
+	const ms = shallowRef((_options$initialValue = options.initialValue) !== null && _options$initialValue !== void 0 ? _options$initialValue : null);
+	watch(source, () => ms.value = timestamp(), options);
+	return shallowReadonly(ms);
+}
+/**
+* Wrapper for `setTimeout` with controls.
+*
+* @param cb
+* @param interval
+* @param options
+*/
+function useTimeoutFn(cb, interval, options = {}) {
+	const { immediate = true, immediateCallback = false } = options;
+	const isPending = shallowRef(false);
+	let timer;
+	function clear() {
+		if (timer) {
+			clearTimeout(timer);
+			timer = void 0;
+		}
+	}
+	function stop() {
+		isPending.value = false;
+		clear();
+	}
+	function start(...args) {
+		if (immediateCallback) cb();
+		clear();
+		isPending.value = true;
+		timer = setTimeout(() => {
+			isPending.value = false;
+			timer = void 0;
+			cb(...args);
+		}, toValue(interval));
+	}
+	if (immediate) {
+		isPending.value = true;
+		if (isClient) start();
+	}
+	tryOnScopeDispose(stop);
+	return {
+		isPending: shallowReadonly(isPending),
+		start,
+		stop
+	};
+}
+function useTimeout(interval = 1e3, options = {}) {
+	const { controls: exposeControls = false, callback } = options;
+	const controls = useTimeoutFn(callback !== null && callback !== void 0 ? callback : noop, interval, options);
+	const ready = computed(() => !controls.isPending.value);
+	if (exposeControls) return {
+		ready,
+		...controls
+	};
+	else return ready;
+}
+/**
+* Reactively convert a string ref to number.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useToNumber(value, options = {}) {
+	const { method = "parseFloat", radix, nanToZero } = options;
+	return computed(() => {
+		let resolved = 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;
+		return resolved;
+	});
+}
+/**
+* Reactively convert a ref to string.
+*
+* @see https://vueuse.org/useToString
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useToString(value) {
+	return computed(() => `${toValue(value)}`);
+}
+/**
+* A boolean ref with a toggler
+*
+* @see https://vueuse.org/useToggle
+* @param [initialValue]
+* @param options
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useToggle(initialValue = false, options = {}) {
+	const { truthyValue = true, falsyValue = false } = options;
+	const valueIsRef = isRef(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;
+			return _value.value;
+		}
+	}
+	if (valueIsRef) return toggle;
+	else return [_value, toggle];
+}
+/**
+* Watch for an array with additions and removals.
+*
+* @see https://vueuse.org/watchArray
+*/
+function watchArray(source, cb, options) {
+	let oldList = (options === null || options === void 0 ? void 0 : options.immediate) ? [] : [...typeof source === "function" ? source() : Array.isArray(source) ? source : toValue(source)];
+	return watch(source, (newList, _, onCleanup) => {
+		const oldListRemains = Array.from({ length: oldList.length });
+		const added = [];
+		for (const obj of newList) {
+			let found = false;
+			for (let i = 0; i < oldList.length; i++) if (!oldListRemains[i] && obj === oldList[i]) {
+				oldListRemains[i] = true;
+				found = true;
+				break;
+			}
+			if (!found) added.push(obj);
+		}
+		const removed = oldList.filter((_, i) => !oldListRemains[i]);
+		cb(newList, oldList, added, removed, onCleanup);
+		oldList = [...newList];
+	}, options);
+}
+function watchAtMost(source, cb, options) {
+	const { count, ...watchOptions } = options;
+	const current = shallowRef(0);
+	const { stop, resume, pause } = watchWithFilter(source, (...args) => {
+		current.value += 1;
+		if (current.value >= toValue(count)) nextTick(() => stop());
+		cb(...args);
+	}, watchOptions);
+	return {
+		count: current,
+		stop,
+		resume,
+		pause
+	};
+}
+function watchDebounced(source, cb, options = {}) {
+	const { debounce = 0, maxWait = void 0, ...watchOptions } = options;
+	return watchWithFilter(source, cb, {
+		...watchOptions,
+		eventFilter: debounceFilter(debounce, { maxWait })
+	});
+}
+/** @deprecated use `watchDebounced` instead */
+var debouncedWatch = watchDebounced;
+/**
+* Shorthand for watching value with {deep: true}
+*
+* @see https://vueuse.org/watchDeep
+*/
+function watchDeep(source, cb, options) {
+	return watch(source, cb, {
+		...options,
+		deep: true
+	});
+}
+function watchIgnorable(source, cb, options = {}) {
+	const { eventFilter = bypassFilter, ...watchOptions } = options;
+	const filteredCb = createFilterWrapper(eventFilter, cb);
+	let ignoreUpdates;
+	let ignorePrevAsyncUpdates;
+	let stop;
+	if (watchOptions.flush === "sync") {
+		let ignore = false;
+		ignorePrevAsyncUpdates = () => {};
+		ignoreUpdates = (updater) => {
+			ignore = true;
+			updater();
+			ignore = false;
+		};
+		stop = watch(source, (...args) => {
+			if (!ignore) filteredCb(...args);
+		}, watchOptions);
+	} else {
+		const disposables = [];
+		let ignoreCounter = 0;
+		let syncCounter = 0;
+		ignorePrevAsyncUpdates = () => {
+			ignoreCounter = syncCounter;
+		};
+		disposables.push(watch(source, () => {
+			syncCounter++;
+		}, {
+			...watchOptions,
+			flush: "sync"
+		}));
+		ignoreUpdates = (updater) => {
+			const syncCounterPrev = syncCounter;
+			updater();
+			ignoreCounter += syncCounter - syncCounterPrev;
+		};
+		disposables.push(watch(source, (...args) => {
+			const ignore = ignoreCounter > 0 && ignoreCounter === syncCounter;
+			ignoreCounter = 0;
+			syncCounter = 0;
+			if (ignore) return;
+			filteredCb(...args);
+		}, watchOptions));
+		stop = () => {
+			disposables.forEach((fn) => fn());
+		};
+	}
+	return {
+		stop,
+		ignoreUpdates,
+		ignorePrevAsyncUpdates
+	};
+}
+/** @deprecated use `watchIgnorable` instead */
+var ignorableWatch = watchIgnorable;
+/**
+* Shorthand for watching value with {immediate: true}
+*
+* @see https://vueuse.org/watchImmediate
+*/
+function watchImmediate(source, cb, options) {
+	return watch(source, cb, {
+		...options,
+		immediate: true
+	});
+}
+/**
+* Shorthand for watching value with { once: true }
+*
+* @see https://vueuse.org/watchOnce
+*/
+function watchOnce(source, cb, options) {
+	return watch(source, cb, {
+		...options,
+		once: true
+	});
+}
+function watchThrottled(source, cb, options = {}) {
+	const { throttle = 0, trailing = true, leading = true, ...watchOptions } = options;
+	return watchWithFilter(source, cb, {
+		...watchOptions,
+		eventFilter: throttleFilter(throttle, trailing, leading)
+	});
+}
+/** @deprecated use `watchThrottled` instead */
+var throttledWatch = watchThrottled;
+function watchTriggerable(source, cb, options = {}) {
+	let cleanupFn;
+	function onEffect() {
+		if (!cleanupFn) return;
+		const fn = cleanupFn;
+		cleanupFn = void 0;
+		fn();
+	}
+	/** Register the function `cleanupFn` */
+	function onCleanup(callback) {
+		cleanupFn = callback;
+	}
+	const _cb = (value, oldValue) => {
+		onEffect();
+		return cb(value, oldValue, onCleanup);
+	};
+	const res = watchIgnorable(source, _cb, options);
+	const { ignoreUpdates } = res;
+	const trigger = () => {
+		let res;
+		ignoreUpdates(() => {
+			res = _cb(getWatchSources(source), getOldValue(source));
+		});
+		return res;
+	};
+	return {
+		...res,
+		trigger
+	};
+}
+function getWatchSources(sources) {
+	if (isReactive(sources)) return sources;
+	if (Array.isArray(sources)) return sources.map((item) => toValue(item));
+	return toValue(sources);
+}
+function getOldValue(source) {
+	return Array.isArray(source) ? source.map(() => void 0) : void 0;
+}
+function whenever(source, cb, options) {
+	const stop = watch(source, (v, ov, onInvalidate) => {
+		if (v) {
+			if (options === null || options === void 0 ? void 0 : options.once) nextTick(() => stop());
+			cb(v, ov, onInvalidate);
+		}
+	}, {
+		...options,
+		once: false
+	});
+	return stop;
+}
+//#endregion
+export { assert, autoResetRef, bypassFilter, camelize, clamp, computedEager, computedWithControl, containsProp, controlledComputed, controlledRef, createDisposableDirective, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, createReactiveFn, createRef, createSharedComposable, createSingletonPromise, debounceFilter, debouncedRef, debouncedWatch, eagerComputed, extendRef, formatDate, get, getLifeCycleTarget, hasOwn, hyphenate, identity, ignorableWatch, increaseWithUnit, injectLocal, invoke, isClient, isDef, isDefined, isIOS, isObject, isWorker, makeDestructurable, noop, normalizeDate, notNullish, now, objectEntries, objectOmit, objectPick, pausableFilter, pausableWatch, promiseTimeout, provideLocal, pxValue, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refManualReset, refThrottled, refWithControl, set, syncRef, syncRefs, throttleFilter, throttledRef, throttledWatch, timestamp, toArray, toReactive, toRef, toRefs, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayDifference, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayFindLast, useArrayIncludes, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useArrayUnique, useCounter, useDateFormat, useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToNumber, useToString, useToggle, watchArray, watchAtMost, watchDebounced, watchDeep, watchIgnorable, watchImmediate, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };
+
+//# sourceMappingURL=@vueuse_shared.js.map