@vitejs/devtools 0.0.0-alpha.21 → 0.0.0-alpha.23

package/dist/dist-Ce2tZLIf.js

@@ -0,0 +1,815 @@
+import { A as getCurrentScope, B as unref, E as watchEffect, F as ref, I as shallowRef, L as toRef$1, M as onScopeDispose, P as readonly, T as watch, _ as inject, g as hasInjectionContext, h as getCurrentInstance, k as customRef, o as computed, v as nextTick, y as onMounted, z as toValue } from "./vue.runtime.esm-bundler-B98sE5ly.js";
+
+//#region ../../node_modules/.pnpm/@vueuse+shared@14.1.0_vue@3.5.26_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js
+/**
+* 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;
+}
+const 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__
+*/
+const 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);
+};
+const isClient = typeof window !== "undefined" && typeof document !== "undefined";
+const isWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+const notNullish = (val) => val != null;
+const toString = Object.prototype.toString;
+const isObject = (val) => toString.call(val) === "[object Object]";
+const noop = () => {};
+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;
+}
+const bypassFilter = (invoke$1) => {
+	return invoke$1();
+};
+/**
+* Create an EventFilter that debounce the events
+*/
+function debounceFilter(ms, options = {}) {
+	let timer;
+	let maxTimer;
+	let lastRejector = noop;
+	const _clearTimeout = (timer$1) => {
+		clearTimeout(timer$1);
+		lastRejector();
+		lastRejector = noop;
+	};
+	let lastInvoker;
+	const filter = (invoke$1) => {
+		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$1());
+		}
+		return new Promise((resolve, reject) => {
+			lastRejector = options.rejectOnCancel ? reject : resolve;
+			lastInvoker = invoke$1;
+			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$1());
+			}, duration);
+		});
+	};
+	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: readonly(isActive),
+		pause,
+		resume,
+		eventFilter
+	};
+}
+/**
+* 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);
+}
+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));
+	});
+}
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
+const camelizeRE = /-(\w)/g;
+const camelize = cacheStringFunction((str) => {
+	return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
+});
+function getLifeCycleTarget(target) {
+	return target || getCurrentInstance();
+}
+/**
+* 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);
+}
+function watchWithFilter(source, cb, options = {}) {
+	const { eventFilter = bypassFilter, ...watchOptions } = options;
+	return watch(source, createFilterWrapper(eventFilter, cb), watchOptions);
+}
+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 `watchPausable` instead */
+const pausableWatch = watchPausable;
+/**
+* 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);
+}
+/**
+* Shorthand for watching value with {immediate: true}
+*
+* @see https://vueuse.org/watchImmediate
+*/
+function watchImmediate(source, cb, options) {
+	return watch(source, cb, {
+		...options,
+		immediate: true
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@vueuse+core@14.1.0_vue@3.5.26_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.js
+const defaultWindow = isClient ? window : void 0;
+const defaultDocument = isClient ? window.document : void 0;
+const defaultNavigator = isClient ? window.navigator : void 0;
+const defaultLocation = isClient ? window.location : void 0;
+/**
+* Get the dom element of a ref of element or Vue component instance
+*
+* @param elRef
+*/
+function unrefElement(elRef) {
+	var _$el;
+	const plain = toValue(elRef);
+	return (_$el = plain === null || plain === void 0 ? void 0 : plain.$el) !== null && _$el !== void 0 ? _$el : plain;
+}
+function useEventListener(...args) {
+	const register = (el, event, listener, options) => {
+		el.addEventListener(event, listener, options);
+		return () => el.removeEventListener(event, listener, options);
+	};
+	const firstParamTargets = computed(() => {
+		const test = toArray(toValue(args[0])).filter((e) => e != null);
+		return test.every((e) => typeof e !== "string") ? test : void 0;
+	});
+	return watchImmediate(() => {
+		var _firstParamTargets$va, _firstParamTargets$va2;
+		return [
+			(_firstParamTargets$va = (_firstParamTargets$va2 = firstParamTargets.value) === null || _firstParamTargets$va2 === void 0 ? void 0 : _firstParamTargets$va2.map((e) => unrefElement(e))) !== null && _firstParamTargets$va !== void 0 ? _firstParamTargets$va : [defaultWindow].filter((e) => e != null),
+			toArray(toValue(firstParamTargets.value ? args[1] : args[0])),
+			toArray(unref(firstParamTargets.value ? args[2] : args[1])),
+			toValue(firstParamTargets.value ? args[3] : args[2])
+		];
+	}, ([raw_targets, raw_events, raw_listeners, raw_options], _, onCleanup) => {
+		if (!(raw_targets === null || raw_targets === void 0 ? void 0 : raw_targets.length) || !(raw_events === null || raw_events === void 0 ? void 0 : raw_events.length) || !(raw_listeners === null || raw_listeners === void 0 ? void 0 : raw_listeners.length)) return;
+		const optionsClone = isObject(raw_options) ? { ...raw_options } : raw_options;
+		const cleanups = raw_targets.flatMap((el) => raw_events.flatMap((event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone))));
+		onCleanup(() => {
+			cleanups.forEach((fn) => fn());
+		});
+	}, { flush: "post" });
+}
+/**
+* Mounted state in ref.
+*
+* @see https://vueuse.org/useMounted
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useMounted() {
+	const isMounted = shallowRef(false);
+	const instance = getCurrentInstance();
+	if (instance) onMounted(() => {
+		isMounted.value = true;
+	}, instance);
+	return isMounted;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function useSupported(callback) {
+	const isMounted = useMounted();
+	return computed(() => {
+		isMounted.value;
+		return Boolean(callback());
+	});
+}
+/**
+* Watch for changes being made to the DOM tree.
+*
+* @see https://vueuse.org/useMutationObserver
+* @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver MutationObserver MDN
+* @param target
+* @param callback
+* @param options
+*/
+function useMutationObserver(target, callback, options = {}) {
+	const { window: window$1 = defaultWindow, ...mutationOptions } = options;
+	let observer;
+	const isSupported = /* @__PURE__ */ useSupported(() => window$1 && "MutationObserver" in window$1);
+	const cleanup = () => {
+		if (observer) {
+			observer.disconnect();
+			observer = void 0;
+		}
+	};
+	const stopWatch = watch(computed(() => {
+		const items = toArray(toValue(target)).map(unrefElement).filter(notNullish);
+		return new Set(items);
+	}), (newTargets) => {
+		cleanup();
+		if (isSupported.value && newTargets.size) {
+			observer = new MutationObserver(callback);
+			newTargets.forEach((el) => observer.observe(el, mutationOptions));
+		}
+	}, {
+		immediate: true,
+		flush: "post"
+	});
+	const takeRecords = () => {
+		return observer === null || observer === void 0 ? void 0 : observer.takeRecords();
+	};
+	const stop = () => {
+		stopWatch();
+		cleanup();
+	};
+	tryOnScopeDispose(stop);
+	return {
+		isSupported,
+		stop,
+		takeRecords
+	};
+}
+const ssrWidthSymbol = Symbol("vueuse-ssr-width");
+/* @__NO_SIDE_EFFECTS__ */
+function useSSRWidth() {
+	const ssrWidth = hasInjectionContext() ? injectLocal(ssrWidthSymbol, null) : null;
+	return typeof ssrWidth === "number" ? ssrWidth : void 0;
+}
+/**
+* Reactive Media Query.
+*
+* @see https://vueuse.org/useMediaQuery
+* @param query
+* @param options
+*/
+function useMediaQuery(query, options = {}) {
+	const { window: window$1 = defaultWindow, ssrWidth = /* @__PURE__ */ useSSRWidth() } = options;
+	const isSupported = /* @__PURE__ */ useSupported(() => window$1 && "matchMedia" in window$1 && typeof window$1.matchMedia === "function");
+	const ssrSupport = shallowRef(typeof ssrWidth === "number");
+	const mediaQuery = shallowRef();
+	const matches = shallowRef(false);
+	const handler = (event) => {
+		matches.value = event.matches;
+	};
+	watchEffect(() => {
+		if (ssrSupport.value) {
+			ssrSupport.value = !isSupported.value;
+			matches.value = toValue(query).split(",").some((queryString) => {
+				const not = queryString.includes("not all");
+				const minWidth = queryString.match(/\(\s*min-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/);
+				const maxWidth = queryString.match(/\(\s*max-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/);
+				let res = Boolean(minWidth || maxWidth);
+				if (minWidth && res) res = ssrWidth >= pxValue(minWidth[1]);
+				if (maxWidth && res) res = ssrWidth <= pxValue(maxWidth[1]);
+				return not ? !res : res;
+			});
+			return;
+		}
+		if (!isSupported.value) return;
+		mediaQuery.value = window$1.matchMedia(toValue(query));
+		matches.value = mediaQuery.value.matches;
+	});
+	useEventListener(mediaQuery, "change", handler, { passive: true });
+	return computed(() => matches.value);
+}
+const _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+const globalKey = "__vueuse_ssr_handlers__";
+const handlers = /* @__PURE__ */ getHandlers();
+function getHandlers() {
+	if (!(globalKey in _global)) _global[globalKey] = _global[globalKey] || {};
+	return _global[globalKey];
+}
+function getSSRHandler(key, fallback) {
+	return handlers[key] || fallback;
+}
+function guessSerializerType(rawInit) {
+	return rawInit == null ? "any" : rawInit instanceof Set ? "set" : rawInit instanceof Map ? "map" : rawInit instanceof Date ? "date" : typeof rawInit === "boolean" ? "boolean" : typeof rawInit === "string" ? "string" : typeof rawInit === "object" ? "object" : !Number.isNaN(rawInit) ? "number" : "any";
+}
+const StorageSerializers = {
+	boolean: {
+		read: (v) => v === "true",
+		write: (v) => String(v)
+	},
+	object: {
+		read: (v) => JSON.parse(v),
+		write: (v) => JSON.stringify(v)
+	},
+	number: {
+		read: (v) => Number.parseFloat(v),
+		write: (v) => String(v)
+	},
+	any: {
+		read: (v) => v,
+		write: (v) => String(v)
+	},
+	string: {
+		read: (v) => v,
+		write: (v) => String(v)
+	},
+	map: {
+		read: (v) => new Map(JSON.parse(v)),
+		write: (v) => JSON.stringify(Array.from(v.entries()))
+	},
+	set: {
+		read: (v) => new Set(JSON.parse(v)),
+		write: (v) => JSON.stringify(Array.from(v))
+	},
+	date: {
+		read: (v) => new Date(v),
+		write: (v) => v.toISOString()
+	}
+};
+const customStorageEventName = "vueuse-storage";
+/**
+* Reactive LocalStorage/SessionStorage.
+*
+* @see https://vueuse.org/useStorage
+*/
+function useStorage(key, defaults$1, storage, options = {}) {
+	var _options$serializer;
+	const { flush = "pre", deep = true, listenToStorageChanges = true, writeDefaults = true, mergeDefaults = false, shallow, window: window$1 = defaultWindow, eventFilter, onError = (e) => {
+		console.error(e);
+	}, initOnMounted } = options;
+	const data = (shallow ? shallowRef : ref)(typeof defaults$1 === "function" ? defaults$1() : defaults$1);
+	const keyComputed = computed(() => toValue(key));
+	if (!storage) try {
+		storage = getSSRHandler("getDefaultStorage", () => defaultWindow === null || defaultWindow === void 0 ? void 0 : defaultWindow.localStorage)();
+	} catch (e) {
+		onError(e);
+	}
+	if (!storage) return data;
+	const rawInit = toValue(defaults$1);
+	const type = guessSerializerType(rawInit);
+	const serializer = (_options$serializer = options.serializer) !== null && _options$serializer !== void 0 ? _options$serializer : StorageSerializers[type];
+	const { pause: pauseWatch, resume: resumeWatch } = pausableWatch(data, (newValue) => write(newValue), {
+		flush,
+		deep,
+		eventFilter
+	});
+	watch(keyComputed, () => update(), { flush });
+	let firstMounted = false;
+	const onStorageEvent = (ev) => {
+		if (initOnMounted && !firstMounted) return;
+		update(ev);
+	};
+	const onStorageCustomEvent = (ev) => {
+		if (initOnMounted && !firstMounted) return;
+		updateFromCustomEvent(ev);
+	};
+	/**
+	* The custom event is needed for same-document syncing when using custom
+	* storage backends, but it doesn't work across different documents.
+	*
+	* TODO: Consider implementing a BroadcastChannel-based solution that fixes this.
+	*/
+	if (window$1 && listenToStorageChanges) if (storage instanceof Storage) useEventListener(window$1, "storage", onStorageEvent, { passive: true });
+	else useEventListener(window$1, customStorageEventName, onStorageCustomEvent);
+	if (initOnMounted) tryOnMounted(() => {
+		firstMounted = true;
+		update();
+	});
+	else update();
+	function dispatchWriteEvent(oldValue, newValue) {
+		if (window$1) {
+			const payload = {
+				key: keyComputed.value,
+				oldValue,
+				newValue,
+				storageArea: storage
+			};
+			window$1.dispatchEvent(storage instanceof Storage ? new StorageEvent("storage", payload) : new CustomEvent(customStorageEventName, { detail: payload }));
+		}
+	}
+	function write(v) {
+		try {
+			const oldValue = storage.getItem(keyComputed.value);
+			if (v == null) {
+				dispatchWriteEvent(oldValue, null);
+				storage.removeItem(keyComputed.value);
+			} else {
+				const serialized = serializer.write(v);
+				if (oldValue !== serialized) {
+					storage.setItem(keyComputed.value, serialized);
+					dispatchWriteEvent(oldValue, serialized);
+				}
+			}
+		} catch (e) {
+			onError(e);
+		}
+	}
+	function read(event) {
+		const rawValue = event ? event.newValue : storage.getItem(keyComputed.value);
+		if (rawValue == null) {
+			if (writeDefaults && rawInit != null) storage.setItem(keyComputed.value, serializer.write(rawInit));
+			return rawInit;
+		} else if (!event && mergeDefaults) {
+			const value = serializer.read(rawValue);
+			if (typeof mergeDefaults === "function") return mergeDefaults(value, rawInit);
+			else if (type === "object" && !Array.isArray(value)) return {
+				...rawInit,
+				...value
+			};
+			return value;
+		} else if (typeof rawValue !== "string") return rawValue;
+		else return serializer.read(rawValue);
+	}
+	function update(event) {
+		if (event && event.storageArea !== storage) return;
+		if (event && event.key == null) {
+			data.value = rawInit;
+			return;
+		}
+		if (event && event.key !== keyComputed.value) return;
+		pauseWatch();
+		try {
+			const serializedData = serializer.write(data.value);
+			if (event === void 0 || (event === null || event === void 0 ? void 0 : event.newValue) !== serializedData) data.value = read(event);
+		} catch (e) {
+			onError(e);
+		} finally {
+			if (event) nextTick(resumeWatch);
+			else resumeWatch();
+		}
+	}
+	function updateFromCustomEvent(event) {
+		update(event.detail);
+	}
+	return data;
+}
+/**
+* Manipulate CSS variables.
+*
+* @see https://vueuse.org/useCssVar
+* @param prop
+* @param target
+* @param options
+*/
+function useCssVar(prop, target, options = {}) {
+	const { window: window$1 = defaultWindow, initialValue, observe = false } = options;
+	const variable = shallowRef(initialValue);
+	const elRef = computed(() => {
+		var _window$document;
+		return unrefElement(target) || (window$1 === null || window$1 === void 0 || (_window$document = window$1.document) === null || _window$document === void 0 ? void 0 : _window$document.documentElement);
+	});
+	function updateCssVar() {
+		const key = toValue(prop);
+		const el = toValue(elRef);
+		if (el && window$1 && key) {
+			var _window$getComputedSt;
+			variable.value = ((_window$getComputedSt = window$1.getComputedStyle(el).getPropertyValue(key)) === null || _window$getComputedSt === void 0 ? void 0 : _window$getComputedSt.trim()) || variable.value || initialValue;
+		}
+	}
+	if (observe) useMutationObserver(elRef, updateCssVar, {
+		attributeFilter: ["style", "class"],
+		window: window$1
+	});
+	watch([elRef, () => toValue(prop)], (_, old) => {
+		if (old[0] && old[1]) old[0].style.removeProperty(old[1]);
+		updateCssVar();
+	}, { immediate: true });
+	watch([variable, elRef], ([val, el]) => {
+		const raw_prop = toValue(prop);
+		if ((el === null || el === void 0 ? void 0 : el.style) && raw_prop) if (val == null) el.style.removeProperty(raw_prop);
+		else el.style.setProperty(raw_prop, val);
+	}, { immediate: true });
+	return variable;
+}
+/**
+* Reports changes to the dimensions of an Element's content or the border-box
+*
+* @see https://vueuse.org/useResizeObserver
+* @param target
+* @param callback
+* @param options
+*/
+function useResizeObserver(target, callback, options = {}) {
+	const { window: window$1 = defaultWindow, ...observerOptions } = options;
+	let observer;
+	const isSupported = /* @__PURE__ */ useSupported(() => window$1 && "ResizeObserver" in window$1);
+	const cleanup = () => {
+		if (observer) {
+			observer.disconnect();
+			observer = void 0;
+		}
+	};
+	const stopWatch = watch(computed(() => {
+		const _targets = toValue(target);
+		return Array.isArray(_targets) ? _targets.map((el) => unrefElement(el)) : [unrefElement(_targets)];
+	}), (els) => {
+		cleanup();
+		if (isSupported.value && window$1) {
+			observer = new ResizeObserver(callback);
+			for (const _el of els) if (_el) observer.observe(_el, observerOptions);
+		}
+	}, {
+		immediate: true,
+		flush: "post"
+	});
+	const stop = () => {
+		cleanup();
+		stopWatch();
+	};
+	tryOnScopeDispose(stop);
+	return {
+		isSupported,
+		stop
+	};
+}
+/**
+* Reactive bounding box of an HTML element.
+*
+* @see https://vueuse.org/useElementBounding
+* @param target
+*/
+function useElementBounding(target, options = {}) {
+	const { reset = true, windowResize = true, windowScroll = true, immediate = true, updateTiming = "sync" } = options;
+	const height = shallowRef(0);
+	const bottom = shallowRef(0);
+	const left = shallowRef(0);
+	const right = shallowRef(0);
+	const top = shallowRef(0);
+	const width = shallowRef(0);
+	const x = shallowRef(0);
+	const y = shallowRef(0);
+	function recalculate() {
+		const el = unrefElement(target);
+		if (!el) {
+			if (reset) {
+				height.value = 0;
+				bottom.value = 0;
+				left.value = 0;
+				right.value = 0;
+				top.value = 0;
+				width.value = 0;
+				x.value = 0;
+				y.value = 0;
+			}
+			return;
+		}
+		const rect = el.getBoundingClientRect();
+		height.value = rect.height;
+		bottom.value = rect.bottom;
+		left.value = rect.left;
+		right.value = rect.right;
+		top.value = rect.top;
+		width.value = rect.width;
+		x.value = rect.x;
+		y.value = rect.y;
+	}
+	function update() {
+		if (updateTiming === "sync") recalculate();
+		else if (updateTiming === "next-frame") requestAnimationFrame(() => recalculate());
+	}
+	useResizeObserver(target, update);
+	watch(() => unrefElement(target), (ele) => !ele && update());
+	useMutationObserver(target, update, { attributeFilter: ["style", "class"] });
+	if (windowScroll) useEventListener("scroll", update, {
+		capture: true,
+		passive: true
+	});
+	if (windowResize) useEventListener("resize", update, { passive: true });
+	tryOnMounted(() => {
+		if (immediate) update();
+	});
+	return {
+		height,
+		bottom,
+		left,
+		right,
+		top,
+		width,
+		x,
+		y,
+		update
+	};
+}
+/**
+* Reactive LocalStorage.
+*
+* @see https://vueuse.org/useLocalStorage
+* @param key
+* @param initialValue
+* @param options
+*/
+function useLocalStorage(key, initialValue, options = {}) {
+	const { window: window$1 = defaultWindow } = options;
+	return useStorage(key, initialValue, window$1 === null || window$1 === void 0 ? void 0 : window$1.localStorage, options);
+}
+const topVarName = "--vueuse-safe-area-top";
+const rightVarName = "--vueuse-safe-area-right";
+const bottomVarName = "--vueuse-safe-area-bottom";
+const leftVarName = "--vueuse-safe-area-left";
+/**
+* Reactive `env(safe-area-inset-*)`
+*
+* @see https://vueuse.org/useScreenSafeArea
+*/
+function useScreenSafeArea() {
+	const top = shallowRef("");
+	const right = shallowRef("");
+	const bottom = shallowRef("");
+	const left = shallowRef("");
+	if (isClient) {
+		const topCssVar = useCssVar(topVarName);
+		const rightCssVar = useCssVar(rightVarName);
+		const bottomCssVar = useCssVar(bottomVarName);
+		const leftCssVar = useCssVar(leftVarName);
+		topCssVar.value = "env(safe-area-inset-top, 0px)";
+		rightCssVar.value = "env(safe-area-inset-right, 0px)";
+		bottomCssVar.value = "env(safe-area-inset-bottom, 0px)";
+		leftCssVar.value = "env(safe-area-inset-left, 0px)";
+		tryOnMounted(update);
+		useEventListener("resize", useDebounceFn(update), { passive: true });
+	}
+	function update() {
+		top.value = getValue(topVarName);
+		right.value = getValue(rightVarName);
+		bottom.value = getValue(bottomVarName);
+		left.value = getValue(leftVarName);
+	}
+	return {
+		top,
+		right,
+		bottom,
+		left,
+		update
+	};
+}
+function getValue(position) {
+	return getComputedStyle(document.documentElement).getPropertyValue(position);
+}
+const DEFAULT_UNITS = [
+	{
+		max: 6e4,
+		value: 1e3,
+		name: "second"
+	},
+	{
+		max: 276e4,
+		value: 6e4,
+		name: "minute"
+	},
+	{
+		max: 72e6,
+		value: 36e5,
+		name: "hour"
+	},
+	{
+		max: 5184e5,
+		value: 864e5,
+		name: "day"
+	},
+	{
+		max: 24192e5,
+		value: 6048e5,
+		name: "week"
+	},
+	{
+		max: 28512e6,
+		value: 2592e6,
+		name: "month"
+	},
+	{
+		max: Number.POSITIVE_INFINITY,
+		value: 31536e6,
+		name: "year"
+	}
+];
+/**
+* Reactive window size.
+*
+* @see https://vueuse.org/useWindowSize
+* @param options
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useWindowSize(options = {}) {
+	const { window: window$1 = defaultWindow, initialWidth = Number.POSITIVE_INFINITY, initialHeight = Number.POSITIVE_INFINITY, listenOrientation = true, includeScrollbar = true, type = "inner" } = options;
+	const width = shallowRef(initialWidth);
+	const height = shallowRef(initialHeight);
+	const update = () => {
+		if (window$1) if (type === "outer") {
+			width.value = window$1.outerWidth;
+			height.value = window$1.outerHeight;
+		} else if (type === "visual" && window$1.visualViewport) {
+			const { width: visualViewportWidth, height: visualViewportHeight, scale } = window$1.visualViewport;
+			width.value = Math.round(visualViewportWidth * scale);
+			height.value = Math.round(visualViewportHeight * scale);
+		} else if (includeScrollbar) {
+			width.value = window$1.innerWidth;
+			height.value = window$1.innerHeight;
+		} else {
+			width.value = window$1.document.documentElement.clientWidth;
+			height.value = window$1.document.documentElement.clientHeight;
+		}
+	};
+	update();
+	tryOnMounted(update);
+	const listenerOptions = { passive: true };
+	useEventListener("resize", update, listenerOptions);
+	if (window$1 && type === "visual" && window$1.visualViewport) useEventListener(window$1.visualViewport, "resize", update, listenerOptions);
+	if (listenOrientation) watch(useMediaQuery("(orientation: portrait)"), () => update());
+	return {
+		width,
+		height
+	};
+}
+
+//#endregion
+export { useWindowSize as a, useScreenSafeArea as i, useEventListener as n, watchImmediate as o, useLocalStorage as r, useElementBounding as t };