@mantine-vue/hooks 1.1.2

package/esm/index.mjs

@@ -0,0 +1,4579 @@
+import { computed, getCurrentInstance, isRef, nextTick, onBeforeUnmount, onMounted, onUpdated, reactive, readonly, ref, shallowRef, toValue, triggerRef, watch, watchEffect } from "vue";
+//#region src/utils/clamp/clamp.ts
+function clamp(value, min, max) {
+	if (min === void 0 && max === void 0) return value;
+	if (min !== void 0 && max === void 0) return Math.max(value, min);
+	if (min === void 0 && max !== void 0) return Math.min(value, max);
+	return Math.min(Math.max(value, min), max);
+}
+//#endregion
+//#region src/utils/lower-first/lower-first.ts
+function lowerFirst(value) {
+	return typeof value !== "string" ? "" : value.charAt(0).toLowerCase() + value.slice(1);
+}
+//#endregion
+//#region src/utils/random-id/random-id.ts
+function randomId(prefix = "mantine-") {
+	return `${prefix}${Math.random().toString(36).slice(2, 11)}`;
+}
+//#endregion
+//#region src/utils/range/range.ts
+function range(start, end) {
+	const length = Math.abs(end - start) + 1;
+	if (!(start > end)) return Array.from({ length }, (_, index) => index + start);
+	return Array.from({ length }, (_, index) => start - index);
+}
+//#endregion
+//#region src/utils/shallow-equal/shallow-equal.ts
+function shallowEqual(a, b) {
+	if (a === b) return true;
+	if (Number.isNaN(a) && Number.isNaN(b)) return true;
+	if (!(a instanceof Object) || !(b instanceof Object)) return false;
+	const keys = Object.keys(a);
+	const { length } = keys;
+	if (length !== Object.keys(b).length) return false;
+	for (let i = 0; i < length; i += 1) {
+		const key = keys[i];
+		if (!(key in b)) return false;
+		if (a[key] !== b[key] && !(Number.isNaN(a[key]) && Number.isNaN(b[key]))) return false;
+	}
+	return true;
+}
+//#endregion
+//#region src/utils/upper-first/upper-first.ts
+function upperFirst(value) {
+	return typeof value !== "string" ? "" : value.charAt(0).toUpperCase() + value.slice(1);
+}
+//#endregion
+//#region src/utils/use-callback-ref/use-callback-ref.ts
+function useCallbackRef(callback) {
+	const callbackRef = ref(toValue(callback));
+	watchEffect(() => {
+		callbackRef.value = toValue(callback);
+	});
+	return ((...args) => callbackRef.value?.(...args));
+}
+//#endregion
+//#region src/use-debounced-callback/use-debounced-callback.ts
+function useDebouncedCallback(callback, waitOrOptions) {
+	const { delay, flushOnUnmount = false, leading = false, maxWait } = typeof waitOrOptions === "number" ? { delay: waitOrOptions } : waitOrOptions;
+	let timeout;
+	let maxTimeout;
+	let lastArgs;
+	let leadingCalled = false;
+	const clear = () => {
+		if (timeout) {
+			clearTimeout(timeout);
+			timeout = void 0;
+		}
+		if (maxTimeout) {
+			clearTimeout(maxTimeout);
+			maxTimeout = void 0;
+		}
+	};
+	const invoke = () => {
+		if (!lastArgs) return;
+		callback(...lastArgs);
+		lastArgs = void 0;
+		leadingCalled = false;
+		clear();
+	};
+	const cancel = () => {
+		lastArgs = void 0;
+		leadingCalled = false;
+		clear();
+	};
+	onBeforeUnmount(() => {
+		if (flushOnUnmount) invoke();
+		else cancel();
+	});
+	const debounced = (...args) => {
+		lastArgs = args;
+		if (leading && !leadingCalled) {
+			callback(...args);
+			lastArgs = void 0;
+			leadingCalled = true;
+			timeout = setTimeout(() => {
+				leadingCalled = false;
+				timeout = void 0;
+			}, delay);
+			return;
+		}
+		if (timeout) clearTimeout(timeout);
+		timeout = setTimeout(() => {
+			if (!leading || maxWait !== void 0) invoke();
+			else {
+				lastArgs = void 0;
+				leadingCalled = false;
+				clear();
+			}
+		}, delay);
+		if (maxWait !== void 0 && !maxTimeout) maxTimeout = setTimeout(invoke, maxWait);
+	};
+	debounced.cancel = cancel;
+	debounced.flush = invoke;
+	debounced.isPending = () => lastArgs !== void 0;
+	return debounced;
+}
+//#endregion
+//#region src/use-click-outside/use-click-outside.ts
+function useClickOutside(callback, events = ["mousedown", "touchstart"], nodes, enabled = true) {
+	const element = ref(null);
+	let activeEvents = [];
+	const listener = (event) => {
+		const target = event.target;
+		if (!target || !document.body.contains(target) && target.tagName !== "HTML") return;
+		const path = event.composedPath();
+		const resolvedNodes = nodes ? toValue(nodes) : void 0;
+		if (resolvedNodes) {
+			if (resolvedNodes.every((node) => !!node && !path.includes(node))) callback(event);
+		} else if (element.value && !path.includes(element.value)) callback(event);
+	};
+	const cleanup = () => {
+		activeEvents.forEach((event) => document.removeEventListener(event, listener));
+		activeEvents = [];
+	};
+	const bind = () => {
+		cleanup();
+		if (!toValue(enabled)) return;
+		activeEvents = toValue(events) || ["mousedown", "touchstart"];
+		activeEvents.forEach((event) => document.addEventListener(event, listener));
+	};
+	onMounted(bind);
+	watch([() => toValue(events)?.join(","), () => toValue(enabled)], bind);
+	onBeforeUnmount(cleanup);
+	return element;
+}
+//#endregion
+//#region src/use-clipboard/use-clipboard.ts
+function useClipboard({ timeout = 2e3 } = {}) {
+	const copied = ref(false);
+	const error = ref(null);
+	let timer;
+	const reset = () => {
+		copied.value = false;
+		error.value = null;
+		clearTimeout(timer);
+	};
+	const copy = async (value) => {
+		let succeeded = true;
+		if (typeof navigator !== "undefined" && navigator.clipboard) try {
+			await navigator.clipboard.writeText(value);
+			error.value = null;
+		} catch (err) {
+			error.value = err;
+			succeeded = false;
+		}
+		if (succeeded) {
+			copied.value = true;
+			clearTimeout(timer);
+			timer = setTimeout(() => {
+				copied.value = false;
+			}, timeout);
+		}
+	};
+	onBeforeUnmount(() => clearTimeout(timer));
+	return {
+		copy,
+		copied,
+		reset,
+		error
+	};
+}
+//#endregion
+//#region src/use-media-query/use-media-query.ts
+function getInitialMediaQueryValue(query, initialValue) {
+	if (typeof initialValue === "boolean") return initialValue;
+	if (typeof window !== "undefined" && typeof window.matchMedia === "function") return window.matchMedia(query).matches;
+	return false;
+}
+function useMediaQuery(query, initialValue = false, options = { getInitialValueInEffect: true }) {
+	const matches = ref(initialValue);
+	const instance = getCurrentInstance();
+	let mediaQueryList;
+	const cleanup = () => mediaQueryList?.removeEventListener("change", update);
+	const update = (event) => {
+		matches.value = event ? event.matches : Boolean(mediaQueryList?.matches);
+	};
+	if (!options.getInitialValueInEffect) matches.value = getInitialMediaQueryValue(toValue(query), initialValue);
+	if (instance) {
+		onMounted(() => {
+			if (typeof window === "undefined" || typeof window.matchMedia !== "function") return;
+			mediaQueryList = window.matchMedia(toValue(query));
+			update();
+			mediaQueryList.addEventListener("change", update);
+		});
+		onBeforeUnmount(cleanup);
+	}
+	watch(() => toValue(query), () => {
+		cleanup();
+		if (typeof window !== "undefined" && typeof window.matchMedia === "function") {
+			mediaQueryList = window.matchMedia(toValue(query));
+			update();
+			mediaQueryList.addEventListener("change", update);
+		}
+	});
+	return readonly(matches);
+}
+//#endregion
+//#region src/use-color-scheme/use-color-scheme.ts
+function useColorScheme(initialValue, options) {
+	const prefersDark = useMediaQuery("(prefers-color-scheme: dark)", initialValue === "dark", options);
+	return computed(() => prefersDark.value ? "dark" : "light");
+}
+//#endregion
+//#region src/use-counter/use-counter.ts
+function useCounter(initialValue = 0, options = {}) {
+	const step = Math.abs(options.step ?? 1);
+	const clamp = (value) => Math.min(options.max ?? value, Math.max(options.min ?? value, value));
+	const count = ref(clamp(initialValue));
+	const set = (value) => {
+		count.value = clamp(typeof value === "function" ? value(count.value) : value);
+	};
+	return [count, {
+		increment: () => set((value) => value + step),
+		decrement: () => set((value) => value - step),
+		set,
+		reset: () => set(initialValue)
+	}];
+}
+//#endregion
+//#region src/use-debounced-state/use-debounced-state.ts
+function useDebouncedState(initialValue, wait, options = {}) {
+	const value = ref(initialValue);
+	let timeout;
+	let leadingCalled = false;
+	const clear = () => {
+		if (timeout) {
+			clearTimeout(timeout);
+			timeout = void 0;
+		}
+	};
+	const setValue = (nextValue) => {
+		const next = nextValue instanceof Function ? nextValue(value.value) : nextValue;
+		if (options.leading && !leadingCalled) {
+			value.value = next;
+			leadingCalled = true;
+		} else {
+			clear();
+			timeout = setTimeout(() => {
+				value.value = next;
+				leadingCalled = false;
+			}, wait);
+		}
+	};
+	onBeforeUnmount(clear);
+	return [value, setValue];
+}
+//#endregion
+//#region src/use-debounced-value/use-debounced-value.ts
+function useDebouncedValue(value, wait, options = {}) {
+	const debounced = ref(toValue(value));
+	let timeout;
+	let cooldown = false;
+	let latestValue = toValue(value);
+	const cancel = () => {
+		if (timeout) {
+			clearTimeout(timeout);
+			timeout = void 0;
+		}
+		cooldown = false;
+	};
+	const flush = () => {
+		if (timeout) {
+			cancel();
+			debounced.value = latestValue;
+		}
+	};
+	watch(() => toValue(value), (nextValue) => {
+		latestValue = nextValue;
+		if (!cooldown && options.leading) {
+			cooldown = true;
+			debounced.value = nextValue;
+			timeout = setTimeout(() => {
+				cooldown = false;
+				timeout = void 0;
+			}, wait);
+		} else {
+			cancel();
+			timeout = setTimeout(() => {
+				cooldown = false;
+				timeout = void 0;
+				debounced.value = nextValue;
+			}, wait);
+		}
+	});
+	onBeforeUnmount(cancel);
+	return [
+		readonly(debounced),
+		cancel,
+		{
+			cancel,
+			flush
+		}
+	];
+}
+//#endregion
+//#region src/use-isomorphic-effect/use-isomorphic-effect.ts
+function useIsomorphicEffect(effect) {
+	if (typeof window === "undefined") return;
+	onMounted(effect);
+}
+//#endregion
+//#region src/use-document-title/use-document-title.ts
+function useDocumentTitle(title) {
+	useIsomorphicEffect(() => {
+		watch(() => toValue(title), (value) => {
+			const nextTitle = value.trim();
+			if (nextTitle) document.title = nextTitle;
+		}, { immediate: true });
+	});
+}
+//#endregion
+//#region src/use-document-visibility/use-document-visibility.ts
+function useDocumentVisibility() {
+	const documentVisibility = ref("visible");
+	const listener = () => {
+		documentVisibility.value = document.visibilityState;
+	};
+	onMounted(() => {
+		documentVisibility.value = document.visibilityState;
+		document.addEventListener("visibilitychange", listener);
+	});
+	onBeforeUnmount(() => document.removeEventListener("visibilitychange", listener));
+	return readonly(documentVisibility);
+}
+//#endregion
+//#region src/use-focus-return/use-focus-return.ts
+function useFocusReturn({ opened, shouldReturnFocus = true }) {
+	let lastActiveElement = null;
+	let timeout;
+	const value = (input) => typeof input === "function" ? input() : typeof input === "object" && input && "value" in input ? input.value : input;
+	const returnFocus = () => lastActiveElement?.focus?.({ preventScroll: true });
+	const clearOnTab = (event) => event.key === "Tab" && clearTimeout(timeout);
+	watch(() => value(opened), (isOpened, wasOpened) => {
+		if (typeof document === "undefined" || isOpened === wasOpened) return;
+		clearTimeout(timeout);
+		if (isOpened) {
+			lastActiveElement = document.activeElement;
+			document.addEventListener("keydown", clearOnTab);
+		} else {
+			document.removeEventListener("keydown", clearOnTab);
+			if (value(shouldReturnFocus)) {
+				const activeAtClose = document.activeElement;
+				timeout = setTimeout(() => {
+					if (!document.activeElement || document.activeElement === document.body || document.activeElement === activeAtClose) returnFocus();
+				}, 10);
+			}
+		}
+	});
+	onBeforeUnmount(() => {
+		clearTimeout(timeout);
+		document?.removeEventListener("keydown", clearOnTab);
+	});
+	return returnFocus;
+}
+//#endregion
+//#region src/use-did-update/use-did-update.ts
+function useDidUpdate(effect, deps) {
+	let cleanup;
+	const runEffect = () => {
+		cleanup?.();
+		cleanup = effect();
+	};
+	if (!deps) {
+		onUpdated(runEffect);
+		return;
+	}
+	watch(deps.map((dep) => () => toValue(dep)), runEffect);
+}
+//#endregion
+//#region src/use-focus-trap/tabbable.ts
+var TABBABLE_NODES = /input|select|textarea|button|object/;
+var FOCUS_SELECTOR = "a, input, select, textarea, button, object, [tabindex]";
+function hidden(element) {
+	if (typeof process !== "undefined" && process.env.NODE_ENV === "test") return false;
+	return element.style.display === "none";
+}
+function visible(element) {
+	if (element.getAttribute("aria-hidden") || element.getAttribute("hidden") || element.getAttribute("type") === "hidden") return false;
+	let parentElement = element;
+	while (parentElement) {
+		if (parentElement === document.body || parentElement.nodeType === 11) break;
+		if (hidden(parentElement)) return false;
+		parentElement = parentElement.parentNode;
+	}
+	return true;
+}
+function getElementTabIndex(element) {
+	const tabIndex = element.getAttribute("tabindex");
+	return Number.parseInt(tabIndex ?? "", 10);
+}
+function focusable(element) {
+	const nodeName = element.nodeName.toLowerCase();
+	const isTabIndexNotNaN = !Number.isNaN(getElementTabIndex(element));
+	const disabled = "disabled" in element ? Boolean(element.disabled) : false;
+	return (TABBABLE_NODES.test(nodeName) && !disabled || (element instanceof HTMLAnchorElement ? Boolean(element.href) || isTabIndexNotNaN : isTabIndexNotNaN)) && visible(element);
+}
+function tabbable(element) {
+	const tabIndex = getElementTabIndex(element);
+	return (Number.isNaN(tabIndex) || tabIndex >= 0) && focusable(element);
+}
+function findTabbableDescendants(element) {
+	return Array.from(element.querySelectorAll(FOCUS_SELECTOR)).filter(tabbable);
+}
+//#endregion
+//#region src/use-focus-trap/scope-tab.ts
+function scopeTab(node, event) {
+	const tabbable = findTabbableDescendants(node);
+	if (!tabbable.length) {
+		event.preventDefault();
+		return;
+	}
+	const finalTabbable = tabbable[event.shiftKey ? 0 : tabbable.length - 1];
+	const root = node.getRootNode();
+	let leavingFinalTabbable = finalTabbable === root.activeElement || node === root.activeElement;
+	const activeElement = root.activeElement;
+	if (activeElement?.tagName === "INPUT" && activeElement.getAttribute("type") === "radio") leavingFinalTabbable = tabbable.filter((element) => element.getAttribute("type") === "radio" && element.getAttribute("name") === activeElement.getAttribute("name")).includes(finalTabbable);
+	if (!leavingFinalTabbable) return;
+	event.preventDefault();
+	tabbable[event.shiftKey ? tabbable.length - 1 : 0]?.focus();
+}
+//#endregion
+//#region src/use-focus-trap/use-focus-trap.ts
+function getElement(node) {
+	return (node?.$el ?? node) || null;
+}
+function focusNode(node) {
+	let focusElement = node.querySelector("[data-autofocus]");
+	if (!focusElement) {
+		const children = Array.from(node.querySelectorAll(FOCUS_SELECTOR));
+		focusElement = children.find(tabbable) || children.find(focusable) || null;
+		if (!focusElement && focusable(node)) focusElement = node;
+	}
+	focusElement?.focus({ preventScroll: true });
+}
+function useFocusTrap(active = true) {
+	const refTarget = ref(null);
+	const isActive = () => toValue(active);
+	const setRef = (node) => {
+		const element = getElement(node);
+		if (!isActive()) {
+			refTarget.value = element;
+			return;
+		}
+		if (element === null) {
+			refTarget.value = null;
+			return;
+		}
+		if (refTarget.value === element) return;
+		setTimeout(() => {
+			if (element.isConnected || element.getRootNode()) focusNode(element);
+		});
+		refTarget.value = element;
+	};
+	const handleKeyDown = (event) => {
+		if (event.key === "Tab" && refTarget.value && isActive()) scopeTab(refTarget.value, event);
+	};
+	onMounted(() => {
+		if (typeof document === "undefined") return;
+		document.addEventListener("keydown", handleKeyDown);
+		if (isActive() && refTarget.value) setTimeout(() => {
+			if (refTarget.value) focusNode(refTarget.value);
+		});
+	});
+	onBeforeUnmount(() => {
+		if (typeof document !== "undefined") document.removeEventListener("keydown", handleKeyDown);
+	});
+	watch(() => isActive(), (value) => {
+		if (value && refTarget.value) setTimeout(() => {
+			if (refTarget.value) focusNode(refTarget.value);
+		});
+	});
+	return setRef;
+}
+//#endregion
+//#region src/use-force-update/use-force-update.ts
+function useForceUpdate() {
+	const key = ref(0);
+	return [key, () => key.value++];
+}
+//#endregion
+//#region src/use-id/use-id.ts
+var idCounter = 0;
+function useId(staticId) {
+	const id = ref(staticId || "");
+	onMounted(() => {
+		if (!id.value) id.value = `mantine-vue-${++idCounter}`;
+	});
+	if (staticId) id.value = staticId;
+	return id;
+}
+//#endregion
+//#region src/use-idle/use-idle.ts
+var DEFAULT_OPTIONS = {
+	events: [
+		"keydown",
+		"mousemove",
+		"touchmove",
+		"click",
+		"scroll",
+		"wheel"
+	],
+	initialState: true
+};
+function useIdle(timeout, options) {
+	const { events, initialState } = {
+		...DEFAULT_OPTIONS,
+		...options
+	};
+	const idle = ref(initialState);
+	let timer = -1;
+	const handleEvents = () => {
+		idle.value = false;
+		if (timer) window.clearTimeout(timer);
+		timer = window.setTimeout(() => {
+			idle.value = true;
+		}, toValue(timeout));
+	};
+	const bind = () => {
+		events.forEach((event) => document.addEventListener(event, handleEvents));
+		timer = window.setTimeout(() => {
+			idle.value = true;
+		}, toValue(timeout));
+	};
+	const cleanup = () => {
+		events.forEach((event) => document.removeEventListener(event, handleEvents));
+		window.clearTimeout(timer);
+		timer = -1;
+	};
+	onMounted(bind);
+	onBeforeUnmount(cleanup);
+	watch(() => toValue(timeout), () => {
+		cleanup();
+		bind();
+	});
+	return idle;
+}
+//#endregion
+//#region src/use-interval/use-interval.ts
+function useInterval(fn, interval, options = {}) {
+	const { autoInvoke = false } = options;
+	const active = ref(false);
+	let intervalId = null;
+	const start = () => {
+		if (!active.value && !intervalId) intervalId = window.setInterval(fn, toValue(interval));
+		active.value = true;
+	};
+	const stop = () => {
+		active.value = false;
+		if (intervalId) window.clearInterval(intervalId);
+		intervalId = null;
+	};
+	const toggle = () => {
+		if (active.value) stop();
+		else start();
+	};
+	watch(() => toValue(interval), () => {
+		if (active.value) {
+			stop();
+			start();
+		}
+	});
+	onMounted(() => {
+		if (autoInvoke) start();
+	});
+	onBeforeUnmount(stop);
+	return {
+		start,
+		stop,
+		toggle,
+		active
+	};
+}
+//#endregion
+//#region src/use-list-state/use-list-state.ts
+function useListState(initialValue = []) {
+	const state = ref(typeof initialValue === "function" ? initialValue() : initialValue);
+	const setState = (value) => {
+		state.value = typeof value === "function" ? value(state.value) : value;
+	};
+	const append = (...items) => setState((current) => [...current, ...items]);
+	const prepend = (...items) => setState((current) => [...items, ...current]);
+	const insert = (index, ...items) => setState((current) => [
+		...current.slice(0, index),
+		...items,
+		...current.slice(index)
+	]);
+	const apply = (fn) => setState((current) => current.map((item, index) => fn(item, index)));
+	const remove = (...indices) => setState((current) => current.filter((_, index) => !indices.includes(index)));
+	const pop = () => setState((current) => {
+		const cloned = [...current];
+		cloned.pop();
+		return cloned;
+	});
+	const shift = () => setState((current) => {
+		const cloned = [...current];
+		cloned.shift();
+		return cloned;
+	});
+	const reorder = ({ from, to }) => setState((current) => {
+		const cloned = [...current];
+		const item = current[from];
+		cloned.splice(from, 1);
+		cloned.splice(to, 0, item);
+		return cloned;
+	});
+	const swap = ({ from, to }) => setState((current) => {
+		const cloned = [...current];
+		const fromItem = cloned[from];
+		const toItem = cloned[to];
+		cloned.splice(to, 1, fromItem);
+		cloned.splice(from, 1, toItem);
+		return cloned;
+	});
+	const setItem = (index, item) => setState((current) => {
+		const cloned = [...current];
+		cloned[index] = item;
+		return cloned;
+	});
+	const setItemProp = (index, prop, value) => setState((current) => {
+		const cloned = [...current];
+		cloned[index] = {
+			...cloned[index],
+			[prop]: value
+		};
+		return cloned;
+	});
+	const applyWhere = (condition, fn) => setState((current) => current.map((item, index) => condition(item, index) ? fn(item, index) : item));
+	const filter = (fn) => {
+		setState((current) => current.filter(fn));
+	};
+	return [state, {
+		setState,
+		append,
+		prepend,
+		insert,
+		pop,
+		shift,
+		apply,
+		applyWhere,
+		remove,
+		reorder,
+		swap,
+		setItem,
+		setItemProp,
+		filter
+	}];
+}
+//#endregion
+//#region src/use-window-event/use-window-event.ts
+function useWindowEvent(type, listener, options) {
+	const getListener = () => isRef(listener) ? listener.value : listener;
+	const handler = (event) => getListener()(event);
+	let currentType;
+	let mounted = false;
+	const add = (eventType) => {
+		currentType = eventType;
+		window.addEventListener(eventType, handler, options);
+	};
+	const remove = () => {
+		if (currentType) {
+			window.removeEventListener(currentType, handler, options);
+			currentType = void 0;
+		}
+	};
+	onMounted(() => {
+		mounted = true;
+		add(toValue(type));
+	});
+	watch(() => toValue(type), (nextType) => {
+		if (mounted && nextType !== currentType) {
+			remove();
+			add(nextType);
+		}
+	});
+	onBeforeUnmount(remove);
+}
+//#endregion
+//#region src/use-local-storage/create-storage.ts
+function serializeJSON(value, hookName = "use-local-storage") {
+	try {
+		return JSON.stringify(value);
+	} catch {
+		throw new Error(`@mantine-vue/hooks ${hookName}: Failed to serialize the value`);
+	}
+}
+function deserializeJSON(value) {
+	try {
+		return value && JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+function createStorageHandler(type) {
+	const getItem = (key) => {
+		try {
+			return window[type].getItem(key);
+		} catch {
+			console.warn(`use-local-storage: Failed to get value from storage, ${type} is blocked`);
+			return null;
+		}
+	};
+	const setItem = (key, value) => {
+		try {
+			window[type].setItem(key, value);
+		} catch {
+			console.warn(`use-local-storage: Failed to set value to storage, ${type} is blocked`);
+		}
+	};
+	const removeItem = (key) => {
+		try {
+			window[type].removeItem(key);
+		} catch {
+			console.warn(`use-local-storage: Failed to remove value from storage, ${type} is blocked`);
+		}
+	};
+	return {
+		getItem,
+		setItem,
+		removeItem
+	};
+}
+function createStorage(type, hookName) {
+	const eventName = type === "localStorage" ? "mantine-vue-local-storage" : "mantine-vue-session-storage";
+	const { getItem, setItem, removeItem } = createStorageHandler(type);
+	return function useStorage({ key, defaultValue, getInitialValueInEffect = true, sync = true, deserialize = deserializeJSON, serialize = (value) => serializeJSON(value, hookName) }) {
+		const readStorageValue = (skipStorage) => {
+			let storageBlockedOrSkipped;
+			try {
+				storageBlockedOrSkipped = typeof window === "undefined" || !(type in window) || window[type] === null || !!skipStorage;
+			} catch {
+				storageBlockedOrSkipped = true;
+			}
+			if (storageBlockedOrSkipped) return defaultValue;
+			const storageValue = getItem(key);
+			return storageValue !== null ? deserialize(storageValue) : defaultValue;
+		};
+		const value = ref(readStorageValue(getInitialValueInEffect));
+		const dispatchSyncEvent = (result) => {
+			if (typeof window === "undefined") return;
+			queueMicrotask(() => {
+				window.dispatchEvent(new CustomEvent(eventName, { detail: {
+					key,
+					value: result
+				} }));
+			});
+		};
+		const setStorageValue = (val) => {
+			const result = val instanceof Function ? val(value.value) : val;
+			setItem(key, serialize(result));
+			value.value = result;
+			dispatchSyncEvent(result);
+		};
+		const removeStorageValue = () => {
+			removeItem(key);
+			value.value = defaultValue;
+			dispatchSyncEvent(defaultValue);
+		};
+		useWindowEvent("storage", (event) => {
+			if (sync && event.storageArea === window[type] && event.key === key) value.value = deserialize(event.newValue ?? void 0);
+		});
+		const handleSyncEvent = (event) => {
+			const detail = event.detail;
+			if (sync && detail.key === key) value.value = detail.value;
+		};
+		onMounted(() => {
+			window.addEventListener(eventName, handleSyncEvent);
+			if (defaultValue !== void 0 && value.value === void 0) setStorageValue(defaultValue);
+			const val = readStorageValue();
+			if (val !== void 0) value.value = val;
+		});
+		onBeforeUnmount(() => {
+			window.removeEventListener(eventName, handleSyncEvent);
+		});
+		return [
+			value,
+			setStorageValue,
+			removeStorageValue
+		];
+	};
+}
+function readValue(type) {
+	const { getItem } = createStorageHandler(type);
+	return function read({ key, defaultValue, deserialize = deserializeJSON }) {
+		let storageBlockedOrSkipped;
+		try {
+			storageBlockedOrSkipped = typeof window === "undefined" || !(type in window) || window[type] === null;
+		} catch {
+			storageBlockedOrSkipped = true;
+		}
+		if (storageBlockedOrSkipped) return defaultValue;
+		const storageValue = getItem(key);
+		return storageValue !== null ? deserialize(storageValue) : defaultValue;
+	};
+}
+//#endregion
+//#region src/use-local-storage/use-local-storage.ts
+function readLocalStorageValue(options) {
+	return readValue("localStorage")(options);
+}
+function useLocalStorage(options) {
+	return createStorage("localStorage", "use-local-storage")(options);
+}
+//#endregion
+//#region src/use-session-storage/use-session-storage.ts
+function readSessionStorageValue(options) {
+	return readValue("sessionStorage")(options);
+}
+function useSessionStorage(options) {
+	return createStorage("sessionStorage", "use-session-storage")(options);
+}
+//#endregion
+//#region src/use-merged-ref/use-merged-ref.ts
+function assignRef(refTarget, value) {
+	if (typeof refTarget === "function") refTarget(value);
+	else if (refTarget) refTarget.value = value;
+}
+function mergeRefs(...refs) {
+	return (value) => refs.forEach((refTarget) => assignRef(refTarget, value));
+}
+function useMergedRef(...refs) {
+	return mergeRefs(...refs);
+}
+//#endregion
+//#region src/use-mouse/use-mouse.ts
+function useMouse(options = { resetOnExit: false }) {
+	const elementRef = ref(null);
+	const x = ref(0);
+	const y = ref(0);
+	let cleanup;
+	watch(elementRef, (node) => {
+		cleanup?.();
+		cleanup = void 0;
+		const target = node instanceof EventTarget ? node : null;
+		const setMousePosition = (event) => {
+			const mouseEvent = event;
+			if (target) {
+				const rect = target.getBoundingClientRect();
+				x.value = Math.max(0, Math.round(mouseEvent.clientX - rect.left));
+				y.value = Math.max(0, Math.round(mouseEvent.clientY - rect.top));
+			} else {
+				x.value = mouseEvent.clientX;
+				y.value = mouseEvent.clientY;
+			}
+		};
+		const resetMousePosition = () => {
+			x.value = 0;
+			y.value = 0;
+		};
+		target?.addEventListener("mousemove", setMousePosition);
+		if (options.resetOnExit) target?.addEventListener("mouseleave", resetMousePosition);
+		cleanup = () => {
+			target?.removeEventListener("mousemove", setMousePosition);
+			if (options.resetOnExit) target?.removeEventListener("mouseleave", resetMousePosition);
+		};
+	}, { immediate: true });
+	onBeforeUnmount(() => cleanup?.());
+	return {
+		ref: elementRef,
+		x,
+		y
+	};
+}
+function useMousePosition() {
+	const x = ref(0);
+	const y = ref(0);
+	const setMousePosition = (event) => {
+		x.value = event.clientX;
+		y.value = event.clientY;
+	};
+	onMounted(() => document.addEventListener("mousemove", setMousePosition));
+	onBeforeUnmount(() => document.removeEventListener("mousemove", setMousePosition));
+	return {
+		x,
+		y
+	};
+}
+//#endregion
+//#region src/use-move/use-move.ts
+var clamp$3 = (value, min, max) => Math.min(max, Math.max(min, value));
+function clampUseMovePosition(position) {
+	return {
+		x: clamp$3(position.x, 0, 1),
+		y: clamp$3(position.y, 0, 1)
+	};
+}
+function useMove(onChange, handlers = {}, dir = "ltr") {
+	const active = ref(false);
+	let element = null;
+	let mounted = false;
+	let frame = 0;
+	const scrub = (x, y) => {
+		cancelAnimationFrame(frame);
+		frame = requestAnimationFrame(() => {
+			if (!mounted || !element) return;
+			const rect = element.getBoundingClientRect();
+			if (!rect.width || !rect.height) return;
+			const positionX = clamp$3((x - rect.left) / rect.width, 0, 1);
+			onChange({
+				x: dir === "ltr" ? positionX : 1 - positionX,
+				y: clamp$3((y - rect.top) / rect.height, 0, 1)
+			});
+		});
+	};
+	const mouseMove = (event) => scrub(event.clientX, event.clientY);
+	const touchMove = (event) => {
+		if (event.cancelable) event.preventDefault();
+		const touch = event.changedTouches[0];
+		if (touch) scrub(touch.clientX, touch.clientY);
+	};
+	const unbind = () => {
+		document.removeEventListener("mousemove", mouseMove);
+		document.removeEventListener("mouseup", stop);
+		document.removeEventListener("touchmove", touchMove);
+		document.removeEventListener("touchend", stop);
+	};
+	const stop = () => {
+		if (!active.value) return;
+		active.value = false;
+		unbind();
+		setTimeout(() => handlers.onScrubEnd?.(), 0);
+	};
+	const start = (event) => {
+		if (!mounted) return;
+		if ("button" in event && event.button !== 0) return;
+		if (event.cancelable) event.preventDefault();
+		active.value = true;
+		handlers.onScrubStart?.();
+		document.addEventListener("mousemove", mouseMove);
+		document.addEventListener("mouseup", stop);
+		document.addEventListener("touchmove", touchMove, { passive: false });
+		document.addEventListener("touchend", stop);
+		if ("changedTouches" in event) touchMove(event);
+		else mouseMove(event);
+	};
+	const setRef = (node) => {
+		const safeNode = node instanceof HTMLElement ? node : null;
+		element?.removeEventListener("mousedown", start);
+		element?.removeEventListener("touchstart", start);
+		element = safeNode;
+		element?.addEventListener("mousedown", start);
+		element?.addEventListener("touchstart", start, { passive: false });
+	};
+	onMounted(() => {
+		mounted = true;
+	});
+	onBeforeUnmount(() => {
+		mounted = false;
+		unbind();
+		cancelAnimationFrame(frame);
+		element?.removeEventListener("mousedown", start);
+		element?.removeEventListener("touchstart", start);
+	});
+	return {
+		ref: setRef,
+		active: readonly(active)
+	};
+}
+//#endregion
+//#region src/use-uncontrolled/use-uncontrolled.ts
+function useUncontrolled({ value, defaultValue, finalValue, onChange = () => {} }) {
+	const uncontrolledValue = ref(defaultValue !== void 0 ? defaultValue : finalValue);
+	const isControlled = computed(() => toValue(value) !== void 0);
+	return [
+		computed({
+			get: () => isControlled.value ? toValue(value) : uncontrolledValue.value,
+			set: (nextValue) => {
+				if (!isControlled.value) uncontrolledValue.value = nextValue;
+				onChange(nextValue);
+			}
+		}),
+		(nextValue, ...payload) => {
+			if (!isControlled.value) uncontrolledValue.value = nextValue;
+			onChange(nextValue, ...payload);
+		},
+		isControlled
+	];
+}
+//#endregion
+//#region src/use-pagination/use-pagination.ts
+var DOTS = "dots";
+function range$1(start, end) {
+	const length = Math.max(end - start + 1, 0);
+	return Array.from({ length }, (_, index) => index + start);
+}
+function usePagination({ total, siblings = 1, boundaries = 1, page, initialPage, onChange, startValue = 1 }) {
+	const start = computed(() => Math.max(Math.trunc(startValue), 1));
+	const end = computed(() => Math.max(Math.trunc(total), start.value));
+	const totalPages = computed(() => end.value - start.value + 1);
+	const firstPage = computed(() => initialPage ?? start.value);
+	const [active, setActive] = useUncontrolled({
+		value: page,
+		defaultValue: firstPage.value,
+		finalValue: firstPage.value,
+		onChange
+	});
+	const setPage = (pageNumber) => {
+		const nextPage = Math.min(end.value, Math.max(start.value, pageNumber));
+		if (nextPage !== active.value) setActive(nextPage);
+	};
+	return {
+		range: computed(() => {
+			if (siblings * 2 + 3 + boundaries * 2 >= totalPages.value) return range$1(start.value, end.value);
+			const leftSiblingIndex = Math.max(active.value - siblings, start.value + boundaries - 1);
+			const rightSiblingIndex = Math.min(active.value + siblings, end.value - boundaries);
+			const shouldShowLeftDots = leftSiblingIndex > start.value + boundaries + 1;
+			const shouldShowRightDots = rightSiblingIndex < end.value - boundaries;
+			if (!shouldShowLeftDots && shouldShowRightDots) {
+				const leftItemCount = siblings * 2 + boundaries + 2;
+				return [
+					...range$1(start.value, start.value + leftItemCount - 1),
+					DOTS,
+					...range$1(end.value - (boundaries - 1), end.value)
+				];
+			}
+			if (shouldShowLeftDots && !shouldShowRightDots) {
+				const rightItemCount = boundaries + 1 + siblings * 2;
+				return [
+					...range$1(start.value, start.value + boundaries - 1),
+					DOTS,
+					...range$1(end.value - rightItemCount, end.value)
+				];
+			}
+			return [
+				...range$1(start.value, start.value + boundaries - 1),
+				DOTS,
+				...range$1(leftSiblingIndex, rightSiblingIndex),
+				DOTS,
+				...range$1(end.value - boundaries + 1, end.value)
+			];
+		}),
+		active,
+		setPage,
+		next: () => setPage(active.value + 1),
+		previous: () => setPage(active.value - 1),
+		first: () => setPage(start.value),
+		last: () => setPage(end.value)
+	};
+}
+//#endregion
+//#region src/use-queue/use-queue.ts
+function useQueue({ initialValues = [], limit }) {
+	const stateRef = ref(initialValues.slice(0, limit));
+	const queueRef = ref(initialValues.slice(limit));
+	const add = (...items) => {
+		const results = [
+			...stateRef.value,
+			...queueRef.value,
+			...items
+		];
+		stateRef.value = results.slice(0, limit);
+		queueRef.value = results.slice(limit);
+	};
+	const update = (fn) => {
+		const results = fn([...stateRef.value, ...queueRef.value]);
+		stateRef.value = results.slice(0, limit);
+		queueRef.value = results.slice(limit);
+	};
+	const cleanQueue = () => {
+		queueRef.value = [];
+	};
+	return {
+		state: readonly(stateRef),
+		queue: readonly(queueRef),
+		add,
+		update,
+		cleanQueue
+	};
+}
+//#endregion
+//#region src/use-page-leave/use-page-leave.ts
+function usePageLeave(onPageLeave) {
+	const getHandler = () => isRef(onPageLeave) ? onPageLeave.value : onPageLeave;
+	const handleMouseLeave = () => getHandler()();
+	onMounted(() => {
+		document.documentElement.addEventListener("mouseleave", handleMouseLeave);
+	});
+	onBeforeUnmount(() => {
+		document.documentElement.removeEventListener("mouseleave", handleMouseLeave);
+	});
+}
+//#endregion
+//#region src/use-reduced-motion/use-reduced-motion.ts
+function useReducedMotion(initialValue, options) {
+	return useMediaQuery("(prefers-reduced-motion: reduce)", initialValue, options);
+}
+//#endregion
+//#region src/use-scroll-into-view/use-scroll-into-view.ts
+function useScrollIntoView(options = {}) {
+	const { duration = 1250, axis = "y", onScrollFinish, onScrollCancel, easing = easeInOutQuad, offset = 0, cancelable = true, isList = false } = options;
+	const frameID = ref(0);
+	const startTime = ref(0);
+	const shouldStop = ref(false);
+	const scrolling = ref(false);
+	const scrollableRef = ref(null);
+	const targetRef = ref(null);
+	const reducedMotion = useReducedMotion();
+	const cancel = () => {
+		if (frameID.value) {
+			cancelAnimationFrame(frameID.value);
+			frameID.value = 0;
+			scrolling.value = false;
+		}
+	};
+	const scrollIntoView = ({ alignment = "start" } = {}) => {
+		shouldStop.value = false;
+		if (frameID.value) cancel();
+		const start = getScrollStart({
+			parent: scrollableRef.value,
+			axis
+		}) ?? 0;
+		const change = getRelativePosition({
+			parent: scrollableRef.value,
+			target: targetRef.value,
+			axis,
+			alignment,
+			offset,
+			isList
+		}) - (scrollableRef.value ? 0 : start);
+		scrolling.value = true;
+		function animateScroll() {
+			if (startTime.value === 0) startTime.value = performance.now();
+			const elapsed = performance.now() - startTime.value;
+			const t = reducedMotion.value || duration === 0 ? 1 : elapsed / duration;
+			const distance = start + change * easing(t);
+			setScrollParam({
+				parent: scrollableRef.value,
+				axis,
+				distance
+			});
+			if (!shouldStop.value && t < 1) frameID.value = requestAnimationFrame(animateScroll);
+			else {
+				if (shouldStop.value) onScrollCancel?.();
+				else onScrollFinish?.();
+				startTime.value = 0;
+				frameID.value = 0;
+				scrolling.value = false;
+				cancel();
+			}
+		}
+		animateScroll();
+	};
+	const handleStop = () => {
+		if (cancelable) shouldStop.value = true;
+	};
+	/**
+	* Detection of one of these events stops scroll animation
+	* wheel - mouse wheel / touch pad
+	* touchmove - any touchable device
+	*/
+	useWindowEvent("wheel", handleStop, { passive: true });
+	useWindowEvent("touchmove", handleStop, { passive: true });
+	onBeforeUnmount(cancel);
+	return {
+		scrollableRef,
+		targetRef,
+		scrollIntoView,
+		cancel,
+		scrolling
+	};
+}
+function easeInOutQuad(t) {
+	return t < .5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+}
+function getRelativePosition({ axis, target, parent, alignment, offset, isList }) {
+	const safeTarget = target instanceof Element ? target : null;
+	const safeParent = parent instanceof Element ? parent : null;
+	if (!safeTarget || !safeParent && typeof document === "undefined") return 0;
+	const isCustomParent = !!safeParent;
+	const parentPosition = (safeParent || document.body).getBoundingClientRect();
+	const targetPosition = safeTarget.getBoundingClientRect();
+	const getDiff = (property) => targetPosition[property] - parentPosition[property];
+	if (axis === "y") {
+		const diff = getDiff("top");
+		if (diff === 0) return 0;
+		if (alignment === "start") {
+			const distance = diff - offset;
+			return distance <= targetPosition.height * (isList ? 0 : 1) || !isList ? distance : 0;
+		}
+		const parentHeight = isCustomParent ? parentPosition.height : window.innerHeight;
+		if (alignment === "end") {
+			const distance = diff + offset - parentHeight + targetPosition.height;
+			return distance >= -targetPosition.height * (isList ? 0 : 1) || !isList ? distance : 0;
+		}
+		if (alignment === "center") return diff - parentHeight / 2 + targetPosition.height / 2;
+		return 0;
+	}
+	if (axis === "x") {
+		const diff = getDiff("left");
+		if (diff === 0) return 0;
+		if (alignment === "start") {
+			const distance = diff - offset;
+			return distance <= targetPosition.width || !isList ? distance : 0;
+		}
+		const parentWidth = isCustomParent ? parentPosition.width : window.innerWidth;
+		if (alignment === "end") {
+			const distance = diff + offset - parentWidth + targetPosition.width;
+			return distance >= -targetPosition.width || !isList ? distance : 0;
+		}
+		if (alignment === "center") return diff - parentWidth / 2 + targetPosition.width / 2;
+		return 0;
+	}
+	return 0;
+}
+function getScrollStart({ axis, parent }) {
+	const safeParent = parent instanceof Element ? parent : null;
+	if (!safeParent && typeof document === "undefined") return 0;
+	const method = axis === "y" ? "scrollTop" : "scrollLeft";
+	if (safeParent) return safeParent[method];
+	const { body, documentElement } = document;
+	return body[method] + documentElement[method];
+}
+function setScrollParam({ axis, parent, distance }) {
+	const safeParent = parent instanceof Element ? parent : null;
+	if (!safeParent && typeof document === "undefined") return;
+	const method = axis === "y" ? "scrollTop" : "scrollLeft";
+	if (safeParent) safeParent[method] = distance;
+	else {
+		const { body, documentElement } = document;
+		body[method] = distance;
+		documentElement[method] = distance;
+	}
+}
+//#endregion
+//#region src/use-resize-observer/use-resize-observer.ts
+var defaultState = {
+	x: 0,
+	y: 0,
+	width: 0,
+	height: 0,
+	top: 0,
+	left: 0,
+	bottom: 0,
+	right: 0
+};
+function useResizeObserver(options) {
+	const elementRef = ref(null);
+	const rect = ref(defaultState);
+	let observer;
+	const disconnect = () => {
+		observer?.disconnect();
+		observer = void 0;
+	};
+	watch(elementRef, (node) => {
+		disconnect();
+		if (!node || typeof ResizeObserver === "undefined") return;
+		observer = new ResizeObserver((entries) => {
+			const entry = entries[0];
+			if (entry) {
+				const boxSize = entry.borderBoxSize?.[0] || entry.contentBoxSize?.[0];
+				if (boxSize) rect.value = {
+					width: boxSize.inlineSize,
+					height: boxSize.blockSize,
+					x: entry.contentRect.x,
+					y: entry.contentRect.y,
+					top: entry.contentRect.top,
+					left: entry.contentRect.left,
+					bottom: entry.contentRect.bottom,
+					right: entry.contentRect.right
+				};
+				else rect.value = entry.contentRect;
+			}
+		});
+		observer.observe(node, options);
+	}, {
+		immediate: true,
+		flush: "sync"
+	});
+	onBeforeUnmount(disconnect);
+	return {
+		ref: elementRef,
+		rect
+	};
+}
+function useElementSize(options) {
+	const { ref: elementRef, rect } = useResizeObserver(options);
+	const width = ref(0);
+	const height = ref(0);
+	watch(rect, (value) => {
+		width.value = value.width;
+		height.value = value.height;
+	}, { immediate: true });
+	return {
+		ref: elementRef,
+		width,
+		height
+	};
+}
+//#endregion
+//#region src/use-shallow-effect/use-shallow-effect.ts
+function shallowEqual$1(a, b) {
+	if (a === b) return true;
+	if (typeof a === "number" && typeof b === "number" && Number.isNaN(a) && Number.isNaN(b)) return true;
+	if (!(a instanceof Object) || !(b instanceof Object)) return false;
+	const keys = Object.keys(a);
+	const { length } = keys;
+	if (length !== Object.keys(b).length) return false;
+	for (let i = 0; i < length; i += 1) {
+		const key = keys[i];
+		if (!(key in b)) return false;
+		const aValue = a[key];
+		const bValue = b[key];
+		if (aValue !== bValue && !(Number.isNaN(aValue) && Number.isNaN(bValue))) return false;
+	}
+	return true;
+}
+function shallowCompareDeps(prev, curr) {
+	if (!prev || !curr) return false;
+	if (prev === curr) return true;
+	if (prev.length !== curr.length) return false;
+	for (let i = 0; i < prev.length; i += 1) if (!shallowEqual$1(prev[i], curr[i])) return false;
+	return true;
+}
+function useShallowEffect(effect, dependencies) {
+	if (!dependencies) {
+		effect();
+		onUpdated(effect);
+		return;
+	}
+	let previous;
+	const getDeps = () => dependencies.map((dep) => toValue(dep));
+	watch(getDeps, (curr) => {
+		if (!shallowCompareDeps(previous, curr)) {
+			previous = curr;
+			effect();
+		}
+	}, { immediate: true });
+}
+//#endregion
+//#region src/use-toggle/use-toggle.ts
+function useToggle(options = [false, true]) {
+	const state = ref(options[0]);
+	const toggle = (value) => {
+		if (value !== void 0) {
+			const nextValue = value instanceof Function ? value(state.value) : value;
+			state.value = options[Math.abs(options.indexOf(nextValue))];
+			return;
+		}
+		state.value = options[(options.indexOf(state.value) + 1) % options.length];
+	};
+	return [state, toggle];
+}
+//#endregion
+//#region src/use-viewport-size/use-viewport-size.ts
+var eventListenerOptions = { passive: true };
+function useViewportSize() {
+	const width = ref(0);
+	const height = ref(0);
+	const setSize = () => {
+		width.value = window.innerWidth || 0;
+		height.value = window.innerHeight || 0;
+	};
+	useWindowEvent("resize", setSize, eventListenerOptions);
+	useWindowEvent("orientationchange", setSize, eventListenerOptions);
+	onMounted(setSize);
+	return {
+		width,
+		height
+	};
+}
+//#endregion
+//#region src/use-window-scroll/use-window-scroll.ts
+function getScrollPosition() {
+	return typeof window !== "undefined" ? {
+		x: window.scrollX,
+		y: window.scrollY
+	} : {
+		x: 0,
+		y: 0
+	};
+}
+function scrollTo({ x, y }) {
+	if (typeof window !== "undefined") {
+		const scrollOptions = { behavior: "smooth" };
+		if (typeof x === "number") scrollOptions.left = x;
+		if (typeof y === "number") scrollOptions.top = y;
+		window.scrollTo(scrollOptions);
+	}
+}
+function useWindowScroll() {
+	const position = ref({
+		x: 0,
+		y: 0
+	});
+	useWindowEvent("scroll", () => position.value = getScrollPosition(), { passive: true });
+	useWindowEvent("resize", () => position.value = getScrollPosition(), { passive: true });
+	onMounted(() => {
+		position.value = getScrollPosition();
+	});
+	return [position, scrollTo];
+}
+//#endregion
+//#region src/use-intersection/use-intersection.ts
+function useIntersection(options) {
+	const elementRef = ref(null);
+	const entry = ref(null);
+	let observer;
+	watch(elementRef, (node) => {
+		observer?.disconnect();
+		observer = void 0;
+		if (!node) {
+			entry.value = null;
+			return;
+		}
+		observer = new IntersectionObserver(([_entry]) => {
+			entry.value = _entry;
+		}, options);
+		observer.observe(node);
+	}, { immediate: true });
+	onBeforeUnmount(() => observer?.disconnect());
+	return {
+		ref: elementRef,
+		entry
+	};
+}
+//#endregion
+//#region src/use-hash/use-hash.ts
+function getInitialHash(getInitialValueInEffect) {
+	if (getInitialValueInEffect) return "";
+	return typeof window !== "undefined" ? window.location.hash || "" : "";
+}
+function useHash(options = {}) {
+	const { getInitialValueInEffect = true } = options;
+	const hash = ref(getInitialHash(getInitialValueInEffect));
+	const setHashHandler = (value) => {
+		const valueWithHash = value.startsWith("#") ? value : `#${value}`;
+		if (typeof window !== "undefined") window.location.hash = valueWithHash;
+		hash.value = valueWithHash;
+	};
+	useWindowEvent("hashchange", () => {
+		const newHash = window.location.hash;
+		if (hash.value !== newHash) hash.value = newHash;
+	});
+	onMounted(() => {
+		if (getInitialValueInEffect) hash.value = window.location.hash;
+	});
+	return [hash, setHashHandler];
+}
+//#endregion
+//#region src/use-hotkeys/parse-hotkey.ts
+var keyNameMap = {
+	" ": "space",
+	ArrowLeft: "arrowleft",
+	ArrowRight: "arrowright",
+	ArrowUp: "arrowup",
+	ArrowDown: "arrowdown",
+	Escape: "escape",
+	Esc: "escape",
+	esc: "escape",
+	Enter: "enter",
+	Tab: "tab",
+	Backspace: "backspace",
+	Delete: "delete",
+	Insert: "insert",
+	Home: "home",
+	End: "end",
+	PageUp: "pageup",
+	PageDown: "pagedown",
+	"+": "plus",
+	"-": "minus",
+	"*": "asterisk",
+	"/": "slash"
+};
+function normalizeKey(key) {
+	const lowerKey = key.replace("Key", "").toLowerCase();
+	return keyNameMap[key] || lowerKey;
+}
+function parseHotkey(hotkey) {
+	const keys = hotkey.toLowerCase().split("+").map((part) => part.trim());
+	const modifiers = {
+		alt: keys.includes("alt"),
+		ctrl: keys.includes("ctrl"),
+		meta: keys.includes("meta"),
+		mod: keys.includes("mod"),
+		shift: keys.includes("shift")
+	};
+	const reservedKeys = [
+		"alt",
+		"ctrl",
+		"meta",
+		"shift",
+		"mod"
+	];
+	const freeKey = keys.find((key) => !reservedKeys.includes(key));
+	return {
+		...modifiers,
+		key: freeKey === "[plus]" ? "+" : freeKey
+	};
+}
+function isExactHotkey(hotkey, event, usePhysicalKeys) {
+	const { alt, ctrl, meta, mod, shift, key } = hotkey;
+	const { altKey, ctrlKey, metaKey, shiftKey, key: pressedKey, code: pressedCode } = event;
+	if (alt !== altKey) return false;
+	if (mod) {
+		if (!ctrlKey && !metaKey) return false;
+	} else {
+		if (ctrl !== ctrlKey) return false;
+		if (meta !== metaKey) return false;
+	}
+	if (shift !== shiftKey) return false;
+	if (key && (usePhysicalKeys ? normalizeKey(pressedCode) === normalizeKey(key) : normalizeKey(pressedKey ?? pressedCode) === normalizeKey(key))) return true;
+	return false;
+}
+function getHotkeyMatcher(hotkey, usePhysicalKeys) {
+	return (event) => isExactHotkey(parseHotkey(hotkey), event, usePhysicalKeys);
+}
+function getHotkeyHandler(hotkeys) {
+	return (event) => {
+		hotkeys.forEach(([hotkey, handler, options = {
+			preventDefault: true,
+			usePhysicalKeys: false
+		}]) => {
+			if (getHotkeyMatcher(hotkey, options.usePhysicalKeys)(event)) {
+				if (options.preventDefault) event.preventDefault();
+				handler(event);
+			}
+		});
+	};
+}
+//#endregion
+//#region src/use-hotkeys/use-hotkeys.ts
+function shouldFireEvent(event, tagsToIgnore, triggerOnContentEditable = false) {
+	if (event.target instanceof HTMLElement) {
+		const tagName = event.target.tagName.toLowerCase();
+		if (triggerOnContentEditable) return !tagsToIgnore.includes(tagName);
+		return !event.target.isContentEditable && !tagsToIgnore.includes(tagName);
+	}
+	return true;
+}
+/**
+* Listens for global keydown events and invokes matching handlers.
+*
+* NOTE: the listener is attached to `window` rather than
+* `document.documentElement` (which is what React Mantine uses). Real
+* keyboard events always bubble to `window`, so this is behaviorally
+* equivalent for actual usage while remaining consistent with how the rest
+* of this package (and its test suite) dispatches synthetic events.
+*/
+function useHotkeys(hotkeys, tagsToIgnore = [
+	"input",
+	"textarea",
+	"select"
+], triggerOnContentEditable = false) {
+	const handleKeydown = (event) => {
+		toValue(hotkeys).forEach(([hotkey, handler, options = {
+			preventDefault: true,
+			usePhysicalKeys: false
+		}]) => {
+			if (getHotkeyMatcher(hotkey, options.usePhysicalKeys)(event) && shouldFireEvent(event, toValue(tagsToIgnore) ?? [
+				"input",
+				"textarea",
+				"select"
+			], toValue(triggerOnContentEditable))) {
+				if (options.preventDefault) event.preventDefault();
+				handler(event);
+			}
+		});
+	};
+	onMounted(() => window.addEventListener("keydown", handleKeydown));
+	onBeforeUnmount(() => window.removeEventListener("keydown", handleKeydown));
+}
+//#endregion
+//#region src/use-fullscreen/use-fullscreen.ts
+function getFullscreenElement() {
+	const _document = window.document;
+	return _document.fullscreenElement || _document.webkitFullscreenElement || _document.mozFullScreenElement || _document.msFullscreenElement || null;
+}
+function exitFullscreen() {
+	const _document = window.document;
+	if (typeof _document.exitFullscreen === "function") return _document.exitFullscreen();
+	if (typeof _document.msExitFullscreen === "function") return _document.msExitFullscreen();
+	if (typeof _document.webkitExitFullscreen === "function") return _document.webkitExitFullscreen();
+	if (typeof _document.mozCancelFullScreen === "function") return _document.mozCancelFullScreen();
+	return null;
+}
+function enterFullScreen(element) {
+	const _element = element;
+	return _element.requestFullscreen?.() || _element.msRequestFullscreen?.() || _element.webkitEnterFullscreen?.() || _element.webkitRequestFullscreen?.() || _element.mozRequestFullscreen?.();
+}
+var prefixes = [
+	"",
+	"webkit",
+	"moz",
+	"ms"
+];
+function addEvents(element, events) {
+	const { onFullScreen, onError } = events;
+	prefixes.forEach((prefix) => {
+		element.addEventListener(`${prefix}fullscreenchange`, onFullScreen);
+		element.addEventListener(`${prefix}fullscreenerror`, onError);
+	});
+	return () => removeEvents(element, events);
+}
+function removeEvents(element, { onFullScreen, onError }) {
+	prefixes.forEach((prefix) => {
+		element.removeEventListener(`${prefix}fullscreenchange`, onFullScreen);
+		element.removeEventListener(`${prefix}fullscreenerror`, onError);
+	});
+}
+function useFullscreenElement() {
+	const fullscreen = ref(false);
+	const elementRef = ref(null);
+	let removeEventsFn;
+	const handleFullscreenChange = () => {
+		fullscreen.value = elementRef.value === getFullscreenElement();
+	};
+	const handleFullscreenError = () => {
+		fullscreen.value = false;
+	};
+	const toggle = async () => {
+		if (!getFullscreenElement() && elementRef.value) await enterFullScreen(elementRef.value);
+		else await exitFullscreen();
+	};
+	watch(elementRef, (node) => {
+		removeEventsFn?.();
+		removeEventsFn = void 0;
+		if (node) removeEventsFn = addEvents(node, {
+			onFullScreen: handleFullscreenChange,
+			onError: handleFullscreenError
+		});
+	}, { immediate: true });
+	onBeforeUnmount(() => removeEventsFn?.());
+	return {
+		ref: elementRef,
+		toggle,
+		fullscreen
+	};
+}
+function useFullscreenDocument() {
+	const fullscreen = ref(false);
+	let removeEventsFn;
+	const handleFullscreenChange = () => {
+		fullscreen.value = getFullscreenElement() === window.document.documentElement;
+	};
+	const handleFullscreenError = () => {
+		fullscreen.value = false;
+	};
+	const toggle = async () => {
+		if (!getFullscreenElement()) await enterFullScreen(window.document.documentElement);
+		else await exitFullscreen();
+	};
+	onMounted(() => {
+		removeEventsFn = addEvents(window.document.documentElement, {
+			onFullScreen: handleFullscreenChange,
+			onError: handleFullscreenError
+		});
+	});
+	onBeforeUnmount(() => removeEventsFn?.());
+	return {
+		toggle,
+		fullscreen
+	};
+}
+//#endregion
+//#region src/use-logger/use-logger.ts
+function useLogger(componentName, props) {
+	onMounted(() => {
+		console.log(`${componentName} mounted`, ...props.map((prop) => toValue(prop)));
+	});
+	onBeforeUnmount(() => {
+		console.log(`${componentName} unmounted`);
+	});
+	useDidUpdate(() => {
+		console.log(`${componentName} updated`, ...props.map((prop) => toValue(prop)));
+	}, props);
+	return null;
+}
+//#endregion
+//#region src/use-hover/use-hover.ts
+function useHover() {
+	const refTarget = ref(null);
+	const hovered = ref(false);
+	let cleanup;
+	onMounted(() => {
+		const node = refTarget.value;
+		if (!node) return;
+		const onEnter = () => hovered.value = true;
+		const onLeave = () => hovered.value = false;
+		node.addEventListener("mouseenter", onEnter);
+		node.addEventListener("mouseleave", onLeave);
+		cleanup = () => {
+			node.removeEventListener("mouseenter", onEnter);
+			node.removeEventListener("mouseleave", onLeave);
+		};
+	});
+	onBeforeUnmount(() => cleanup?.());
+	return {
+		ref: refTarget,
+		hovered
+	};
+}
+//#endregion
+//#region src/use-validated-state/use-validated-state.ts
+function useValidatedState(initialValue, validate, initialValidationState) {
+	const state = ref({
+		value: initialValue,
+		lastValidValue: validate(initialValue) ? initialValue : void 0,
+		valid: typeof initialValidationState === "boolean" ? initialValidationState : validate(initialValue)
+	});
+	const onChange = (val) => {
+		const isValid = validate(val);
+		state.value = {
+			value: val,
+			lastValidValue: isValid ? val : state.value.lastValidValue,
+			valid: isValid
+		};
+	};
+	return [readonly(state), onChange];
+}
+//#endregion
+//#region src/use-os/use-os.ts
+function isMacOS(userAgent) {
+	return /(Macintosh)|(MacIntel)|(MacPPC)|(Mac68K)/i.test(userAgent);
+}
+function isIOS(userAgent) {
+	return /(iPhone)|(iPad)|(iPod)/i.test(userAgent);
+}
+function isWindows(userAgent) {
+	return /(Win32)|(Win64)|(Windows)|(WinCE)/i.test(userAgent);
+}
+function isAndroid(userAgent) {
+	return /Android/i.test(userAgent);
+}
+function isLinux(userAgent) {
+	return /Linux/i.test(userAgent);
+}
+function isChromeOS(userAgent) {
+	return /CrOS/i.test(userAgent);
+}
+function getOS() {
+	if (typeof window === "undefined") return "undetermined";
+	const { userAgent } = window.navigator;
+	if (isIOS(userAgent) || isMacOS(userAgent) && "ontouchend" in document) return "ios";
+	if (isMacOS(userAgent)) return "macos";
+	if (isWindows(userAgent)) return "windows";
+	if (isAndroid(userAgent)) return "android";
+	if (isChromeOS(userAgent)) return "chromeos";
+	if (isLinux(userAgent)) return "linux";
+	return "undetermined";
+}
+function useOs(options = { getValueInEffect: true }) {
+	const value = ref(options.getValueInEffect ? "undetermined" : getOS());
+	useIsomorphicEffect(() => {
+		if (options.getValueInEffect) value.value = getOS();
+	});
+	return readonly(value);
+}
+//#endregion
+//#region src/use-set-state/use-set-state.ts
+function useSetState(initialState) {
+	const state = ref(initialState);
+	const setState = (statePartial) => {
+		state.value = {
+			...state.value,
+			...typeof statePartial === "function" ? statePartial(state.value) : statePartial
+		};
+	};
+	return [state, setState];
+}
+//#endregion
+//#region src/use-input-state/use-input-state.ts
+function useInputState(initialValue) {
+	const value = ref(initialValue);
+	const setValue = (eventOrValue) => {
+		if (eventOrValue instanceof Function) {
+			value.value = eventOrValue(value.value);
+			return;
+		}
+		if (eventOrValue instanceof Event || eventOrValue && typeof eventOrValue === "object" && "currentTarget" in eventOrValue && "nativeEvent" in eventOrValue) {
+			const target = eventOrValue.target ?? eventOrValue.currentTarget;
+			value.value = target.type === "checkbox" ? target.checked : target.value;
+		} else value.value = eventOrValue;
+	};
+	return [value, setValue];
+}
+//#endregion
+//#region src/use-event-listener/use-event-listener.ts
+function useEventListener(type, listener, options) {
+	const elementRef = ref(null);
+	let cleanup;
+	watch(elementRef, (node) => {
+		cleanup?.();
+		cleanup = void 0;
+		if (!node) return;
+		node.addEventListener(type, listener, options);
+		cleanup = () => node.removeEventListener(type, listener, options);
+	}, { immediate: true });
+	onBeforeUnmount(() => cleanup?.());
+	return elementRef;
+}
+//#endregion
+//#region src/use-disclosure/use-disclosure.ts
+function useDisclosure(initialState = false, options = {}) {
+	const opened = ref(initialState);
+	const set = (value) => {
+		if (value && !opened.value) options.onOpen?.();
+		if (!value && opened.value) options.onClose?.();
+		opened.value = value;
+	};
+	return [opened, {
+		set,
+		open: () => set(true),
+		close: () => set(false),
+		toggle: () => set(!opened.value)
+	}];
+}
+//#endregion
+//#region src/use-focus-within/use-focus-within.ts
+function useFocusWithin(options = {}) {
+	const refTarget = ref(null);
+	const focused = ref(false);
+	let cleanup;
+	onMounted(() => {
+		const node = refTarget.value;
+		if (!node) return;
+		const onFocusIn = (event) => {
+			focused.value = true;
+			options.onFocus?.(event);
+		};
+		const onFocusOut = (event) => nextTick(() => {
+			const isFocused = node.matches(":focus-within");
+			if (!isFocused && focused.value) options.onBlur?.(event);
+			focused.value = isFocused;
+		});
+		node.addEventListener("focusin", onFocusIn);
+		node.addEventListener("focusout", onFocusOut);
+		cleanup = () => {
+			node.removeEventListener("focusin", onFocusIn);
+			node.removeEventListener("focusout", onFocusOut);
+		};
+	});
+	onBeforeUnmount(() => cleanup?.());
+	return {
+		ref: refTarget,
+		focused
+	};
+}
+//#endregion
+//#region src/use-network/use-network.ts
+function getConnection() {
+	if (typeof navigator === "undefined") return {};
+	const nav = navigator;
+	const connection = nav.connection || nav.mozConnection || nav.webkitConnection;
+	if (!connection) return {};
+	return {
+		downlink: connection.downlink,
+		downlinkMax: connection.downlinkMax,
+		effectiveType: connection.effectiveType,
+		rtt: connection.rtt,
+		saveData: connection.saveData,
+		type: connection.type
+	};
+}
+function useNetwork() {
+	const status = ref({ online: true });
+	const handleConnectionChange = () => {
+		status.value = {
+			...status.value,
+			...getConnection()
+		};
+	};
+	useWindowEvent("online", () => {
+		status.value = {
+			online: true,
+			...getConnection()
+		};
+	});
+	useWindowEvent("offline", () => {
+		status.value = {
+			online: false,
+			...getConnection()
+		};
+	});
+	onMounted(() => {
+		const nav = navigator;
+		if (nav.connection) {
+			status.value = {
+				online: nav.onLine,
+				...getConnection()
+			};
+			nav.connection.addEventListener("change", handleConnectionChange);
+			return;
+		}
+		if (typeof nav.onLine === "boolean") status.value = {
+			...status.value,
+			online: nav.onLine
+		};
+	});
+	onBeforeUnmount(() => {
+		navigator.connection?.removeEventListener("change", handleConnectionChange);
+	});
+	return status;
+}
+//#endregion
+//#region src/use-timeout/use-timeout.ts
+function useTimeout(callback, delay, options = { autoInvoke: false }) {
+	let timeout;
+	const start = (...callbackParams) => {
+		clear();
+		timeout = setTimeout(() => callback(...callbackParams), delay);
+	};
+	const clear = () => {
+		if (timeout) {
+			clearTimeout(timeout);
+			timeout = void 0;
+		}
+	};
+	if (options.autoInvoke) start();
+	onBeforeUnmount(clear);
+	return {
+		start,
+		clear
+	};
+}
+//#endregion
+//#region src/use-text-selection/use-text-selection.ts
+function useTextSelection() {
+	const selection = shallowRef(null);
+	const handleSelectionChange = () => {
+		selection.value = document.getSelection();
+		triggerRef(selection);
+	};
+	onMounted(() => {
+		selection.value = document.getSelection();
+		triggerRef(selection);
+		document.addEventListener("selectionchange", handleSelectionChange);
+	});
+	onBeforeUnmount(() => {
+		document.removeEventListener("selectionchange", handleSelectionChange);
+	});
+	return selection;
+}
+//#endregion
+//#region src/use-previous/use-previous.ts
+function usePrevious(value) {
+	const previous = shallowRef();
+	watch(() => toValue(value), (_, oldValue) => {
+		previous.value = oldValue;
+	});
+	return previous;
+}
+//#endregion
+//#region src/use-favicon/use-favicon.ts
+var MIME_TYPES = {
+	ico: "image/x-icon",
+	png: "image/png",
+	svg: "image/svg+xml",
+	gif: "image/gif"
+};
+function useFavicon(url) {
+	let link = null;
+	useIsomorphicEffect(() => {
+		watch(() => toValue(url), (value) => {
+			if (!value) return;
+			if (!link) {
+				document.querySelectorAll("link[rel*=\"icon\"]").forEach((element) => document.head.removeChild(element));
+				const element = document.createElement("link");
+				element.rel = "shortcut icon";
+				link = element;
+				document.querySelector("head").appendChild(element);
+			}
+			const splittedUrl = value.split(".");
+			const mimeType = MIME_TYPES[splittedUrl[splittedUrl.length - 1].toLowerCase()];
+			if (mimeType) link.setAttribute("type", mimeType);
+			else link.removeAttribute("type");
+			link.setAttribute("href", value);
+		}, { immediate: true });
+	});
+}
+//#endregion
+//#region src/use-scroll-direction/use-scroll-direction.ts
+function useScrollDirection() {
+	const scrollDirection = ref("unknown");
+	let lastScrollTop = 0;
+	let isResizing = false;
+	let resizeTimer;
+	const handleScroll = () => {
+		if (isResizing) return;
+		const currentScrollTop = window.scrollY || document.documentElement.scrollTop;
+		scrollDirection.value = currentScrollTop < lastScrollTop ? "up" : "down";
+		lastScrollTop = currentScrollTop;
+	};
+	const handleResize = () => {
+		isResizing = true;
+		window.clearTimeout(resizeTimer);
+		resizeTimer = window.setTimeout(() => {
+			isResizing = false;
+		}, 300);
+	};
+	useWindowEvent("scroll", handleScroll);
+	useWindowEvent("resize", handleResize);
+	onBeforeUnmount(() => window.clearTimeout(resizeTimer));
+	return readonly(scrollDirection);
+}
+//#endregion
+//#region src/use-headroom/use-headroom.ts
+var isFixed = (current, fixedAt) => current <= fixedAt;
+var isPinned = (current, previous) => current <= previous;
+var isReleased = (current, previous, fixedAt) => !isPinned(current, previous) && !isFixed(current, fixedAt);
+var isPinnedOrReleased = (current, fixedAt, isCurrentlyPinnedRef, isScrollingUp, onPin, onRelease) => {
+	const isInFixedPosition = isFixed(current, fixedAt);
+	if (isInFixedPosition && !isCurrentlyPinnedRef.value) {
+		isCurrentlyPinnedRef.value = true;
+		onPin?.();
+	} else if (!isInFixedPosition && isScrollingUp && !isCurrentlyPinnedRef.value) {
+		isCurrentlyPinnedRef.value = true;
+		onPin?.();
+	} else if (!isInFixedPosition && !isScrollingUp && isCurrentlyPinnedRef.value) {
+		isCurrentlyPinnedRef.value = false;
+		onRelease?.();
+	}
+};
+function useHeadroom({ fixedAt = 0, scrollDistance = 100, onPin, onFix, onRelease } = {}) {
+	const scrollDirection = useScrollDirection();
+	const scrollY = ref(typeof window === "undefined" ? 0 : window.scrollY || document.documentElement.scrollTop);
+	useWindowEvent("scroll", () => {
+		scrollY.value = window.scrollY || document.documentElement.scrollTop;
+	});
+	const pinned = ref(false);
+	const scrollProgress = ref(0);
+	const isCurrentlyPinned = { value: false };
+	let wasFixed = isFixed(scrollY.value, fixedAt);
+	let prevIsFixed = wasFixed;
+	let directionChangeScrollY = scrollY.value;
+	let progressAtDirectionChange = wasFixed ? 1 : 0;
+	let prevIsScrollingUp = scrollDirection.value === "up";
+	const recalc = () => {
+		const current = scrollY.value;
+		const isScrollingUp = scrollDirection.value === "up";
+		isPinnedOrReleased(current, fixedAt, isCurrentlyPinned, isScrollingUp, onPin, onRelease);
+		const currentlyFixed = isFixed(current, fixedAt);
+		if (currentlyFixed && !wasFixed) onFix?.();
+		wasFixed = currentlyFixed;
+		if (prevIsFixed !== currentlyFixed) {
+			prevIsFixed = currentlyFixed;
+			directionChangeScrollY = currentlyFixed ? current : fixedAt;
+			progressAtDirectionChange = 1;
+			prevIsScrollingUp = isScrollingUp;
+		}
+		if (!currentlyFixed && prevIsScrollingUp !== isScrollingUp) {
+			const transitionDelta = Math.abs(current - directionChangeScrollY);
+			const transitionProgress = prevIsScrollingUp ? Math.min(progressAtDirectionChange + transitionDelta / scrollDistance, 1) : Math.max(progressAtDirectionChange - transitionDelta / scrollDistance, 0);
+			prevIsScrollingUp = isScrollingUp;
+			directionChangeScrollY = current;
+			progressAtDirectionChange = transitionProgress;
+		}
+		let nextScrollProgress;
+		if (currentlyFixed) nextScrollProgress = 1;
+		else {
+			const scrollDelta = Math.abs(current - directionChangeScrollY);
+			nextScrollProgress = isScrollingUp ? Math.min(progressAtDirectionChange + scrollDelta / scrollDistance, 1) : Math.max(progressAtDirectionChange - scrollDelta / scrollDistance, 0);
+		}
+		scrollProgress.value = nextScrollProgress;
+		pinned.value = nextScrollProgress > 0;
+	};
+	watch([scrollY, scrollDirection], recalc, { immediate: true });
+	return {
+		pinned,
+		scrollProgress
+	};
+}
+//#endregion
+//#region src/use-eye-dropper/use-eye-dropper.ts
+function isOpera() {
+	return navigator.userAgent.includes("OPR");
+}
+function useEyeDropper() {
+	const supported = ref(false);
+	useIsomorphicEffect(() => {
+		supported.value = typeof window !== "undefined" && !isOpera() && "EyeDropper" in window;
+	});
+	const open = (options = {}) => {
+		if (supported.value) return new window.EyeDropper().open(options);
+		return Promise.resolve(void 0);
+	};
+	return {
+		supported,
+		open
+	};
+}
+//#endregion
+//#region src/use-in-viewport/use-in-viewport.ts
+function useInViewport() {
+	const elementRef = ref(null);
+	const inViewport = ref(false);
+	let observer;
+	watch(elementRef, (node) => {
+		if (typeof IntersectionObserver === "undefined") return;
+		observer?.disconnect();
+		const target = node instanceof Element ? node : null;
+		if (target) {
+			observer = new IntersectionObserver((entries) => {
+				inViewport.value = entries[entries.length - 1].isIntersecting;
+			});
+			observer.observe(target);
+		} else {
+			observer = void 0;
+			inViewport.value = false;
+		}
+	}, { immediate: true });
+	onBeforeUnmount(() => observer?.disconnect());
+	return {
+		ref: elementRef,
+		inViewport
+	};
+}
+//#endregion
+//#region src/use-mutation-observer/use-mutation-observer.ts
+function useMutationObserver(callback, options) {
+	const elementRef = ref(null);
+	let observer;
+	watch(elementRef, (node) => {
+		observer?.disconnect();
+		observer = void 0;
+		if (node instanceof Element) {
+			observer = new MutationObserver(callback);
+			observer.observe(node, options);
+		}
+	}, { immediate: true });
+	onBeforeUnmount(() => observer?.disconnect());
+	return elementRef;
+}
+function useMutationObserverTarget(callback, options, target) {
+	let observer;
+	const connect = () => {
+		observer?.disconnect();
+		observer = void 0;
+		const targetElement = toValue(target);
+		if (targetElement instanceof Element) {
+			observer = new MutationObserver(callback);
+			observer.observe(targetElement, options);
+		}
+	};
+	onMounted(connect);
+	watch(() => toValue(target), connect);
+	onBeforeUnmount(() => observer?.disconnect());
+}
+//#endregion
+//#region src/use-mounted/use-mounted.ts
+function useMounted() {
+	const mounted = ref(false);
+	onMounted(() => {
+		mounted.value = true;
+	});
+	return readonly(mounted);
+}
+//#endregion
+//#region src/use-state-history/use-state-history.ts
+function useStateHistory(initialValue) {
+	const historyState = ref({
+		history: [initialValue],
+		current: 0
+	});
+	const set = (val) => {
+		const nextHistory = [...historyState.value.history.slice(0, historyState.value.current + 1), val];
+		historyState.value = {
+			history: nextHistory,
+			current: nextHistory.length - 1
+		};
+	};
+	const back = (steps = 1) => {
+		historyState.value = {
+			history: historyState.value.history,
+			current: Math.max(0, historyState.value.current - steps)
+		};
+	};
+	const forward = (steps = 1) => {
+		historyState.value = {
+			history: historyState.value.history,
+			current: Math.min(historyState.value.history.length - 1, historyState.value.current + steps)
+		};
+	};
+	const reset = () => {
+		historyState.value = {
+			history: [initialValue],
+			current: 0
+		};
+	};
+	const handlers = {
+		back,
+		forward,
+		reset,
+		set
+	};
+	return [
+		computed(() => historyState.value.history[historyState.value.current]),
+		handlers,
+		readonly(historyState)
+	];
+}
+//#endregion
+//#region src/use-map/use-map.ts
+function useMap(initialState) {
+	return reactive(new Map(initialState));
+}
+//#endregion
+//#region src/use-set/use-set.ts
+function readonlySetLikeToSet(input) {
+	if (input instanceof Set) return input;
+	const result = /* @__PURE__ */ new Set();
+	const iterator = input.keys();
+	let next = iterator.next();
+	while (!next.done) {
+		result.add(next.value);
+		next = iterator.next();
+	}
+	return result;
+}
+function useSet(values) {
+	const rawSet = new Set(values);
+	rawSet.union = (other) => {
+		const result = new Set(rawSet);
+		readonlySetLikeToSet(other).forEach((item) => result.add(item));
+		return result;
+	};
+	rawSet.intersection = (other) => {
+		const result = /* @__PURE__ */ new Set();
+		const otherSet = readonlySetLikeToSet(other);
+		rawSet.forEach((item) => {
+			if (otherSet.has(item)) result.add(item);
+		});
+		return result;
+	};
+	rawSet.difference = (other) => {
+		const result = /* @__PURE__ */ new Set();
+		const otherSet = readonlySetLikeToSet(other);
+		rawSet.forEach((item) => {
+			if (!otherSet.has(item)) result.add(item);
+		});
+		return result;
+	};
+	rawSet.symmetricDifference = (other) => {
+		const result = /* @__PURE__ */ new Set();
+		const otherSet = readonlySetLikeToSet(other);
+		rawSet.forEach((item) => {
+			if (!otherSet.has(item)) result.add(item);
+		});
+		otherSet.forEach((item) => {
+			if (!rawSet.has(item)) result.add(item);
+		});
+		return result;
+	};
+	return reactive(rawSet);
+}
+//#endregion
+//#region src/use-throttled-callback/use-throttled-callback.ts
+function useThrottledCallbackWithClearTimeout(callback, wait) {
+	let latestInArgs = null;
+	let latestOutArgs = null;
+	let active = true;
+	let timeoutId = -1;
+	const clear = () => window.clearTimeout(timeoutId);
+	const callThrottledCallback = (...args) => {
+		callback(...args);
+		latestInArgs = args;
+		latestOutArgs = args;
+		active = false;
+	};
+	const timerCallback = () => {
+		if (latestInArgs && latestInArgs !== latestOutArgs) {
+			callThrottledCallback(...latestInArgs);
+			timeoutId = window.setTimeout(timerCallback, wait);
+		} else active = true;
+	};
+	const throttled = (...args) => {
+		if (active) {
+			callThrottledCallback(...args);
+			timeoutId = window.setTimeout(timerCallback, wait);
+		} else latestInArgs = args;
+	};
+	return [throttled, clear];
+}
+function useThrottledCallback(callback, wait) {
+	const [throttled, clear] = useThrottledCallbackWithClearTimeout(callback, wait);
+	onBeforeUnmount(clear);
+	return throttled;
+}
+//#endregion
+//#region src/use-throttled-state/use-throttled-state.ts
+function useThrottledState(defaultValue, wait) {
+	const value = ref(defaultValue);
+	const [setThrottledValue, clear] = useThrottledCallbackWithClearTimeout((nextValue) => {
+		value.value = nextValue;
+	}, wait);
+	onBeforeUnmount(clear);
+	return [value, setThrottledValue];
+}
+//#endregion
+//#region src/use-throttled-value/use-throttled-value.ts
+function useThrottledValue(value, wait) {
+	const throttledValue = ref(toValue(value));
+	const [throttledSetValue, clear] = useThrottledCallbackWithClearTimeout((nextValue) => {
+		throttledValue.value = nextValue;
+	}, wait);
+	watch(() => toValue(value), (nextValue) => throttledSetValue(nextValue));
+	onBeforeUnmount(clear);
+	return readonly(throttledValue);
+}
+//#endregion
+//#region src/use-is-first-render/use-is-first-render.ts
+function useIsFirstRender() {
+	const isFirst = ref(true);
+	onUpdated(() => {
+		isFirst.value = false;
+	});
+	return readonly(isFirst);
+}
+//#endregion
+//#region src/use-orientation/use-orientation.ts
+function getInitialValue(initialValue, getInitialValueInEffect) {
+	if (getInitialValueInEffect) return initialValue;
+	if (typeof window !== "undefined" && "screen" in window) return {
+		angle: window.screen.orientation?.angle ?? initialValue.angle,
+		type: window.screen.orientation?.type ?? initialValue.type
+	};
+	return initialValue;
+}
+function useOrientation(options = {}) {
+	const { defaultAngle = 0, defaultType = "landscape-primary", getInitialValueInEffect = true } = options;
+	const orientation = ref(getInitialValue({
+		angle: defaultAngle,
+		type: defaultType
+	}, getInitialValueInEffect));
+	const handleOrientationChange = (event) => {
+		const target = event.currentTarget;
+		orientation.value = {
+			angle: target?.angle || 0,
+			type: target?.type || "landscape-primary"
+		};
+	};
+	useIsomorphicEffect(() => {
+		if (window.screen.orientation) {
+			orientation.value = {
+				angle: window.screen.orientation.angle,
+				type: window.screen.orientation.type
+			};
+			window.screen.orientation.addEventListener("change", handleOrientationChange);
+		}
+	});
+	onBeforeUnmount(() => {
+		if (typeof window !== "undefined") window.screen.orientation?.removeEventListener("change", handleOrientationChange);
+	});
+	return orientation;
+}
+//#endregion
+//#region src/use-fetch/use-fetch.ts
+function useFetch(url, { autoInvoke = true, ...options } = {}) {
+	const data = ref(null);
+	const loading = ref(false);
+	const error = ref(null);
+	let controller = null;
+	const refetch = () => {
+		if (controller) controller.abort();
+		controller = new AbortController();
+		loading.value = true;
+		return fetch(toValue(url), {
+			...options,
+			signal: controller.signal
+		}).then((res) => {
+			if (!res.ok) throw new Error(`Request failed with status ${res.status}`);
+			return res.json();
+		}).then((res) => {
+			data.value = res;
+			loading.value = false;
+			return res;
+		}).catch((err) => {
+			loading.value = false;
+			if (err.name !== "AbortError") error.value = err;
+			return err;
+		});
+	};
+	const abort = () => {
+		if (controller) controller.abort("");
+	};
+	watch(() => toValue(url), () => {
+		if (autoInvoke) refetch();
+	}, { immediate: true });
+	onBeforeUnmount(() => {
+		if (controller) controller.abort("");
+	});
+	return {
+		data,
+		loading,
+		error,
+		refetch,
+		abort
+	};
+}
+//#endregion
+//#region src/use-radial-move/use-radial-move.ts
+function clamp$2(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
+function radiansToDegrees(radians) {
+	return radians * (180 / Math.PI);
+}
+function getElementCenter(element) {
+	const rect = element.getBoundingClientRect();
+	return [rect.left + rect.width / 2, rect.top + rect.height / 2];
+}
+function getAngle(coordinates, element) {
+	const center = getElementCenter(element);
+	const x = coordinates[0] - center[0];
+	const y = coordinates[1] - center[1];
+	return 360 - (radiansToDegrees(Math.atan2(x, y)) + 180);
+}
+function toFixed(value, digits) {
+	return Number.parseFloat(value.toFixed(digits));
+}
+function getDigitsAfterDot(value) {
+	return value.toString().split(".")[1]?.length || 0;
+}
+function normalizeRadialValue(degree, step) {
+	const clamped = clamp$2(degree, 0, 360);
+	const high = Math.ceil(clamped / step);
+	const low = Math.round(clamped / step);
+	return toFixed(high >= clamped / step ? high * step === 360 ? 0 : high * step : low * step, getDigitsAfterDot(step));
+}
+function useRadialMove(onChange, { step = .01, onChangeEnd, onScrubStart, onScrubEnd } = {}) {
+	const active = ref(false);
+	let nodeRef = null;
+	let cleanupNode;
+	const update = (event, done = false) => {
+		if (!nodeRef) return;
+		nodeRef.style.userSelect = "none";
+		const nextValue = normalizeRadialValue(getAngle([event.clientX, event.clientY], nodeRef), step || 1);
+		onChange(nextValue);
+		if (done) onChangeEnd?.(nextValue);
+	};
+	const handleMouseMove = (event) => update(event);
+	const handleMouseUp = (event) => {
+		update(event, true);
+		endTracking();
+	};
+	const handleTouchMove = (event) => {
+		event.preventDefault();
+		update(event.touches[0]);
+	};
+	const handleTouchEnd = (event) => {
+		update(event.changedTouches[0], true);
+		endTracking();
+	};
+	function beginTracking() {
+		onScrubStart?.();
+		active.value = true;
+		document.addEventListener("mousemove", handleMouseMove, false);
+		document.addEventListener("mouseup", handleMouseUp, false);
+		document.addEventListener("touchmove", handleTouchMove, { passive: false });
+		document.addEventListener("touchend", handleTouchEnd, false);
+	}
+	function endTracking() {
+		onScrubEnd?.();
+		active.value = false;
+		document.removeEventListener("mousemove", handleMouseMove, false);
+		document.removeEventListener("mouseup", handleMouseUp, false);
+		document.removeEventListener("touchmove", handleTouchMove, false);
+		document.removeEventListener("touchend", handleTouchEnd, false);
+	}
+	const handleMouseDown = (event) => {
+		beginTracking();
+		update(event);
+	};
+	const handleTouchStart = (event) => {
+		event.preventDefault();
+		beginTracking();
+		update(event.touches[0]);
+	};
+	const setRef = (node) => {
+		cleanupNode?.();
+		nodeRef = node;
+		if (!node) {
+			cleanupNode = void 0;
+			return;
+		}
+		node.addEventListener("mousedown", handleMouseDown);
+		node.addEventListener("touchstart", handleTouchStart, { passive: false });
+		cleanupNode = () => {
+			node.removeEventListener("mousedown", handleMouseDown);
+			node.removeEventListener("touchstart", handleTouchStart);
+		};
+	};
+	onBeforeUnmount(() => {
+		cleanupNode?.();
+		endTracking();
+	});
+	return {
+		ref: setRef,
+		active
+	};
+}
+//#endregion
+//#region src/use-scroll-spy/use-scroll-spy.ts
+var scrollSpyId = 0;
+function getActiveElement(rects, offset = 0) {
+	if (rects.length === 0) return -1;
+	return rects.reduce((closest, rect, index) => Math.abs(closest.position - offset) < Math.abs(rect.y - offset) ? closest : {
+		index,
+		position: rect.y
+	}, {
+		index: 0,
+		position: rects[0].y
+	}).index;
+}
+function useScrollSpy(options = {}) {
+	const active = ref(-1);
+	const initialized = ref(false);
+	const data = ref([]);
+	let host;
+	const updateActive = () => {
+		active.value = getActiveElement(data.value.map((item) => item.getNode()?.getBoundingClientRect()).filter(Boolean), toValue(options.offset) ?? 0);
+	};
+	const reinitialize = () => {
+		if (typeof document === "undefined") return;
+		const getDepth = options.getDepth ?? ((element) => Number(element.tagName[1]));
+		const getValue = options.getValue ?? ((element) => element.textContent || "");
+		data.value = Array.from(document.querySelectorAll(toValue(options.selector) ?? "h1, h2, h3, h4, h5, h6")).map((heading) => ({
+			depth: getDepth(heading),
+			value: getValue(heading),
+			id: heading.id || `mantine-scroll-spy-${++scrollSpyId}`,
+			getNode: () => heading.id ? document.getElementById(heading.id) ?? heading : heading
+		}));
+		initialized.value = true;
+		updateActive();
+	};
+	const bind = () => {
+		host?.removeEventListener("scroll", updateActive);
+		host = toValue(options.scrollHost) ?? (typeof window !== "undefined" ? window : void 0);
+		host?.addEventListener("scroll", updateActive, { passive: true });
+	};
+	onMounted(() => {
+		reinitialize();
+		bind();
+	});
+	onBeforeUnmount(() => host?.removeEventListener("scroll", updateActive));
+	watch(() => [
+		toValue(options.selector),
+		toValue(options.offset),
+		toValue(options.scrollHost)
+	], () => {
+		reinitialize();
+		bind();
+	});
+	return {
+		active: readonly(active),
+		initialized: readonly(initialized),
+		data: readonly(data),
+		reinitialize
+	};
+}
+//#endregion
+//#region src/use-scroller/use-scroller.ts
+function useScroller({ scrollAmount = 200, draggable = true, onScrollStateChange } = {}) {
+	let containerRef = null;
+	let resizeObserver;
+	let isDraggingRef = false;
+	let hasDraggedRef = false;
+	let startX = 0;
+	let scrollLeftStart = 0;
+	const canScrollStart = ref(false);
+	const canScrollEnd = ref(false);
+	const isDragging = ref(false);
+	const updateScrollState = () => {
+		const container = containerRef;
+		if (!container) return;
+		const { scrollLeft, scrollWidth, clientWidth } = container;
+		const isRtl = getComputedStyle(container).direction === "rtl";
+		const nextCanScrollStart = isRtl ? scrollLeft < -1 : scrollLeft > 1;
+		const nextCanScrollEnd = isRtl ? scrollLeft > -(scrollWidth - clientWidth) + 1 : scrollLeft < scrollWidth - clientWidth - 1;
+		canScrollStart.value = nextCanScrollStart;
+		canScrollEnd.value = nextCanScrollEnd;
+		onScrollStateChange?.({
+			canScrollStart: nextCanScrollStart,
+			canScrollEnd: nextCanScrollEnd
+		});
+	};
+	const setRef = (node) => {
+		const safeNode = node instanceof HTMLElement ? node : null;
+		if (containerRef) {
+			containerRef.removeEventListener("scroll", updateScrollState);
+			resizeObserver?.disconnect();
+		}
+		containerRef = safeNode;
+		if (safeNode) {
+			safeNode.addEventListener("scroll", updateScrollState);
+			if (typeof ResizeObserver !== "undefined") {
+				resizeObserver = new ResizeObserver(updateScrollState);
+				resizeObserver.observe(safeNode);
+			}
+			updateScrollState();
+		}
+	};
+	const scroll = (direction) => {
+		if (!containerRef) return;
+		const isRtl = getComputedStyle(containerRef).direction === "rtl";
+		const scrollBy = direction === "end" ? scrollAmount : -scrollAmount;
+		const adjustedScrollBy = isRtl ? -scrollBy : scrollBy;
+		containerRef.scrollBy({
+			left: adjustedScrollBy,
+			behavior: "smooth"
+		});
+	};
+	const handleMouseDown = (event) => {
+		if (!draggable || !containerRef) return;
+		isDraggingRef = true;
+		hasDraggedRef = false;
+		isDragging.value = true;
+		startX = event.pageX - containerRef.offsetLeft;
+		scrollLeftStart = containerRef.scrollLeft;
+		containerRef.style.cursor = "grabbing";
+		containerRef.style.userSelect = "none";
+	};
+	const handleMouseMove = (event) => {
+		if (!isDraggingRef || !containerRef) return;
+		event.preventDefault();
+		const walk = event.pageX - containerRef.offsetLeft - startX;
+		if (Math.abs(walk) > 5) hasDraggedRef = true;
+		containerRef.scrollLeft = scrollLeftStart - walk;
+	};
+	const handleMouseUp = () => {
+		const wasDragged = hasDraggedRef;
+		isDraggingRef = false;
+		hasDraggedRef = false;
+		isDragging.value = false;
+		if (!containerRef) return;
+		containerRef.style.cursor = "";
+		containerRef.style.userSelect = "";
+		if (wasDragged) {
+			const suppressClick = (event) => {
+				event.stopPropagation();
+				event.preventDefault();
+				containerRef?.removeEventListener("click", suppressClick, true);
+			};
+			containerRef.addEventListener("click", suppressClick, true);
+		}
+	};
+	onBeforeUnmount(() => {
+		if (containerRef) containerRef.removeEventListener("scroll", updateScrollState);
+		resizeObserver?.disconnect();
+	});
+	return {
+		ref: setRef,
+		canScrollStart,
+		canScrollEnd,
+		scrollStart: () => scroll("start"),
+		scrollEnd: () => scroll("end"),
+		isDragging,
+		dragHandlers: {
+			onMousedown: handleMouseDown,
+			onMousemove: handleMouseMove,
+			onMouseup: handleMouseUp,
+			onMouseleave: () => {
+				if (isDraggingRef) handleMouseUp();
+			}
+		}
+	};
+}
+//#endregion
+//#region src/use-file-dialog/use-file-dialog.ts
+var defaultOptions = {
+	multiple: true,
+	accept: "*"
+};
+function getInitialFilesList(files) {
+	if (!files) return null;
+	if (files instanceof FileList) return files;
+	const result = new DataTransfer();
+	for (const file of files) result.items.add(file);
+	return result.files;
+}
+function createInput(options) {
+	if (typeof document === "undefined") return null;
+	const input = document.createElement("input");
+	input.type = "file";
+	if (options.accept) input.accept = options.accept;
+	if (options.multiple) input.multiple = options.multiple;
+	if (options.capture) input.capture = options.capture;
+	if (options.directory) input.webkitdirectory = options.directory;
+	input.style.display = "none";
+	return input;
+}
+function useFileDialog(input = {}) {
+	const options = {
+		...defaultOptions,
+		...input
+	};
+	const files = ref(getInitialFilesList(options.initialFiles));
+	let inputElement = null;
+	const handleChange = (event) => {
+		const target = event.target;
+		if (target?.files) {
+			files.value = target.files;
+			options.onChange?.(target.files);
+		}
+	};
+	const createAndSetupInput = () => {
+		inputElement?.remove();
+		inputElement = createInput(options);
+		if (inputElement) {
+			inputElement.addEventListener("change", handleChange, { once: true });
+			if (options.onCancel) inputElement.addEventListener("cancel", options.onCancel, { once: true });
+			document.body.appendChild(inputElement);
+		}
+	};
+	useIsomorphicEffect(() => {
+		createAndSetupInput();
+	});
+	onBeforeUnmount(() => inputElement?.remove());
+	const reset = () => {
+		files.value = null;
+		options.onChange?.(null);
+	};
+	const open = () => {
+		if (options.resetOnOpen) reset();
+		createAndSetupInput();
+		inputElement?.click();
+	};
+	return {
+		files,
+		open,
+		reset
+	};
+}
+//#endregion
+//#region src/use-long-press/use-long-press.ts
+var getPosition = (event) => {
+	if ("touches" in event) {
+		const touch = event.touches[0] ?? event.changedTouches[0];
+		return touch ? {
+			x: touch.clientX,
+			y: touch.clientY
+		} : null;
+	}
+	return {
+		x: event.clientX,
+		y: event.clientY
+	};
+};
+function useLongPress(onLongPress, options = {}) {
+	const events = options.events ?? ["mouse", "touch"];
+	const threshold = options.threshold ?? 400;
+	const moveThreshold = options.cancelOnMove === true ? 10 : typeof options.cancelOnMove === "number" ? options.cancelOnMove : 0;
+	let timeout;
+	let active = false;
+	let pressed = false;
+	let startPosition = null;
+	const clear = () => {
+		clearTimeout(timeout);
+		timeout = void 0;
+	};
+	const start = (event) => {
+		options.onStart?.(event);
+		startPosition = getPosition(event);
+		pressed = true;
+		clear();
+		timeout = setTimeout(() => {
+			onLongPress(event);
+			active = true;
+		}, threshold);
+	};
+	const cancel = (event) => {
+		if (active) options.onFinish?.(event);
+		else if (pressed) options.onCancel?.(event);
+		active = false;
+		pressed = false;
+		startPosition = null;
+		clear();
+	};
+	const move = (event) => {
+		if (!options.cancelOnMove || !pressed || active || !startPosition) return;
+		const current = getPosition(event);
+		if (!current) return;
+		if (Math.hypot(current.x - startPosition.x, current.y - startPosition.y) > moveThreshold) cancel(event);
+	};
+	onBeforeUnmount(clear);
+	return {
+		...events.includes("mouse") ? {
+			onMousedown: start,
+			onMouseup: cancel,
+			onMouseleave: cancel,
+			...options.cancelOnMove ? { onMousemove: move } : {}
+		} : {},
+		...events.includes("touch") ? {
+			onTouchstart: start,
+			onTouchend: cancel,
+			onTouchcancel: cancel,
+			...options.cancelOnMove ? { onTouchmove: move } : {}
+		} : {}
+	};
+}
+//#endregion
+//#region src/use-selection/use-selection.ts
+function useSelection(input) {
+	const selectionSet = ref(new Set(input.defaultSelection || []));
+	useDidUpdate(() => {
+		if (toValue(input.resetSelectionOnDataChange)) selectionSet.value = /* @__PURE__ */ new Set();
+	}, [input.data, input.resetSelectionOnDataChange]);
+	const select = (selected) => {
+		if (!selectionSet.value.has(selected)) {
+			const newSet = new Set(selectionSet.value);
+			newSet.add(selected);
+			selectionSet.value = newSet;
+		}
+	};
+	const deselect = (deselected) => {
+		if (selectionSet.value.has(deselected)) {
+			const newSet = new Set(selectionSet.value);
+			newSet.delete(deselected);
+			selectionSet.value = newSet;
+		}
+	};
+	const toggle = (toggled) => {
+		const newSet = new Set(selectionSet.value);
+		if (newSet.has(toggled)) newSet.delete(toggled);
+		else newSet.add(toggled);
+		selectionSet.value = newSet;
+	};
+	const resetSelection = () => {
+		selectionSet.value = /* @__PURE__ */ new Set();
+	};
+	const setSelection = (selection) => {
+		selectionSet.value = new Set(selection);
+	};
+	const isAllSelected = () => {
+		const data = toValue(input.data);
+		if (data.length === 0) return false;
+		return data.every((item) => selectionSet.value.has(item));
+	};
+	const isSomeSelected = () => {
+		return toValue(input.data).some((item) => selectionSet.value.has(item));
+	};
+	return [computed(() => Array.from(selectionSet.value)), {
+		select,
+		deselect,
+		toggle,
+		isAllSelected,
+		isSomeSelected,
+		setSelection,
+		resetSelection
+	}];
+}
+//#endregion
+//#region src/use-floating-window/use-floating-window.ts
+function px(value) {
+	return value.endsWith("px") ? parseFloat(value) : 0;
+}
+function clampToViewport(x, y, element, offset = 0) {
+	const rect = element.getBoundingClientRect();
+	return {
+		x: Math.min(Math.max(offset, x), Math.max(offset, window.innerWidth - rect.width - offset)),
+		y: Math.min(Math.max(offset, y), Math.max(offset, window.innerHeight - rect.height - offset))
+	};
+}
+function constrain(element, position, options) {
+	return options.constrainToViewport ? clampToViewport(position.x, position.y, element, options.constrainOffset) : position;
+}
+function calculateInitialPosition(element, options) {
+	const rect = element.getBoundingClientRect();
+	const style = getComputedStyle(element);
+	const offset = options.constrainOffset ?? 0;
+	const initial = options.initialPosition ?? {};
+	return constrain(element, {
+		x: initial.left ?? (initial.right !== void 0 ? window.innerWidth - rect.width - initial.right : px(style.left) || window.innerWidth - rect.width - px(style.right) || offset),
+		y: initial.top ?? (initial.bottom !== void 0 ? window.innerHeight - rect.height - initial.bottom : px(style.top) || window.innerHeight - rect.height - px(style.bottom) || offset)
+	}, options);
+}
+function excluded(target, selector) {
+	return Boolean(selector && target instanceof Element && target.closest(selector));
+}
+function isHandle(element, target, options) {
+	if (!(target instanceof Node) || excluded(target, options.excludeDragHandleSelector)) return false;
+	if (!options.dragHandleSelector) return true;
+	return Array.from(element.querySelectorAll(options.dragHandleSelector)).some((item) => item.contains(target));
+}
+function useFloatingWindow(options = {}) {
+	const element = ref(null);
+	const isDragging = ref(false);
+	let position = {
+		x: 0,
+		y: 0
+	};
+	let pointerOffset = {
+		x: 0,
+		y: 0
+	};
+	let observer;
+	const applyPosition = (next, notify = true) => {
+		if (!element.value) return;
+		position = constrain(element.value, next, options);
+		element.value.style.left = `${position.x}px`;
+		element.value.style.top = `${position.y}px`;
+		element.value.style.right = "unset";
+		element.value.style.bottom = "unset";
+		if (notify) options.onPositionChange?.(position);
+	};
+	const setPosition = (next) => {
+		const node = element.value;
+		if (!node) return;
+		const rect = node.getBoundingClientRect();
+		applyPosition({
+			x: next.left ?? (next.right !== void 0 ? window.innerWidth - rect.width - next.right : position.x),
+			y: next.top ?? (next.bottom !== void 0 ? window.innerHeight - rect.height - next.bottom : position.y)
+		});
+	};
+	const end = () => {
+		if (!isDragging.value) return;
+		isDragging.value = false;
+		document.body.style.userSelect = "";
+		document.body.style.webkitUserSelect = "";
+		options.onDragEnd?.();
+		document.removeEventListener("mousemove", move);
+		document.removeEventListener("mouseup", end);
+		document.removeEventListener("touchmove", move);
+		document.removeEventListener("touchend", end);
+	};
+	const move = (event) => {
+		if (!isDragging.value || !element.value) return;
+		const point = "touches" in event ? event.touches[0] : event;
+		event.preventDefault();
+		const next = constrain(element.value, {
+			x: point.clientX - pointerOffset.x,
+			y: point.clientY - pointerOffset.y
+		}, options);
+		applyPosition({
+			x: options.axis === "y" ? position.x : next.x,
+			y: options.axis === "x" ? position.y : next.y
+		});
+	};
+	const start = (event) => {
+		const node = element.value;
+		if (!node || options.enabled === false || !isHandle(node, event.target, options)) return;
+		if ("button" in event && event.button !== 0) return;
+		const point = "touches" in event ? event.touches[0] : event;
+		const rect = node.getBoundingClientRect();
+		pointerOffset = {
+			x: point.clientX - rect.left,
+			y: point.clientY - rect.top
+		};
+		isDragging.value = true;
+		document.body.style.userSelect = "none";
+		document.body.style.webkitUserSelect = "none";
+		options.onDragStart?.();
+		document.addEventListener("mousemove", move);
+		document.addEventListener("mouseup", end);
+		document.addEventListener("touchmove", move, { passive: false });
+		document.addEventListener("touchend", end);
+	};
+	const setRef = (node) => {
+		const safeNode = node instanceof Element ? node : null;
+		if (safeNode === element.value) return;
+		if (element.value) {
+			element.value.removeEventListener("mousedown", start);
+			element.value.removeEventListener("touchstart", start);
+		}
+		observer?.disconnect();
+		observer = void 0;
+		element.value = safeNode;
+		if (safeNode) {
+			safeNode.addEventListener("mousedown", start);
+			safeNode.addEventListener("touchstart", start, { passive: false });
+			position = calculateInitialPosition(safeNode, options);
+			applyPosition(position, false);
+			if (typeof ResizeObserver !== "undefined") {
+				observer = new ResizeObserver(() => applyPosition(position, false));
+				observer.observe(safeNode);
+			}
+		}
+	};
+	onMounted(() => element.value && applyPosition(calculateInitialPosition(element.value, options), false));
+	onBeforeUnmount(() => {
+		end();
+		observer?.disconnect();
+		element.value?.removeEventListener("mousedown", start);
+		element.value?.removeEventListener("touchstart", start);
+	});
+	return {
+		ref: setRef,
+		element: readonly(element),
+		isDragging: readonly(isDragging),
+		setPosition
+	};
+}
+//#endregion
+//#region src/use-collapse/use-collapse.ts
+function getAutoSizeDuration(size) {
+	if (!size || typeof size === "string") return 0;
+	const constant = size / 36;
+	return Math.round((4 + 15 * constant ** .25 + constant / 5) * 10);
+}
+function getElementContentSize(element, dimension) {
+	if (!element) return "auto";
+	const size = dimension === "height" ? element.scrollHeight : element.scrollWidth;
+	if (size !== 0) return size;
+	const children = Array.from(element.children).filter((child) => child instanceof HTMLElement);
+	if (children.length === 0) return size;
+	const childrenScrollSize = children.reduce((acc, child) => acc + (dimension === "height" ? child.scrollHeight : child.scrollWidth), 0);
+	if (childrenScrollSize !== 0) return childrenScrollSize;
+	const rect = element.getBoundingClientRect();
+	const start = dimension === "height" ? rect.top : rect.left;
+	const endProperty = dimension === "height" ? "bottom" : "right";
+	const marginProperty = dimension === "height" ? "marginBottom" : "marginRight";
+	const view = element.ownerDocument.defaultView;
+	return Math.max(...children.map((child) => {
+		const childRect = child.getBoundingClientRect();
+		const childStyles = view?.getComputedStyle(child);
+		const margin = childStyles ? Number.parseFloat(childStyles[marginProperty]) || 0 : 0;
+		return childRect[endProperty] - start + margin;
+	}), 0);
+}
+function getCssSize(size) {
+	return typeof size === "number" ? `${size}px` : size;
+}
+function createCollapse({ dimension, getElementSize, expanded, transitionDuration, transitionTimingFunction = "ease", onTransitionEnd, onTransitionStart, keepMounted }) {
+	const isExpanded = () => toValue(expanded);
+	const collapsedStyles = {
+		[dimension]: 0,
+		overflow: "hidden",
+		...keepMounted ? {} : { display: "none" }
+	};
+	const elementRef = ref(null);
+	const styles = ref(isExpanded() ? {} : collapsedStyles);
+	const state = ref(isExpanded() ? "entered" : "exited");
+	const raf = typeof window === "undefined" ? (callback) => callback(0) : window.requestAnimationFrame;
+	const mergeStyles = (nextStyles) => {
+		styles.value = {
+			...styles.value,
+			...nextStyles
+		};
+	};
+	const measureExpandedSize = (attempt = 0) => {
+		if (!isExpanded()) return;
+		const size = getElementSize(elementRef.value);
+		if (size === 0 && elementRef.value?.children.length && attempt < 5) {
+			raf(() => measureExpandedSize(attempt + 1));
+			return;
+		}
+		mergeStyles({
+			...getTransitionStyles(size),
+			[dimension]: getCssSize(size)
+		});
+	};
+	const getTransitionStyles = (size) => {
+		const duration = transitionDuration ?? getAutoSizeDuration(size);
+		return { transition: `${dimension} ${duration}ms ${transitionTimingFunction}, opacity ${duration}ms ${transitionTimingFunction}` };
+	};
+	watch(() => isExpanded(), (value, oldValue) => {
+		if (value === oldValue) return;
+		if (transitionDuration !== 0) onTransitionStart?.();
+		if (value) raf(() => {
+			state.value = "entering";
+			mergeStyles({
+				willChange: dimension,
+				display: "block",
+				overflow: "hidden"
+			});
+			nextTick(() => {
+				raf(() => {
+					raf(() => measureExpandedSize());
+				});
+			});
+		});
+		else raf(() => {
+			state.value = "exiting";
+			const size = getElementSize(elementRef.value);
+			mergeStyles({
+				...getTransitionStyles(size),
+				willChange: dimension,
+				[dimension]: getCssSize(size)
+			});
+			raf(() => mergeStyles({
+				[dimension]: 0,
+				overflow: "hidden"
+			}));
+		});
+	}, { flush: "post" });
+	const handleTransitionEnd = (event) => {
+		if (event.target !== elementRef.value || event.propertyName !== dimension) return;
+		if (isExpanded()) {
+			const size = getElementSize(elementRef.value);
+			if (getCssSize(size) === styles.value[dimension]) styles.value = {};
+			else mergeStyles({ [dimension]: getCssSize(size) });
+			state.value = "entered";
+			onTransitionEnd?.();
+		} else if (styles.value[dimension] === 0) {
+			styles.value = collapsedStyles;
+			state.value = "exited";
+			onTransitionEnd?.();
+		}
+	};
+	return {
+		state,
+		getCollapseProps: (input = {}) => {
+			const setRef = (value) => {
+				const element = value?.$el ?? value;
+				elementRef.value = element;
+				assignRef(input.ref, element);
+			};
+			return {
+				"aria-hidden": !isExpanded(),
+				inert: !isExpanded(),
+				ref: setRef,
+				onTransitionend: handleTransitionEnd,
+				style: {
+					boxSizing: "border-box",
+					...input.style,
+					...styles.value
+				}
+			};
+		}
+	};
+}
+function useCollapse(input) {
+	return createCollapse({
+		...input,
+		dimension: "height",
+		getElementSize: (element) => getElementContentSize(element, "height")
+	});
+}
+//#endregion
+//#region src/use-collapse/use-horizontal-collapse.ts
+function useHorizontalCollapse(input) {
+	return createCollapse({
+		...input,
+		dimension: "width",
+		getElementSize: (element) => getElementContentSize(element, "width")
+	});
+}
+//#endregion
+//#region src/use-mask/use-mask.ts
+var DEFAULT_TOKENS = {
+	"9": /[0-9]/,
+	a: /[A-Za-z]/,
+	A: /[A-Z]/,
+	"*": /[A-Za-z0-9]/,
+	"#": /[-+0-9]/
+};
+var MAX_UNDO_HISTORY = 100;
+function parseMask(mask, tokens) {
+	if (Array.isArray(mask)) return mask.map((item) => {
+		if (item instanceof RegExp) return {
+			type: "token",
+			char: "_",
+			pattern: item
+		};
+		return {
+			type: "literal",
+			char: item
+		};
+	});
+	const slots = [];
+	let optional = false;
+	for (let i = 0; i < mask.length; i++) {
+		const char = mask[i];
+		if (char === "\\" && i + 1 < mask.length) {
+			i++;
+			slots.push({
+				type: "literal",
+				char: mask[i]
+			});
+			continue;
+		}
+		if (char === "?") {
+			optional = true;
+			continue;
+		}
+		if (tokens[char]) slots.push({
+			type: "token",
+			char,
+			pattern: tokens[char],
+			optional
+		});
+		else slots.push({
+			type: "literal",
+			char,
+			optional
+		});
+	}
+	return slots;
+}
+function getSlotChar(slotCharOption, index) {
+	if (slotCharOption === null || slotCharOption === "" || slotCharOption === void 0) return "";
+	if (slotCharOption.length > 1) return slotCharOption[index] || "_";
+	return slotCharOption;
+}
+function applyMaskToRaw(raw, slots, _slotCharOption, transform) {
+	let result = "";
+	let rawIndex = 0;
+	let slotIndex = 0;
+	for (slotIndex = 0; slotIndex < slots.length; slotIndex++) {
+		const slot = slots[slotIndex];
+		if (slot.type === "literal") result += slot.char;
+		else if (rawIndex < raw.length) {
+			const ch = transform ? transform(raw[rawIndex]) : raw[rawIndex];
+			if (slot.pattern && slot.pattern.test(ch)) {
+				result += ch;
+				rawIndex++;
+			} else {
+				rawIndex++;
+				slotIndex--;
+			}
+		} else break;
+	}
+	return result;
+}
+function buildDisplayValue(value, slots, slotCharOption, showSlots) {
+	if (!showSlots) return value;
+	let display = value;
+	for (let i = value.length; i < slots.length; i++) {
+		const slot = slots[i];
+		if (slot.type === "literal") display += slot.char;
+		else {
+			const sc = getSlotChar(slotCharOption, i);
+			if (!sc) break;
+			display += sc;
+		}
+	}
+	return display;
+}
+function extractRaw(masked, slots) {
+	let raw = "";
+	for (let i = 0; i < masked.length && i < slots.length; i++) if (slots[i].type === "token") raw += masked[i];
+	return raw;
+}
+function checkComplete(masked, slots) {
+	for (let i = 0; i < slots.length; i++) if (slots[i].type === "token" && !slots[i].optional) {
+		if (i >= masked.length) return false;
+		if (!slots[i].pattern.test(masked[i])) return false;
+	}
+	return true;
+}
+function findNextTokenIndex(slots, from) {
+	for (let i = from; i < slots.length; i++) if (slots[i].type === "token") return i;
+	return slots.length;
+}
+function findPrevTokenIndex(slots, from) {
+	for (let i = from; i >= 0; i--) if (slots[i].type === "token") return i;
+	return -1;
+}
+function processInput(inputValue, slots, _slotCharOption) {
+	let result = "";
+	let inputIndex = 0;
+	for (let slotIndex = 0; slotIndex < slots.length && inputIndex <= inputValue.length; slotIndex++) {
+		const slot = slots[slotIndex];
+		if (slot.type === "literal") {
+			result += slot.char;
+			if (inputIndex < inputValue.length && inputValue[inputIndex] === slot.char) inputIndex++;
+			continue;
+		}
+		if (inputIndex >= inputValue.length) break;
+		while (inputIndex < inputValue.length) {
+			const ch = inputValue[inputIndex];
+			inputIndex++;
+			if (slot.pattern.test(ch)) {
+				result += ch;
+				break;
+			}
+		}
+		if (result.length <= slotIndex) break;
+	}
+	return result;
+}
+function getResolvedOptions(options, rawValue) {
+	const tokens = {
+		...DEFAULT_TOKENS,
+		...options.tokens
+	};
+	let mask = options.mask;
+	let slotChar = options.slotChar === void 0 ? "_" : options.slotChar;
+	let separate = options.separate ?? false;
+	if (options.modify) {
+		const overrides = options.modify(rawValue);
+		if (overrides) {
+			if (overrides.mask !== void 0) mask = overrides.mask;
+			if (overrides.tokens !== void 0) Object.assign(tokens, overrides.tokens);
+			if (overrides.slotChar !== void 0) slotChar = overrides.slotChar;
+			if (overrides.separate !== void 0) separate = overrides.separate;
+		}
+	}
+	return {
+		slots: parseMask(mask, tokens),
+		slotChar,
+		separate,
+		tokens,
+		transform: options.transform
+	};
+}
+function formatMask(raw, options) {
+	const { slots, slotChar, transform } = getResolvedOptions(options, raw);
+	return applyMaskToRaw(raw, slots, slotChar, transform);
+}
+function unformatMask(masked, options) {
+	const { slots } = getResolvedOptions(options, "");
+	return extractRaw(masked, slots);
+}
+function isMaskComplete(masked, options) {
+	const { slots } = getResolvedOptions(options, "");
+	return checkComplete(masked, slots);
+}
+function generatePattern(mode, options) {
+	const { slots } = getResolvedOptions(options, "");
+	let pattern = "";
+	for (const slot of slots) if (slot.type === "literal") pattern += slot.char.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	else {
+		const src = slot.pattern.source;
+		if (mode === "full-inexact") pattern += slot.optional ? `${src}?` : src;
+		else pattern += slot.optional ? `(${src})?` : `(${src})`;
+	}
+	return pattern;
+}
+function findNextEditablePosition(from, slots, value) {
+	let pos = from;
+	while (pos < slots.length && pos < value.length && slots[pos] && slots[pos].type === "literal") pos++;
+	return pos;
+}
+function useMask(options) {
+	let node = null;
+	const maskedValue = ref("");
+	const rawValue = ref("");
+	const isComplete = ref(false);
+	let processed = "";
+	let display = "";
+	let rawInternal = "";
+	let wasComplete = false;
+	let isFocused = false;
+	let undoStack = [];
+	let redoStack = [];
+	const applyValue = (input) => {
+		const { reprocessed, newRaw, displayValue, resolvedSlots, cursorPos, notifyChange } = input;
+		processed = reprocessed;
+		display = displayValue;
+		rawInternal = newRaw;
+		maskedValue.value = displayValue;
+		rawValue.value = newRaw;
+		if (node) {
+			node.value = displayValue;
+			if (cursorPos !== void 0 && document.activeElement === node) {
+				const pos = Math.min(cursorPos, reprocessed.length);
+				node.setSelectionRange(pos, pos);
+			}
+		}
+		if (notifyChange && options.onChangeRaw) options.onChangeRaw(newRaw, displayValue);
+		const complete = checkComplete(reprocessed, resolvedSlots);
+		if (notifyChange && complete && !wasComplete && options.onComplete) options.onComplete(displayValue, newRaw);
+		wasComplete = complete;
+		isComplete.value = complete;
+	};
+	const updateValue = (newMasked, cursorPos) => {
+		const { slots } = getResolvedOptions(options, extractRaw(newMasked, getResolvedOptions(options, "").slots));
+		const { slots: resolvedSlots, slotChar } = getResolvedOptions(options, extractRaw(newMasked, slots));
+		const reprocessed = processInput(newMasked, resolvedSlots, slotChar);
+		const newRaw = extractRaw(reprocessed, resolvedSlots);
+		const showSlots = options.alwaysShowMask || isFocused;
+		const showOnFocus = options.showMaskOnFocus !== false;
+		const displayValue = buildDisplayValue(reprocessed, resolvedSlots, slotChar, showSlots && (showOnFocus || reprocessed.length > 0));
+		applyValue({
+			reprocessed,
+			newRaw,
+			displayValue,
+			resolvedSlots,
+			cursorPos,
+			notifyChange: true
+		});
+		return {
+			displayValue,
+			newRaw,
+			reprocessed,
+			resolvedSlots
+		};
+	};
+	const initializeInputValue = (inputNode) => {
+		if (!inputNode.value) return false;
+		const { slots: initialSlots, slotChar: initialSlotChar } = getResolvedOptions(options, "");
+		const { slots: resolvedSlots, slotChar } = getResolvedOptions(options, extractRaw(processInput(inputNode.value, initialSlots, initialSlotChar), initialSlots));
+		const reprocessed = processInput(inputNode.value, resolvedSlots, slotChar);
+		const newRaw = extractRaw(reprocessed, resolvedSlots);
+		const showSlots = options.alwaysShowMask || isFocused;
+		const showOnFocus = options.showMaskOnFocus !== false;
+		applyValue({
+			reprocessed,
+			newRaw,
+			displayValue: buildDisplayValue(reprocessed, resolvedSlots, slotChar, showSlots && (showOnFocus || reprocessed.length > 0)),
+			resolvedSlots,
+			notifyChange: false
+		});
+		return true;
+	};
+	const pushUndoState = () => {
+		const selectionStart = node?.selectionStart ?? rawInternal.length;
+		const state = {
+			rawValue: rawInternal,
+			selectionStart
+		};
+		const top = undoStack[undoStack.length - 1];
+		if (top && top.rawValue === state.rawValue && top.selectionStart === state.selectionStart) return;
+		undoStack.push(state);
+		if (undoStack.length > MAX_UNDO_HISTORY) undoStack.shift();
+		redoStack = [];
+	};
+	const applyHistoryState = (target) => {
+		const { slots, slotChar, transform } = getResolvedOptions(options, target.rawValue);
+		updateValue(applyMaskToRaw(target.rawValue, slots, slotChar, transform), target.selectionStart);
+	};
+	const handleInput = (e) => {
+		const input = e.target;
+		const { slots: resolvedSlots, slotChar, transform } = getResolvedOptions(options, "");
+		const prev = display;
+		const curr = input.value;
+		let prefixLen = 0;
+		const maxPrefix = Math.min(prev.length, curr.length);
+		while (prefixLen < maxPrefix && prev[prefixLen] === curr[prefixLen]) prefixLen++;
+		let suffixLen = 0;
+		const maxSuffix = Math.min(prev.length - prefixLen, curr.length - prefixLen);
+		while (suffixLen < maxSuffix && prev[prev.length - 1 - suffixLen] === curr[curr.length - 1 - suffixLen]) suffixLen++;
+		const insertedText = curr.slice(prefixLen, curr.length - suffixLen);
+		const removedEnd = prev.length - suffixLen;
+		const beforeRaw = extractRaw(prev.slice(0, prefixLen), resolvedSlots.slice(0, prefixLen));
+		const afterRaw = extractRaw(prev.slice(removedEnd), resolvedSlots.slice(removedEnd));
+		const reformatted = applyMaskToRaw(beforeRaw + insertedText + afterRaw, resolvedSlots, slotChar, transform);
+		const maskedPrefix = applyMaskToRaw(beforeRaw + insertedText, resolvedSlots, slotChar, transform);
+		if (reformatted !== prev) pushUndoState();
+		updateValue(reformatted, maskedPrefix.length);
+	};
+	const clampCursorToProcessed = (input) => {
+		const start = input.selectionStart ?? 0;
+		if (start !== (input.selectionEnd ?? 0)) return;
+		const { slots } = getResolvedOptions(options, "");
+		const endPos = processed.length > 0 ? findNextEditablePosition(processed.length, slots, processed) : findNextTokenIndex(slots, 0);
+		const startPos = findNextTokenIndex(slots, 0);
+		if (start > endPos || start < startPos) input.setSelectionRange(endPos, endPos);
+	};
+	const handleFocus = () => {
+		isFocused = true;
+		const input = node;
+		if (!input) return;
+		const { slots, slotChar } = getResolvedOptions(options, "");
+		if (options.showMaskOnFocus !== false || options.alwaysShowMask) {
+			const nextDisplay = buildDisplayValue(processed, slots, slotChar, true);
+			input.value = nextDisplay;
+			display = nextDisplay;
+			maskedValue.value = nextDisplay;
+		}
+		requestAnimationFrame(() => {
+			if (input === document.activeElement) clampCursorToProcessed(input);
+		});
+	};
+	const handleMouseUp = () => {
+		const input = node;
+		if (!input || input !== document.activeElement) return;
+		clampCursorToProcessed(input);
+	};
+	const handleMouseDown = () => {
+		const input = node;
+		if (!input) return;
+		requestAnimationFrame(() => {
+			if (input !== document.activeElement) return;
+			const start = input.selectionStart ?? 0;
+			if (start !== (input.selectionEnd ?? 0)) return;
+			const { slots } = getResolvedOptions(options, "");
+			const endPos = processed.length > 0 ? findNextEditablePosition(processed.length, slots, processed) : findNextTokenIndex(slots, 0);
+			if (start > endPos) input.setSelectionRange(endPos, endPos);
+		});
+	};
+	const handleBlur = () => {
+		isFocused = false;
+		const input = node;
+		if (!input) return;
+		const { slots, slotChar } = getResolvedOptions(options, rawInternal);
+		const expectedFocusDisplay = buildDisplayValue(processed, slots, slotChar, true);
+		const nextProcessed = input.value === expectedFocusDisplay ? processed : processInput(input.value, slots, slotChar);
+		const complete = checkComplete(nextProcessed, slots);
+		if (options.autoClear && !complete && nextProcessed.length > 0) {
+			input.value = "";
+			processed = "";
+			display = "";
+			rawInternal = "";
+			maskedValue.value = "";
+			rawValue.value = "";
+			wasComplete = false;
+			isComplete.value = false;
+			if (options.onChangeRaw) options.onChangeRaw("", "");
+			if (options.alwaysShowMask) {
+				const emptyDisplay = buildDisplayValue("", slots, slotChar, true);
+				input.value = emptyDisplay;
+				display = emptyDisplay;
+				maskedValue.value = emptyDisplay;
+			}
+			return;
+		}
+		if (!options.alwaysShowMask && !complete) {
+			if (extractRaw(nextProcessed, slots).length === 0) {
+				input.value = "";
+				processed = "";
+				display = "";
+				rawInternal = "";
+				maskedValue.value = "";
+				rawValue.value = "";
+				wasComplete = false;
+				isComplete.value = false;
+				if (options.onChangeRaw) options.onChangeRaw("", "");
+				return;
+			}
+			const nextDisplay = buildDisplayValue(nextProcessed, slots, slotChar, false);
+			input.value = nextDisplay;
+			display = nextDisplay;
+			maskedValue.value = nextDisplay;
+		}
+	};
+	const handleKeyDown = (e) => {
+		const input = e.target;
+		const { slots, slotChar, transform } = getResolvedOptions(options, rawInternal);
+		const start = input.selectionStart ?? 0;
+		const end = input.selectionEnd ?? 0;
+		const modifier = e.metaKey || e.ctrlKey && !e.altKey;
+		const key = e.key.toLowerCase();
+		if (modifier && key === "z" && !e.shiftKey) {
+			e.preventDefault();
+			const prev = undoStack.pop();
+			if (!prev) return;
+			redoStack.push({
+				rawValue: rawInternal,
+				selectionStart: input.selectionStart ?? 0
+			});
+			applyHistoryState(prev);
+			return;
+		}
+		if (modifier && (key === "z" && e.shiftKey || key === "y" && !e.shiftKey)) {
+			e.preventDefault();
+			const next = redoStack.pop();
+			if (!next) return;
+			undoStack.push({
+				rawValue: rawInternal,
+				selectionStart: input.selectionStart ?? 0
+			});
+			applyHistoryState(next);
+			return;
+		}
+		if (e.key === "Backspace") {
+			e.preventDefault();
+			if (e.metaKey || e.ctrlKey && !e.altKey) {
+				const clampedStart = Math.min(start, processed.length);
+				const newValue = applyMaskToRaw(extractRaw(processed.slice(clampedStart), slots.slice(clampedStart)), slots, slotChar, transform);
+				pushUndoState();
+				updateValue(newValue, 0);
+				return;
+			}
+			if (start !== end) {
+				const clampedEnd = Math.min(end, processed.length);
+				const before = processed.slice(0, start);
+				const afterRaw = extractRaw(processed.slice(clampedEnd), slots.slice(clampedEnd));
+				const newValue = applyMaskToRaw(extractRaw(before, slots) + afterRaw, slots, slotChar, transform);
+				pushUndoState();
+				updateValue(newValue, start);
+				return;
+			}
+			if (start === 0) return;
+			let deletePos = start - 1;
+			while (deletePos >= 0 && slots[deletePos] && slots[deletePos].type === "literal") deletePos--;
+			if (deletePos < 0) return;
+			const newValue = applyMaskToRaw(extractRaw(processed.slice(0, deletePos), slots.slice(0, deletePos)) + extractRaw(processed.slice(deletePos + 1), slots.slice(deletePos + 1)), slots, slotChar, transform);
+			pushUndoState();
+			updateValue(newValue, deletePos);
+		} else if (e.key === "Delete") {
+			e.preventDefault();
+			if (start !== end) {
+				const clampedEnd = Math.min(end, processed.length);
+				const before = processed.slice(0, start);
+				const afterRaw = extractRaw(processed.slice(clampedEnd), slots.slice(clampedEnd));
+				const newValue = applyMaskToRaw(extractRaw(before, slots) + afterRaw, slots, slotChar, transform);
+				pushUndoState();
+				updateValue(newValue, start);
+				return;
+			}
+			let deletePos = start;
+			while (deletePos < slots.length && slots[deletePos] && slots[deletePos].type === "literal") deletePos++;
+			if (deletePos >= processed.length) return;
+			const newValue = applyMaskToRaw(extractRaw(processed.slice(0, start), slots.slice(0, start)) + extractRaw(processed.slice(deletePos + 1), slots.slice(deletePos + 1)), slots, slotChar, transform);
+			pushUndoState();
+			updateValue(newValue, start);
+		} else if (e.key === "ArrowRight" && !e.shiftKey) {
+			const nextPos = findNextEditablePosition(start + 1, slots, input.value);
+			if (nextPos !== start + 1) {
+				e.preventDefault();
+				input.setSelectionRange(nextPos, nextPos);
+			}
+		} else if (e.key === "ArrowLeft" && !e.shiftKey) {
+			if (start > 0) {
+				const prevToken = findPrevTokenIndex(slots, start - 1);
+				if (prevToken >= 0 && prevToken !== start - 1) {
+					e.preventDefault();
+					input.setSelectionRange(prevToken + 1, prevToken + 1);
+				}
+			}
+		} else if (e.key.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey) {
+			e.preventDefault();
+			let insertPos = Math.min(start, processed.length);
+			while (insertPos < slots.length && slots[insertPos] && slots[insertPos].type === "literal") insertPos++;
+			if (insertPos >= slots.length) return;
+			const slot = slots[insertPos];
+			const ch = transform ? transform(e.key) : e.key;
+			if (!slot.pattern.test(ch)) return;
+			const beforeRaw = extractRaw(processed.slice(0, insertPos), slots.slice(0, insertPos));
+			const afterRaw = start < end ? extractRaw(processed.slice(Math.min(end, processed.length)), slots.slice(Math.min(end, processed.length))) : extractRaw(processed.slice(insertPos), slots.slice(insertPos));
+			const newValue = applyMaskToRaw(beforeRaw + ch + afterRaw, slots, slotChar, transform);
+			const newCursorPos = findNextEditablePosition(insertPos + 1, slots, newValue);
+			pushUndoState();
+			updateValue(newValue, newCursorPos);
+		}
+	};
+	const handlePaste = (e) => {
+		e.preventDefault();
+		const input = e.target;
+		const pastedText = e.clipboardData?.getData("text") ?? "";
+		const start = input.selectionStart ?? 0;
+		const end = input.selectionEnd ?? 0;
+		const { slots, slotChar, transform } = getResolvedOptions(options, "");
+		const clampedStart = Math.min(start, processed.length);
+		const clampedEnd = Math.min(end, processed.length);
+		const beforeRaw = extractRaw(processed.slice(0, clampedStart), slots.slice(0, clampedStart));
+		const afterRaw = extractRaw(processed.slice(clampedEnd), slots.slice(clampedEnd));
+		const newValue = applyMaskToRaw(beforeRaw + pastedText + afterRaw, slots, slotChar, transform);
+		pushUndoState();
+		updateValue(newValue);
+		const maskedPrefix = applyMaskToRaw(beforeRaw + pastedText, slots, slotChar, transform);
+		const pasteEndPos = Math.min(maskedPrefix.length, slots.length);
+		if (input === document.activeElement) input.setSelectionRange(pasteEndPos, pasteEndPos);
+	};
+	const setAriaAttributes = (input) => {
+		if (options.invalid) input.setAttribute("aria-invalid", "true");
+		else input.removeAttribute("aria-invalid");
+	};
+	const refCallback = (newNode) => {
+		const prevNode = node;
+		if (prevNode) {
+			prevNode.removeEventListener("input", handleInput);
+			prevNode.removeEventListener("focus", handleFocus);
+			prevNode.removeEventListener("blur", handleBlur);
+			prevNode.removeEventListener("mousedown", handleMouseDown);
+			prevNode.removeEventListener("mouseup", handleMouseUp);
+			prevNode.removeEventListener("keydown", handleKeyDown);
+			prevNode.removeEventListener("paste", handlePaste);
+		}
+		node = newNode;
+		if (newNode) {
+			newNode.addEventListener("input", handleInput);
+			newNode.addEventListener("focus", handleFocus);
+			newNode.addEventListener("blur", handleBlur);
+			newNode.addEventListener("mousedown", handleMouseDown);
+			newNode.addEventListener("mouseup", handleMouseUp);
+			newNode.addEventListener("keydown", handleKeyDown);
+			newNode.addEventListener("paste", handlePaste);
+			setAriaAttributes(newNode);
+			const hasInitialValue = initializeInputValue(newNode);
+			if (options.alwaysShowMask && !hasInitialValue) {
+				const { slots, slotChar } = getResolvedOptions(options, "");
+				const displayValue = buildDisplayValue("", slots, slotChar, true);
+				newNode.value = displayValue;
+				display = displayValue;
+				maskedValue.value = displayValue;
+			}
+		}
+	};
+	watch(() => options.invalid, () => {
+		if (node) setAriaAttributes(node);
+	});
+	const reset = () => {
+		processed = "";
+		display = "";
+		rawInternal = "";
+		undoStack = [];
+		redoStack = [];
+		maskedValue.value = "";
+		rawValue.value = "";
+		wasComplete = false;
+		isComplete.value = false;
+		if (node) if (options.alwaysShowMask) {
+			const { slots, slotChar } = getResolvedOptions(options, "");
+			const displayValue = buildDisplayValue("", slots, slotChar, true);
+			node.value = displayValue;
+			display = displayValue;
+			maskedValue.value = displayValue;
+		} else node.value = "";
+		if (options.onChangeRaw) options.onChangeRaw("", "");
+	};
+	return {
+		ref: refCallback,
+		value: maskedValue,
+		rawValue,
+		isComplete,
+		reset
+	};
+}
+//#endregion
+//#region src/use-roving-index/use-roving-index.ts
+function findNextEnabled(current, total, isItemDisabled, loop) {
+	for (let i = current + 1; i < total; i += 1) if (!isItemDisabled(i)) return i;
+	if (loop) {
+		for (let i = 0; i < current; i += 1) if (!isItemDisabled(i)) return i;
+	}
+	return current;
+}
+function findPreviousEnabled(current, total, isItemDisabled, loop) {
+	for (let i = current - 1; i >= 0; i -= 1) if (!isItemDisabled(i)) return i;
+	if (loop) {
+		for (let i = total - 1; i > current; i -= 1) if (!isItemDisabled(i)) return i;
+	}
+	return current;
+}
+function findFirstEnabled(total, isItemDisabled) {
+	for (let i = 0; i < total; i += 1) if (!isItemDisabled(i)) return i;
+	return 0;
+}
+function findLastEnabled(total, isItemDisabled) {
+	for (let i = total - 1; i >= 0; i -= 1) if (!isItemDisabled(i)) return i;
+	return 0;
+}
+var defaultIsItemDisabled = () => false;
+function useRovingIndex(input) {
+	const { total, orientation = "horizontal", loop = true, dir = "ltr", activateOnFocus = false, columns, focusedIndex, initialIndex, onFocusChange, isItemDisabled = defaultIsItemDisabled } = input;
+	const itemRefs = /* @__PURE__ */ new Map();
+	const getColumns = () => toValue(columns);
+	const getIsGrid = () => {
+		const cols = getColumns();
+		return typeof cols === "number" && cols > 0;
+	};
+	const [activeIndex, setActiveIndex] = useUncontrolled({
+		value: focusedIndex,
+		defaultValue: initialIndex !== void 0 ? initialIndex : findFirstEnabled(toValue(total), isItemDisabled),
+		finalValue: 0,
+		onChange: onFocusChange
+	});
+	watch(() => [toValue(total), activeIndex.value], ([currentTotal, currentActive]) => {
+		if (currentTotal === 0) return;
+		if (currentActive >= currentTotal) setActiveIndex(findLastEnabled(currentTotal, isItemDisabled));
+		else if (isItemDisabled(currentActive)) setActiveIndex(findFirstEnabled(currentTotal, isItemDisabled));
+	}, { immediate: true });
+	const focusItem = (index) => {
+		setActiveIndex(index);
+		const element = itemRefs.get(index);
+		if (element) {
+			element.focus();
+			if (activateOnFocus) element.click();
+		}
+	};
+	const handleGridKeyDown = (event, currentIndex) => {
+		const cols = getColumns();
+		const total_ = toValue(total);
+		const row = Math.floor(currentIndex / cols);
+		const col = currentIndex % cols;
+		const totalRows = Math.ceil(total_ / cols);
+		let nextIndex = null;
+		const isRtl = dir === "rtl";
+		switch (event.key) {
+			case "ArrowRight": {
+				const targetCol = isRtl ? col - 1 : col + 1;
+				if (targetCol >= 0 && targetCol < cols && row * cols + targetCol < total_) {
+					const candidate = row * cols + targetCol;
+					if (!isItemDisabled(candidate)) nextIndex = candidate;
+				}
+				break;
+			}
+			case "ArrowLeft": {
+				const targetCol = isRtl ? col + 1 : col - 1;
+				if (targetCol >= 0 && targetCol < cols && row * cols + targetCol < total_) {
+					const candidate = row * cols + targetCol;
+					if (!isItemDisabled(candidate)) nextIndex = candidate;
+				}
+				break;
+			}
+			case "ArrowDown":
+				for (let r = row + 1; r < totalRows; r += 1) {
+					const candidate = r * cols + col;
+					if (candidate < total_ && !isItemDisabled(candidate)) {
+						nextIndex = candidate;
+						break;
+					}
+				}
+				break;
+			case "ArrowUp":
+				for (let r = row - 1; r >= 0; r -= 1) {
+					const candidate = r * cols + col;
+					if (candidate < total_ && !isItemDisabled(candidate)) {
+						nextIndex = candidate;
+						break;
+					}
+				}
+				break;
+			case "Home":
+				if (event.ctrlKey) nextIndex = findFirstEnabled(total_, isItemDisabled);
+				else {
+					const rowStart = row * cols;
+					for (let i = rowStart; i < rowStart + cols && i < total_; i += 1) if (!isItemDisabled(i)) {
+						nextIndex = i;
+						break;
+					}
+				}
+				break;
+			case "End":
+				if (event.ctrlKey) nextIndex = findLastEnabled(total_, isItemDisabled);
+				else {
+					const rowStart = row * cols;
+					const rowEnd = Math.min(rowStart + cols, total_) - 1;
+					for (let i = rowEnd; i >= rowStart; i -= 1) if (!isItemDisabled(i)) {
+						nextIndex = i;
+						break;
+					}
+				}
+				break;
+		}
+		if (nextIndex !== null && nextIndex !== currentIndex) {
+			event.preventDefault();
+			event.stopPropagation();
+			focusItem(nextIndex);
+		}
+	};
+	const handleListKeyDown = (event, currentIndex) => {
+		const total_ = toValue(total);
+		const isRtl = dir === "rtl";
+		let nextIndex = null;
+		switch (event.key) {
+			case "ArrowRight":
+				if (orientation === "horizontal" || orientation === "both") nextIndex = isRtl ? findPreviousEnabled(currentIndex, total_, isItemDisabled, loop) : findNextEnabled(currentIndex, total_, isItemDisabled, loop);
+				break;
+			case "ArrowLeft":
+				if (orientation === "horizontal" || orientation === "both") nextIndex = isRtl ? findNextEnabled(currentIndex, total_, isItemDisabled, loop) : findPreviousEnabled(currentIndex, total_, isItemDisabled, loop);
+				break;
+			case "ArrowDown":
+				if (orientation === "vertical" || orientation === "both") nextIndex = findNextEnabled(currentIndex, total_, isItemDisabled, loop);
+				break;
+			case "ArrowUp":
+				if (orientation === "vertical" || orientation === "both") nextIndex = findPreviousEnabled(currentIndex, total_, isItemDisabled, loop);
+				break;
+			case "Home":
+				nextIndex = findFirstEnabled(total_, isItemDisabled);
+				break;
+			case "End":
+				nextIndex = findLastEnabled(total_, isItemDisabled);
+				break;
+		}
+		if (nextIndex !== null && nextIndex !== currentIndex) {
+			event.preventDefault();
+			event.stopPropagation();
+			focusItem(nextIndex);
+		}
+	};
+	const getItemProps = (options) => {
+		const { index, onClick, onKeyDown } = options;
+		return {
+			tabIndex: index === activeIndex.value ? 0 : -1,
+			ref: (node) => {
+				const safeNode = node instanceof HTMLElement ? node : null;
+				if (safeNode) itemRefs.set(index, safeNode);
+				else itemRefs.delete(index);
+			},
+			onKeyDown: (event) => {
+				onKeyDown?.(event);
+				if (event.defaultPrevented) return;
+				if (getIsGrid()) handleGridKeyDown(event, index);
+				else handleListKeyDown(event, index);
+			},
+			onClick: (event) => {
+				onClick?.(event);
+				setActiveIndex(index);
+			}
+		};
+	};
+	return {
+		getItemProps,
+		focusedIndex: activeIndex,
+		setFocusedIndex: setActiveIndex
+	};
+}
+//#endregion
+//#region src/use-drag/use-drag.ts
+var VELOCITY_DECAY_MS = 100;
+function sign(n) {
+	if (n > 0) return 1;
+	if (n < 0) return -1;
+	return 0;
+}
+function getThresholdVector(threshold) {
+	const t = threshold ?? 0;
+	if (typeof t === "number") return [t, t];
+	return t;
+}
+function createInitialState() {
+	return {
+		isActive: false,
+		pointerId: -1,
+		startXY: [0, 0],
+		prevXY: [0, 0],
+		startTimestamp: 0,
+		prevTimestamp: 0,
+		thresholdMet: false,
+		firstFired: false,
+		lockedAxis: null,
+		canceled: false,
+		lastVelocity: [0, 0]
+	};
+}
+function useDrag(handler, options = {}) {
+	const active = ref(false);
+	const state = createInitialState();
+	let node = null;
+	let documentController = null;
+	let cleanupNode;
+	const applyAxisConstraint = (v) => {
+		if (options.axis === "x") return [v[0], 0];
+		if (options.axis === "y") return [0, v[1]];
+		if (options.axis === "lock") {
+			if (state.lockedAxis === null) {
+				const t = options.axisThreshold ?? 1;
+				if (Math.abs(v[0]) > t || Math.abs(v[1]) > t) state.lockedAxis = Math.abs(v[0]) >= Math.abs(v[1]) ? "x" : "y";
+			}
+			if (state.lockedAxis === "x") return [v[0], 0];
+			if (state.lockedAxis === "y") return [0, v[1]];
+		}
+		return v;
+	};
+	const resetDrag = () => {
+		state.isActive = false;
+		state.pointerId = -1;
+		state.thresholdMet = false;
+		state.firstFired = false;
+		state.lockedAxis = null;
+		state.canceled = false;
+		active.value = false;
+		document.body.style.userSelect = "";
+		document.body.style.webkitUserSelect = "";
+		documentController?.abort();
+		documentController = null;
+	};
+	const cancel = () => {
+		if (state.isActive) {
+			state.canceled = true;
+			resetDrag();
+		}
+	};
+	const activateDrag = () => {
+		active.value = true;
+		document.body.style.userSelect = "none";
+		document.body.style.webkitUserSelect = "none";
+	};
+	const onPointerDown = (event) => {
+		if (options.enabled === false) return;
+		if (event.button !== 0) return;
+		if (state.isActive) return;
+		state.isActive = true;
+		state.pointerId = event.pointerId;
+		state.startXY = [event.clientX, event.clientY];
+		state.prevXY = [event.clientX, event.clientY];
+		state.startTimestamp = event.timeStamp;
+		state.prevTimestamp = event.timeStamp;
+		state.thresholdMet = false;
+		state.firstFired = false;
+		state.lockedAxis = null;
+		state.canceled = false;
+		state.lastVelocity = [0, 0];
+		const [tx, ty] = getThresholdVector(options.threshold);
+		if (tx === 0 && ty === 0) {
+			state.thresholdMet = true;
+			state.firstFired = true;
+			activateDrag();
+			handler({
+				xy: [event.clientX, event.clientY],
+				initial: [event.clientX, event.clientY],
+				movement: [0, 0],
+				delta: [0, 0],
+				distance: [0, 0],
+				direction: [0, 0],
+				velocity: [0, 0],
+				elapsedTime: 0,
+				first: true,
+				last: false,
+				active: true,
+				tap: false,
+				canceled: false,
+				cancel,
+				event
+			});
+		}
+		documentController?.abort();
+		documentController = new AbortController();
+		const sig = documentController.signal;
+		document.addEventListener("pointermove", onPointerMove, { signal: sig });
+		document.addEventListener("pointerup", onPointerUp, { signal: sig });
+		document.addEventListener("pointercancel", onPointerCancel, { signal: sig });
+	};
+	const onPointerMove = (event) => {
+		if (!state.isActive || event.pointerId !== state.pointerId) return;
+		const rawMovement = [event.clientX - state.startXY[0], event.clientY - state.startXY[1]];
+		if (!state.thresholdMet) {
+			const [tx, ty] = getThresholdVector(options.threshold);
+			if (Math.abs(rawMovement[0]) < tx && Math.abs(rawMovement[1]) < ty) {
+				state.prevXY = [event.clientX, event.clientY];
+				state.prevTimestamp = event.timeStamp;
+				return;
+			}
+			state.thresholdMet = true;
+			activateDrag();
+		}
+		const movement = applyAxisConstraint(rawMovement);
+		const delta = applyAxisConstraint([event.clientX - state.prevXY[0], event.clientY - state.prevXY[1]]);
+		const timeDelta = event.timeStamp - state.prevTimestamp;
+		const velocity = timeDelta > 0 ? [Math.abs(delta[0]) / timeDelta, Math.abs(delta[1]) / timeDelta] : state.lastVelocity;
+		state.lastVelocity = velocity;
+		const isFirst = !state.firstFired;
+		state.firstFired = true;
+		state.prevXY = [event.clientX, event.clientY];
+		state.prevTimestamp = event.timeStamp;
+		handler({
+			xy: [event.clientX, event.clientY],
+			initial: [...state.startXY],
+			movement,
+			delta,
+			distance: [Math.abs(movement[0]), Math.abs(movement[1])],
+			direction: [sign(delta[0]), sign(delta[1])],
+			velocity,
+			elapsedTime: event.timeStamp - state.startTimestamp,
+			first: isFirst,
+			last: false,
+			active: true,
+			tap: false,
+			canceled: false,
+			cancel,
+			event
+		});
+	};
+	const onPointerUp = (event) => {
+		if (!state.isActive || event.pointerId !== state.pointerId) return;
+		if (!state.thresholdMet) {
+			if (options.filterTaps) {
+				const mov = applyAxisConstraint([event.clientX - state.startXY[0], event.clientY - state.startXY[1]]);
+				const dist = [Math.abs(mov[0]), Math.abs(mov[1])];
+				const isTap = Math.max(dist[0], dist[1]) < (options.tapThreshold ?? 3);
+				handler({
+					xy: [event.clientX, event.clientY],
+					initial: [...state.startXY],
+					movement: mov,
+					delta: mov,
+					distance: dist,
+					direction: [sign(mov[0]), sign(mov[1])],
+					velocity: [0, 0],
+					elapsedTime: event.timeStamp - state.startTimestamp,
+					first: true,
+					last: true,
+					active: false,
+					tap: isTap,
+					canceled: false,
+					cancel,
+					event
+				});
+			}
+			resetDrag();
+			return;
+		}
+		const movement = applyAxisConstraint([event.clientX - state.startXY[0], event.clientY - state.startXY[1]]);
+		const distance = [Math.abs(movement[0]), Math.abs(movement[1])];
+		const delta = applyAxisConstraint([event.clientX - state.prevXY[0], event.clientY - state.prevXY[1]]);
+		const velocity = event.timeStamp - state.prevTimestamp > VELOCITY_DECAY_MS ? [0, 0] : state.lastVelocity;
+		const maxDistance = Math.max(distance[0], distance[1]);
+		const tap = options.filterTaps === true && maxDistance < (options.tapThreshold ?? 3);
+		handler({
+			xy: [event.clientX, event.clientY],
+			initial: [...state.startXY],
+			movement,
+			delta,
+			distance,
+			direction: [sign(delta[0]), sign(delta[1])],
+			velocity,
+			elapsedTime: event.timeStamp - state.startTimestamp,
+			first: !state.firstFired,
+			last: true,
+			active: false,
+			tap,
+			canceled: false,
+			cancel,
+			event
+		});
+		resetDrag();
+	};
+	const onPointerCancel = (event) => {
+		if (!state.isActive || event.pointerId !== state.pointerId) return;
+		const movement = applyAxisConstraint([event.clientX - state.startXY[0], event.clientY - state.startXY[1]]);
+		handler({
+			xy: [event.clientX, event.clientY],
+			initial: [...state.startXY],
+			movement,
+			delta: [0, 0],
+			distance: [Math.abs(movement[0]), Math.abs(movement[1])],
+			direction: [0, 0],
+			velocity: [0, 0],
+			elapsedTime: event.timeStamp - state.startTimestamp,
+			first: !state.firstFired,
+			last: true,
+			active: false,
+			tap: false,
+			canceled: true,
+			cancel,
+			event
+		});
+		resetDrag();
+	};
+	const refCallback = (newNode) => {
+		cleanupNode?.();
+		cleanupNode = void 0;
+		node = newNode;
+		if (!node) return;
+		const elementController = new AbortController();
+		node.addEventListener("pointerdown", onPointerDown, { signal: elementController.signal });
+		cleanupNode = () => {
+			elementController.abort();
+			documentController?.abort();
+			documentController = null;
+			if (state.isActive) {
+				state.isActive = false;
+				active.value = false;
+				document.body.style.userSelect = "";
+				document.body.style.webkitUserSelect = "";
+			}
+		};
+	};
+	onBeforeUnmount(() => {
+		cleanupNode?.();
+	});
+	return {
+		ref: refCallback,
+		active
+	};
+}
+//#endregion
+//#region src/use-splitter/use-splitter.ts
+function clamp$1(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+function getMin(panel) {
+	return panel.min ?? 0;
+}
+function getMax(panel) {
+	return panel.max ?? 100;
+}
+function getCollapseThreshold(panel) {
+	return panel.collapseThreshold ?? getMin(panel);
+}
+function createInitialInternalState() {
+	return {
+		isDragging: false,
+		handleIndex: -1,
+		startPointer: 0,
+		containerSize: 0,
+		startSizes: [],
+		preCollapseSizes: []
+	};
+}
+function checkCollapse(sizes, panels, handleIndex, delta) {
+	const beforeIdx = handleIndex;
+	const afterIdx = handleIndex + 1;
+	const beforePanel = panels[beforeIdx];
+	const afterPanel = panels[afterIdx];
+	const rawBefore = sizes[beforeIdx] + delta;
+	const rawAfter = sizes[afterIdx] - delta;
+	if (beforePanel.collapsible && rawBefore < getCollapseThreshold(beforePanel) && rawBefore < sizes[beforeIdx]) {
+		const result = [...sizes];
+		result[afterIdx] += result[beforeIdx];
+		result[beforeIdx] = 0;
+		return result;
+	}
+	if (afterPanel.collapsible && rawAfter < getCollapseThreshold(afterPanel) && rawAfter < sizes[afterIdx]) {
+		const result = [...sizes];
+		result[beforeIdx] += result[afterIdx];
+		result[afterIdx] = 0;
+		return result;
+	}
+	return null;
+}
+function applyAdjacentOnly(sizes, panels, handleIndex, delta) {
+	const result = [...sizes];
+	const beforeIdx = handleIndex;
+	const afterIdx = handleIndex + 1;
+	const total = result[beforeIdx] + result[afterIdx];
+	const effectiveBeforeMax = Math.min(getMax(panels[beforeIdx]), total - getMin(panels[afterIdx]));
+	const effectiveBeforeMin = Math.max(getMin(panels[beforeIdx]), total - getMax(panels[afterIdx]));
+	const newBefore = clamp$1(result[beforeIdx] + delta, effectiveBeforeMin, effectiveBeforeMax);
+	result[beforeIdx] = newBefore;
+	result[afterIdx] = total - newBefore;
+	return result;
+}
+function redistributeNearest(sizes, panels, handleIndex, delta) {
+	const result = [...sizes];
+	if (delta > 0) {
+		const growIdx = handleIndex;
+		const maxGrow = getMax(panels[growIdx]) - result[growIdx];
+		const wantedGrow = Math.min(delta, maxGrow);
+		let taken = 0;
+		for (let i = handleIndex + 1; i < result.length && taken < wantedGrow; i += 1) {
+			const canGive = result[i] - getMin(panels[i]);
+			const take = Math.min(canGive, wantedGrow - taken);
+			result[i] -= take;
+			taken += take;
+		}
+		result[growIdx] += taken;
+	} else if (delta < 0) {
+		const growIdx = handleIndex + 1;
+		const maxGrow = getMax(panels[growIdx]) - result[growIdx];
+		const wantedGrow = Math.min(Math.abs(delta), maxGrow);
+		let taken = 0;
+		for (let i = handleIndex; i >= 0 && taken < wantedGrow; i -= 1) {
+			const canGive = result[i] - getMin(panels[i]);
+			const take = Math.min(canGive, wantedGrow - taken);
+			result[i] -= take;
+			taken += take;
+		}
+		result[growIdx] += taken;
+	}
+	return result;
+}
+function redistributeEqual(sizes, panels, handleIndex, delta) {
+	const result = [...sizes];
+	if (delta > 0) {
+		const growIdx = handleIndex;
+		const maxGrow = getMax(panels[growIdx]) - result[growIdx];
+		const wantedGrow = Math.min(delta, maxGrow);
+		const donors = [];
+		for (let i = handleIndex + 1; i < result.length; i += 1) if (result[i] > getMin(panels[i])) donors.push(i);
+		let remaining = wantedGrow;
+		while (remaining > .001 && donors.length > 0) {
+			const perDonor = remaining / donors.length;
+			const exhausted = [];
+			for (let d = 0; d < donors.length; d += 1) {
+				const idx = donors[d];
+				const canGive = result[idx] - getMin(panels[idx]);
+				const take = Math.min(canGive, perDonor);
+				result[idx] -= take;
+				remaining -= take;
+				if (canGive <= perDonor + .001) exhausted.push(d);
+			}
+			for (let i = exhausted.length - 1; i >= 0; i -= 1) donors.splice(exhausted[i], 1);
+			if (exhausted.length === 0) break;
+		}
+		result[growIdx] += wantedGrow - remaining;
+	} else if (delta < 0) {
+		const growIdx = handleIndex + 1;
+		const maxGrow = getMax(panels[growIdx]) - result[growIdx];
+		const wantedGrow = Math.min(Math.abs(delta), maxGrow);
+		const donors = [];
+		for (let i = handleIndex; i >= 0; i -= 1) if (result[i] > getMin(panels[i])) donors.push(i);
+		let remaining = wantedGrow;
+		while (remaining > .001 && donors.length > 0) {
+			const perDonor = remaining / donors.length;
+			const exhausted = [];
+			for (let d = 0; d < donors.length; d += 1) {
+				const idx = donors[d];
+				const canGive = result[idx] - getMin(panels[idx]);
+				const take = Math.min(canGive, perDonor);
+				result[idx] -= take;
+				remaining -= take;
+				if (canGive <= perDonor + .001) exhausted.push(d);
+			}
+			for (let i = exhausted.length - 1; i >= 0; i -= 1) donors.splice(exhausted[i], 1);
+			if (exhausted.length === 0) break;
+		}
+		result[growIdx] += wantedGrow - remaining;
+	}
+	return result;
+}
+function applyConstraints(sizes, panels, handleIndex, delta, redistribute) {
+	if (typeof redistribute === "function") return redistribute({
+		sizes: [...sizes],
+		panels,
+		handleIndex,
+		delta
+	});
+	if (redistribute === "nearest" || redistribute === "equal") {
+		const result = (redistribute === "nearest" ? redistributeNearest : redistributeEqual)(sizes, panels, handleIndex, delta);
+		const beforeIdx = handleIndex;
+		const afterIdx = handleIndex + 1;
+		const beforePanel = panels[beforeIdx];
+		const afterPanel = panels[afterIdx];
+		if (beforePanel.collapsible && result[beforeIdx] < getCollapseThreshold(beforePanel) && result[beforeIdx] < sizes[beforeIdx]) {
+			const freed = result[beforeIdx];
+			result[afterIdx] += freed;
+			result[beforeIdx] = 0;
+		} else if (afterPanel.collapsible && result[afterIdx] < getCollapseThreshold(afterPanel) && result[afterIdx] < sizes[afterIdx]) {
+			const freed = result[afterIdx];
+			result[beforeIdx] += freed;
+			result[afterIdx] = 0;
+		}
+		return result;
+	}
+	const collapsedResult = checkCollapse(sizes, panels, handleIndex, delta);
+	if (collapsedResult) return collapsedResult;
+	return applyAdjacentOnly(sizes, panels, handleIndex, delta);
+}
+function useSplitter(options) {
+	const { panels, orientation = "horizontal", sizes: controlledSizes, onSizeChange, onResizeStart, onResizeEnd, onCollapseChange, redistribute, step = 1, shiftStep = 10, dir = "ltr", resetOnDoubleClick = true, enabled = true } = options;
+	const defaultSizes = panels.map((p) => p.defaultSize);
+	const [currentSizes, setCurrentSizesRaw] = useUncontrolled({
+		value: controlledSizes,
+		defaultValue: defaultSizes,
+		finalValue: defaultSizes,
+		onChange: onSizeChange
+	});
+	const activeHandle = ref(-1);
+	const internalState = createInitialInternalState();
+	let containerNode = null;
+	let documentController = null;
+	let frame = 0;
+	let preCollapseSizes = [...defaultSizes];
+	const collapsed = computed(() => currentSizes.value.map((size) => size === 0));
+	const updateSizes = (newSizes) => {
+		setCurrentSizesRaw(newSizes);
+	};
+	const collapsePanel = (panelIndex) => {
+		if (!panels[panelIndex]?.collapsible) return;
+		const sizesNow = currentSizes.value;
+		if (sizesNow[panelIndex] === 0) return;
+		preCollapseSizes = [...sizesNow];
+		const newSizes = [...sizesNow];
+		const freedSize = newSizes[panelIndex];
+		newSizes[panelIndex] = 0;
+		const neighbor = panelIndex === 0 ? 1 : panelIndex - 1;
+		newSizes[neighbor] += freedSize;
+		updateSizes(newSizes);
+		onCollapseChange?.(panelIndex, true);
+	};
+	const expandPanel = (panelIndex) => {
+		if (!panels[panelIndex]?.collapsible) return;
+		const sizesNow = currentSizes.value;
+		if (sizesNow[panelIndex] !== 0) return;
+		const restoreSize = preCollapseSizes[panelIndex] || panels[panelIndex].defaultSize;
+		const newSizes = [...sizesNow];
+		const neighbor = panelIndex === 0 ? 1 : panelIndex - 1;
+		const available = Math.max(0, newSizes[neighbor] - getMin(panels[neighbor]));
+		const actualRestore = Math.min(restoreSize, available);
+		if (actualRestore <= 0) return;
+		newSizes[panelIndex] = actualRestore;
+		newSizes[neighbor] -= actualRestore;
+		updateSizes(newSizes);
+		onCollapseChange?.(panelIndex, false);
+	};
+	const toggleCollapsePanel = (panelIndex) => {
+		if (currentSizes.value[panelIndex] === 0) expandPanel(panelIndex);
+		else collapsePanel(panelIndex);
+	};
+	const emitCollapseTransitions = (prev, next, indices, preCollapseSnapshot) => {
+		for (const idx of indices) {
+			const wasCollapsed = prev[idx] === 0;
+			const nowCollapsed = next[idx] === 0;
+			if (!wasCollapsed && nowCollapsed) {
+				preCollapseSizes = [...preCollapseSnapshot];
+				onCollapseChange?.(idx, true);
+			} else if (wasCollapsed && !nowCollapsed) onCollapseChange?.(idx, false);
+		}
+	};
+	const reset = (handleIndex) => {
+		const prev = currentSizes.value;
+		const beforeIdx = handleIndex;
+		const afterIdx = handleIndex + 1;
+		if (beforeIdx < 0 || afterIdx >= prev.length) return;
+		const total = prev[beforeIdx] + prev[afterIdx];
+		const defBefore = panels[beforeIdx].defaultSize;
+		const defTotal = defBefore + panels[afterIdx].defaultSize;
+		const next = applyAdjacentOnly(prev, panels, beforeIdx, (defTotal === 0 ? total / 2 : total * (defBefore / defTotal)) - prev[beforeIdx]);
+		emitCollapseTransitions(prev, next, [beforeIdx, afterIdx], prev);
+		updateSizes(next);
+	};
+	const containerRefCallback = (node) => {
+		containerNode = node instanceof HTMLElement ? node : null;
+	};
+	const handleRefCallbacks = /* @__PURE__ */ new Map();
+	const handleElementControllers = /* @__PURE__ */ new Map();
+	const getHandleRefCallback = (handleIndex) => {
+		const cached = handleRefCallbacks.get(handleIndex);
+		if (cached) return cached;
+		const callback = (rawNode) => {
+			const existingController = handleElementControllers.get(handleIndex);
+			if (existingController) {
+				existingController.abort();
+				handleElementControllers.delete(handleIndex);
+			}
+			const node = rawNode instanceof HTMLElement ? rawNode : null;
+			if (!node) return;
+			const elementController = new AbortController();
+			handleElementControllers.set(handleIndex, elementController);
+			const flushResize = (pointerEvent) => {
+				const s = internalState;
+				if (!s.containerSize) return;
+				const isHorizontal = orientation === "horizontal";
+				const isRtl = isHorizontal && dir === "rtl";
+				const pixelDelta = (isHorizontal ? pointerEvent.clientX : pointerEvent.clientY) - s.startPointer;
+				const percentDelta = (isRtl ? -pixelDelta : pixelDelta) / s.containerSize * 100;
+				const newSizes = applyConstraints(s.startSizes, panels, s.handleIndex, percentDelta, redistribute);
+				const prevSizes = currentSizes.value;
+				emitCollapseTransitions(prevSizes, newSizes, [s.handleIndex, s.handleIndex + 1], s.startSizes);
+				setCurrentSizesRaw(newSizes);
+			};
+			const onPointerMove = (event) => {
+				if (!internalState.isDragging) return;
+				cancelAnimationFrame(frame);
+				frame = requestAnimationFrame(() => {
+					flushResize(event);
+				});
+			};
+			const onPointerUp = (event) => {
+				const s = internalState;
+				if (!s.isDragging) return;
+				cancelAnimationFrame(frame);
+				flushResize(event);
+				s.isDragging = false;
+				const finishedHandle = s.handleIndex;
+				s.handleIndex = -1;
+				activeHandle.value = -1;
+				document.body.style.userSelect = "";
+				document.body.style.webkitUserSelect = "";
+				document.body.style.cursor = "";
+				documentController?.abort();
+				documentController = null;
+				onResizeEnd?.(finishedHandle, [...currentSizes.value]);
+			};
+			const onPointerDown = (event) => {
+				if (enabled === false) return;
+				if (event.button !== 0) return;
+				const container = containerNode;
+				if (!container) return;
+				const rect = container.getBoundingClientRect();
+				const isHorizontal = orientation === "horizontal";
+				const containerSize = isHorizontal ? rect.width : rect.height;
+				const pointerPos = isHorizontal ? event.clientX : event.clientY;
+				internalState.isDragging = true;
+				internalState.handleIndex = handleIndex;
+				internalState.startPointer = pointerPos;
+				internalState.containerSize = containerSize;
+				internalState.startSizes = [...currentSizes.value];
+				internalState.preCollapseSizes = [...preCollapseSizes];
+				activeHandle.value = handleIndex;
+				document.body.style.userSelect = "none";
+				document.body.style.webkitUserSelect = "none";
+				document.body.style.cursor = isHorizontal ? "col-resize" : "row-resize";
+				onResizeStart?.(handleIndex);
+				documentController?.abort();
+				documentController = new AbortController();
+				const sig = documentController.signal;
+				document.addEventListener("pointermove", onPointerMove, { signal: sig });
+				document.addEventListener("pointerup", onPointerUp, { signal: sig });
+				document.addEventListener("pointercancel", onPointerUp, { signal: sig });
+			};
+			node.addEventListener("pointerdown", onPointerDown, { signal: elementController.signal });
+		};
+		handleRefCallbacks.set(handleIndex, callback);
+		return callback;
+	};
+	const getHandleProps = (input) => {
+		const { index } = input;
+		const orient = orientation;
+		const beforeSize = currentSizes.value[index] ?? 0;
+		const beforePanel = panels[index];
+		const afterPanel = panels[index + 1];
+		return {
+			ref: getHandleRefCallback(index),
+			role: "separator",
+			"aria-orientation": orient,
+			"aria-valuenow": Math.round(beforeSize),
+			"aria-valuemin": Math.round(getMin(beforePanel)),
+			"aria-valuemax": Math.round(getMax(beforePanel)),
+			tabIndex: 0,
+			onKeyDown: (event) => {
+				if (!enabled) return;
+				const isHorizontal = orient === "horizontal";
+				const isRtl = dir === "rtl";
+				let delta = 0;
+				const currentStep = event.shiftKey ? shiftStep : step;
+				switch (event.key) {
+					case "ArrowLeft":
+						if (!isHorizontal) return;
+						delta = isRtl ? currentStep : -currentStep;
+						break;
+					case "ArrowRight":
+						if (!isHorizontal) return;
+						delta = isRtl ? -currentStep : currentStep;
+						break;
+					case "ArrowUp":
+						if (isHorizontal) return;
+						delta = -currentStep;
+						break;
+					case "ArrowDown":
+						if (isHorizontal) return;
+						delta = currentStep;
+						break;
+					case "Home":
+						delta = -(currentSizes.value[index] - getMin(beforePanel));
+						break;
+					case "End":
+						delta = getMax(beforePanel) - currentSizes.value[index];
+						break;
+					case "Enter": {
+						const beforeCollapsible = beforePanel?.collapsible;
+						const afterCollapsible = afterPanel?.collapsible;
+						if (beforeCollapsible && currentSizes.value[index] <= currentSizes.value[index + 1]) {
+							toggleCollapsePanel(index);
+							event.preventDefault();
+							return;
+						}
+						if (afterCollapsible) {
+							toggleCollapsePanel(index + 1);
+							event.preventDefault();
+							return;
+						}
+						if (beforeCollapsible) {
+							toggleCollapsePanel(index);
+							event.preventDefault();
+							return;
+						}
+						return;
+					}
+					default: return;
+				}
+				event.preventDefault();
+				if (delta !== 0) {
+					const newSizes = applyConstraints(currentSizes.value, panels, index, delta, redistribute);
+					emitCollapseTransitions(currentSizes.value, newSizes, [index, index + 1], currentSizes.value);
+					updateSizes(newSizes);
+				}
+			},
+			onDoubleClick: () => {
+				if (!enabled || !resetOnDoubleClick) return;
+				reset(index);
+			},
+			"data-active": activeHandle.value === index || void 0,
+			"data-orientation": orient
+		};
+	};
+	onBeforeUnmount(() => {
+		documentController?.abort();
+		documentController = null;
+		handleElementControllers.forEach((controller) => controller.abort());
+		handleElementControllers.clear();
+		cancelAnimationFrame(frame);
+		if (internalState.isDragging) {
+			internalState.isDragging = false;
+			document.body.style.userSelect = "";
+			document.body.style.webkitUserSelect = "";
+			document.body.style.cursor = "";
+		}
+	});
+	return {
+		ref: containerRefCallback,
+		sizes: currentSizes,
+		collapsed,
+		activeHandle,
+		getHandleProps,
+		setSizes: updateSizes,
+		collapse: collapsePanel,
+		expand: expandPanel,
+		toggleCollapse: toggleCollapsePanel,
+		reset
+	};
+}
+//#endregion
+export { DOTS, FOCUS_SELECTOR, assignRef, clamp, clampUseMovePosition, createCollapse, findTabbableDescendants, focusable, formatMask, generatePattern, getElementContentSize, getHotkeyHandler, isFixed, isMaskComplete, isPinned, isPinnedOrReleased, isReleased, lowerFirst, mergeRefs, normalizeRadialValue, randomId, range, readLocalStorageValue, readSessionStorageValue, readonlySetLikeToSet, scopeTab, shallowEqual, tabbable, unformatMask, upperFirst, useCallbackRef, useClickOutside, useClipboard, useCollapse, useColorScheme, useCounter, useDebouncedCallback, useDebouncedState, useDebouncedValue, useDidUpdate, useDisclosure, useDocumentTitle, useDocumentVisibility, useDrag, useElementSize, useEventListener, useEyeDropper, useFavicon, useFetch, useFileDialog, useFloatingWindow, useFocusReturn, useFocusTrap, useFocusWithin, useForceUpdate, useFullscreenDocument, useFullscreenElement, useHash, useHeadroom, useHorizontalCollapse, useHotkeys, useHover, useId, useIdle, useInViewport, useInputState, useIntersection, useInterval, useIsFirstRender, useIsomorphicEffect, useListState, useLocalStorage, useLogger, useLongPress, useMap, useMask, useMediaQuery, useMergedRef, useMounted, useMouse, useMousePosition, useMove, useMutationObserver, useMutationObserverTarget, useNetwork, useOrientation, useOs, usePageLeave, usePagination, usePrevious, useQueue, useRadialMove, useReducedMotion, useResizeObserver, useRovingIndex, useScrollDirection, useScrollIntoView, useScrollSpy, useScroller, useSelection, useSessionStorage, useSet, useSetState, useShallowEffect, useSplitter, useStateHistory, useTextSelection, useThrottledCallback, useThrottledState, useThrottledValue, useTimeout, useToggle, useUncontrolled, useValidatedState, useViewportSize, useWindowEvent, useWindowScroll };
+
+//# sourceMappingURL=index.mjs.map