v-float 0.10.0 → 0.11.0

package/dist/index.mjs

@@ -0,0 +1,2038 @@
+import { computed, effectScope, getCurrentScope, onScopeDispose, onWatcherCleanup, readonly, ref, shallowRef, toValue, watch, watchEffect, watchPostEffect } from "vue";
+import { createFocusTrap } from "focus-trap";
+import { arrow as arrow$1, autoPlacement, autoUpdate, computePosition, flip, hide, offset, shift, size } from "@floating-ui/dom";
+//#region src/composables/utils/use-event-listener.ts
+function useEventListener(target, event, listener, options) {
+	let removeListener;
+	const cleanup = () => {
+		removeListener?.();
+		removeListener = void 0;
+	};
+	const stopWatch = watch(() => [toValue(target), toValue(event)], ([currentTarget, currentEvent], _, onCleanup) => {
+		cleanup();
+		if (!currentTarget || !currentEvent) return;
+		const listenerOptions = typeof options === "object" && options !== null ? { ...options } : options;
+		currentTarget.addEventListener(currentEvent, listener, listenerOptions);
+		removeListener = () => {
+			currentTarget.removeEventListener(currentEvent, listener, listenerOptions);
+		};
+		onCleanup(cleanup);
+	}, {
+		immediate: true,
+		flush: "post"
+	});
+	return () => {
+		stopWatch();
+		cleanup();
+	};
+}
+//#endregion
+//#region src/core/floating-accessors.ts
+function getFloatingRefs(context) {
+	if (context.refs) return context.refs;
+	throw new Error("[VFloat] Floating refs are missing from the provided context.");
+}
+function getFloatingState(context) {
+	if (context.state) return context.state;
+	if (context.open && context.setOpen) return {
+		open: context.open,
+		setOpen: context.setOpen
+	};
+	throw new Error("[VFloat] Floating state is missing from the provided context.");
+}
+function getFloatingPosition(context) {
+	if (context.position) return context.position;
+	if (context.x && context.y && context.strategy && context.placement && context.middlewareData && context.isPositioned && context.floatingStyles && context.update) return {
+		x: context.x,
+		y: context.y,
+		strategy: context.strategy,
+		placement: context.placement,
+		middlewareData: context.middlewareData,
+		isPositioned: context.isPositioned,
+		styles: context.floatingStyles,
+		update: context.update
+	};
+	throw new Error("[VFloat] Floating position data is missing from the provided context.");
+}
+//#endregion
+//#region src/core/lifecycle.ts
+function tryOnScopeDispose(cleanup) {
+	if (!getCurrentScope()) return false;
+	onScopeDispose(cleanup);
+	return true;
+}
+//#endregion
+//#region src/utils.ts
+/**
+* Type guard for HTMLElement
+*/
+function isHTMLElement(value) {
+	return value instanceof Element && value instanceof HTMLElement;
+}
+/**
+* Checks if the user agent is on a Mac.
+*/
+function isMac() {
+	if (typeof navigator === "undefined") return false;
+	return navigator.platform.toUpperCase().indexOf("MAC") >= 0;
+}
+/**
+* Checks if the browser is Safari.
+*/
+function isSafari() {
+	if (typeof navigator === "undefined") return false;
+	return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+}
+/**
+* A simple utility to check if an element matches `:focus-visible`.
+*/
+function matchesFocusVisible(element) {
+	if (typeof element?.matches !== "function") return false;
+	return element.matches(":focus-visible");
+}
+/**
+* Checks if the pointer type is mouse-like (mouse or pen).
+*/
+function isMouseLikePointerType(pointerType, strict) {
+	if (pointerType === void 0) return false;
+	const isMouse = pointerType === "mouse";
+	return strict ? isMouse : isMouse || pointerType === "pen";
+}
+/**
+* Checks if the element is an input, textarea, or contenteditable element.
+*/
+function isTypeableElement(element) {
+	if (!element || !(element instanceof HTMLElement)) return false;
+	return element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element.isContentEditable && element.contentEditable !== "false";
+}
+/**
+* Checks if the event target is a button-like element.
+*/
+function isButtonTarget(event) {
+	const target = event.target;
+	if (!(target instanceof HTMLElement)) return false;
+	return target.tagName === "BUTTON" || target.tagName === "INPUT" && target.getAttribute("type") === "button" || target.getAttribute("role") === "button";
+}
+/**
+* Checks if the Space key press should be ignored for the given element.
+*/
+function isSpaceIgnored(element) {
+	return isTypeableElement(element);
+}
+/**
+* Checks if the event target is within the given element.
+*/
+function isEventTargetWithin(event, element) {
+	if (!element) return false;
+	if ("composedPath" in event && typeof event.composedPath === "function") return event.composedPath().includes(element);
+	return element.contains(event.target);
+}
+/**
+* Checks if a click event occurred on a scrollbar.
+*/
+function isClickOnScrollbar(event, target) {
+	const rect = target.getBoundingClientRect();
+	const scrollbarWidth = target.offsetWidth - target.clientWidth;
+	const scrollbarHeight = target.offsetHeight - target.clientHeight;
+	const elementX = event.clientX - rect.left;
+	const elementY = event.clientY - rect.top;
+	if (scrollbarWidth > 0) {
+		if (elementX >= target.clientWidth && elementX <= target.offsetWidth) return true;
+	}
+	if (scrollbarHeight > 0) {
+		if (elementY >= target.clientHeight && elementY <= target.offsetHeight) return true;
+	}
+	return false;
+}
+/**
+* Simple element containment wrapper.
+*/
+function contains(el, target) {
+	return el.contains(target);
+}
+/**
+* Event target extraction utility.
+*/
+function getTarget(event) {
+	return event.target;
+}
+/**
+* Safe performance timing that handles environments without performance API.
+*/
+function getCurrentTime() {
+	return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+/**
+* Centralized timeout management to prevent memory leaks.
+*/
+function clearTimeoutIfSet(timeoutId) {
+	if (timeoutId !== -1) clearTimeout(timeoutId);
+}
+//#endregion
+//#region src/composables/interactions/use-click.ts
+/**
+* Enables showing/hiding the floating element when clicking the anchor element
+* and optionally when clicking outside both the anchor and floating elements.
+*
+* This composable provides unified event handlers for both inside click interactions
+* (to open/toggle floating elements) and outside click interactions (to close them).
+*
+* @param context - The floating context with open state and change handler.
+* @param options - Configuration options for click behavior.
+*
+* @example Basic usage with outside click enabled
+* ```ts
+* const context = useFloating(...)
+* useClick(context, {
+*   toggle: true,
+*   closeOnOutsideClick: true,
+*   outsideClickEvent: 'pointerdown'
+* })
+* ```
+*
+* @example Custom outside click handler
+* ```ts
+* useClick(context, {
+*   closeOnOutsideClick: true,
+*   onOutsideClick: (event) => {
+*     if (confirm("Close dialog?")) {
+*       context.setOpen(false)
+*     }
+*   },
+* })
+* ```
+*/
+function useClick(context, options = {}) {
+	const { open, setOpen } = getFloatingState(context);
+	const refs = getFloatingRefs(context);
+	const { enabled = true, event: eventOption = "click", toggle = true, ignoreMouse = false, ignoreKeyboard = false, ignoreTouch = false, closeOnOutsideClick = false, outsideClickEvent = "pointerdown", outsideCapture = true, onOutsideClick, ignoreScrollbar = true, ignoreDrag = true } = options;
+	const interactionState = {
+		pointerType: void 0,
+		didKeyDown: false,
+		dragStartedInside: false,
+		interactionInProgress: false
+	};
+	let dragResetTimeoutId;
+	const isEnabled = computed(() => toValue(enabled));
+	const isOutsideClickEnabled = computed(() => toValue(closeOnOutsideClick));
+	const anchorEl = computed(() => {
+		const el = refs.anchorEl.value;
+		if (el instanceof HTMLElement) return el;
+		return null;
+	});
+	const floatingEl = computed(() => refs.floatingEl.value);
+	function clearDragResetTimeout() {
+		if (dragResetTimeoutId == null) return;
+		clearTimeout(dragResetTimeoutId);
+		dragResetTimeoutId = void 0;
+	}
+	function handleOpenChange(reason, event) {
+		interactionState.interactionInProgress = true;
+		try {
+			if (open.value) toValue(toggle) && setOpen(false, reason, event);
+			else setOpen(true, reason, event);
+		} finally {
+			queueMicrotask(() => {
+				interactionState.interactionInProgress = false;
+			});
+		}
+	}
+	function resetInteractionState() {
+		interactionState.pointerType = void 0;
+		interactionState.didKeyDown = false;
+		interactionState.dragStartedInside = false;
+		clearDragResetTimeout();
+	}
+	function onPointerDown(e) {
+		interactionState.pointerType = e.pointerType;
+	}
+	function isSyntheticKeyboardClick(e) {
+		return toValue(ignoreKeyboard) && e.detail === 0;
+	}
+	function onMouseDown(e) {
+		if (e.button !== 0) return;
+		if (toValue(eventOption) === "click") return;
+		if (shouldIgnorePointerType(interactionState.pointerType)) return;
+		handleOpenChange("anchor-click", e);
+	}
+	function onClick(e) {
+		if (isSyntheticKeyboardClick(e)) {
+			resetInteractionState();
+			return;
+		}
+		if (toValue(eventOption) === "mousedown" && interactionState.pointerType) {
+			resetInteractionState();
+			return;
+		}
+		if (shouldIgnorePointerType(interactionState.pointerType)) {
+			resetInteractionState();
+			return;
+		}
+		handleOpenChange("anchor-click", e);
+		resetInteractionState();
+	}
+	function onKeyDown(e) {
+		interactionState.pointerType = void 0;
+		if (e.defaultPrevented || toValue(ignoreKeyboard) || isButtonTarget(e)) return;
+		const el = anchorEl.value;
+		if (!el) return;
+		if (e.key === " " && !isSpaceIgnored(el)) {
+			e.preventDefault();
+			interactionState.didKeyDown = true;
+		}
+		if (e.key === "Enter") handleOpenChange("keyboard-activate", e);
+	}
+	function onKeyUp(e) {
+		const el = anchorEl.value;
+		if (!el) return;
+		if (e.defaultPrevented || toValue(ignoreKeyboard) || isButtonTarget(e) || isSpaceIgnored(el)) return;
+		if (e.key === " " && interactionState.didKeyDown) {
+			interactionState.didKeyDown = false;
+			handleOpenChange("keyboard-activate", e);
+		}
+	}
+	function onOutsideClickHandler(event) {
+		if (!isEnabled.value || !isOutsideClickEnabled.value || !open.value) return;
+		if (suppressOutsideClickForDragSequence()) return;
+		if (interactionState.interactionInProgress) return;
+		const target = event.target;
+		if (!target) return;
+		if (toValue(ignoreScrollbar) && isHTMLElement(target) && floatingEl.value && isClickOnScrollbar(event, target)) return;
+		if (isEventTargetWithin(event, anchorEl.value) || isEventTargetWithin(event, floatingEl.value)) return;
+		if (onOutsideClick) onOutsideClick(event);
+		else setOpen(false, "outside-pointer", event);
+	}
+	function suppressOutsideClickForDragSequence() {
+		if (toValue(outsideClickEvent) !== "click") return false;
+		if (!toValue(ignoreDrag)) return false;
+		if (!interactionState.dragStartedInside) return false;
+		interactionState.dragStartedInside = false;
+		return true;
+	}
+	function onFloatingMouseDown() {
+		interactionState.dragStartedInside = true;
+	}
+	function onFloatingMouseUp() {
+		clearDragResetTimeout();
+		dragResetTimeoutId = setTimeout(() => {
+			interactionState.dragStartedInside = false;
+		}, 0);
+	}
+	function shouldIgnorePointerType(type) {
+		if (isMouseLikePointerType(type, true) && toValue(ignoreMouse)) return true;
+		if (type === "touch" && toValue(ignoreTouch)) return true;
+		return false;
+	}
+	tryOnScopeDispose(() => {
+		clearDragResetTimeout();
+	});
+	watchPostEffect(() => {
+		const el = anchorEl.value;
+		if (!isEnabled.value || !el) return;
+		el.addEventListener("pointerdown", onPointerDown);
+		el.addEventListener("mousedown", onMouseDown);
+		el.addEventListener("click", onClick);
+		el.addEventListener("keydown", onKeyDown);
+		el.addEventListener("keyup", onKeyUp);
+		onWatcherCleanup(() => {
+			el.removeEventListener("pointerdown", onPointerDown);
+			el.removeEventListener("mousedown", onMouseDown);
+			el.removeEventListener("click", onClick);
+			el.removeEventListener("keydown", onKeyDown);
+			el.removeEventListener("keyup", onKeyUp);
+			resetInteractionState();
+		});
+	});
+	useEventListener(() => isEnabled.value && isOutsideClickEnabled.value ? document : null, outsideClickEvent, onOutsideClickHandler, { capture: toValue(outsideCapture) });
+	useEventListener(() => isEnabled.value && isOutsideClickEnabled.value && toValue(ignoreDrag) ? floatingEl.value : null, "mousedown", onFloatingMouseDown, { capture: true });
+	useEventListener(() => isEnabled.value && isOutsideClickEnabled.value && toValue(ignoreDrag) ? floatingEl.value : null, "mouseup", onFloatingMouseUp, { capture: true });
+}
+//#endregion
+//#region src/composables/utils/use-composition.ts
+let sharedCompositionState;
+function getSharedCompositionState() {
+	if (sharedCompositionState) return sharedCompositionState;
+	const scope = effectScope(true);
+	const isComposing = ref(false);
+	scope.run(() => {
+		useEventListener(document, "compositionstart", () => {
+			isComposing.value = true;
+		});
+		useEventListener(document, "compositionend", () => {
+			isComposing.value = false;
+		});
+	});
+	sharedCompositionState = {
+		scope,
+		isComposing,
+		consumers: 0
+	};
+	return sharedCompositionState;
+}
+function useComposition() {
+	const state = getSharedCompositionState();
+	state.consumers += 1;
+	if (getCurrentScope()) onScopeDispose(() => {
+		state.consumers -= 1;
+		if (state.consumers <= 0) {
+			state.scope.stop();
+			sharedCompositionState = void 0;
+		}
+	});
+	return { isComposing: state.isComposing };
+}
+//#endregion
+//#region src/composables/interactions/use-escape-key.ts
+/**
+* A composable to handle the escape key press with composition event handling.
+*
+* When triggered, it will close the floating element by setting open to false.
+*
+* @param context - The floating context with open state and change handler.
+* @param options - {@link UseEscapeKeyOptions}
+*
+* @example Basic usage
+* ```ts
+* const context = useFloating(...)
+* useEscapeKey(context) // Closes the floating element on escape
+* ```
+*
+* @example Custom handler
+* ```ts
+* useEscapeKey(context, {
+*   onEscape: (event) => {
+*     if (hasUnsavedChanges.value) {
+*       showConfirmDialog.value = true
+*     } else {
+*       context.setOpen(false)
+*     }
+*   }
+* })
+* ```
+*/
+function useEscapeKey(context, options = {}) {
+	const { enabled = true, capture = false, preventDefault = false, onEscape } = options;
+	const { isComposing } = useComposition();
+	const { open, setOpen } = getFloatingState(context);
+	const handleEscape = (event) => {
+		if (event.key !== "Escape" || event.defaultPrevented || !toValue(enabled) || !open.value || isComposing.value) return;
+		if (preventDefault) event.preventDefault();
+		if (onEscape) {
+			onEscape(event);
+			return;
+		}
+		setOpen(false, "escape-key", event);
+	};
+	useEventListener(document, "keydown", handleEscape, capture);
+}
+//#endregion
+//#region src/composables/utils/is-using-keyboard.ts
+const mutableRef = ref(false);
+if (typeof window !== "undefined") {
+	const options = { capture: true };
+	function switchToKeyboard() {
+		mutableRef.value = true;
+		window.removeEventListener("keydown", switchToKeyboard, options);
+		window.addEventListener("pointerdown", switchToPointer, options);
+	}
+	function switchToPointer() {
+		mutableRef.value = false;
+		window.removeEventListener("pointerdown", switchToPointer, options);
+		window.addEventListener("keydown", switchToKeyboard, options);
+	}
+	switchToPointer();
+}
+const isUsingKeyboard = readonly(mutableRef);
+//#endregion
+//#region src/composables/interactions/use-focus.ts
+/**
+* Delay in milliseconds for checking active element after blur event.
+* Using 0ms ensures check happens in next event loop tick, which is more
+* reliable than relatedTarget for Shadow DOM and programmatic focus changes.
+*/
+const BLUR_CHECK_DELAY = 0;
+/**
+* Enables showing/hiding the floating element when the reference element receives or loses focus.
+*
+* Keyboard-only interaction hook. Compose with `useClick`, `useHover`, `useEscapeKey` for a complete UX.
+*
+* @param context - The floating context with open state and change handler
+* @param options - Configuration options
+*
+* @example
+* ```ts
+* const ctx = useFloating(...)
+* useFocus(ctx)
+* ```
+*/
+function useFocus(context, options = {}) {
+	const { open, setOpen } = getFloatingState(context);
+	const { floatingEl, anchorEl: _anchorEl } = getFloatingRefs(context);
+	const { enabled = true, requireFocusVisible = true } = options;
+	/**
+	* Computed anchor element that handles both HTMLElement and virtual element references.
+	* Virtual elements (from libraries like Floating UI) use a `contextElement` property
+	* to reference the actual DOM element for positioning calculations.
+	*/
+	const anchorEl = computed(() => {
+		if (!_anchorEl.value) return null;
+		return _anchorEl.value instanceof HTMLElement ? _anchorEl.value : _anchorEl.value.contextElement;
+	});
+	let isFocusBlocked = false;
+	const isSafariOnMac = isMac() && isSafari();
+	let timeoutId;
+	useEventListener(window, "blur", () => {
+		if (!open.value && anchorEl.value && anchorEl.value === document.activeElement) isFocusBlocked = true;
+	});
+	useEventListener(window, "focus", () => {
+		isFocusBlocked = false;
+	});
+	function onFocus(event) {
+		if (isFocusBlocked) {
+			isFocusBlocked = false;
+			return;
+		}
+		const target = event.target instanceof Element ? event.target : null;
+		if (toValue(requireFocusVisible) && target) {
+			if (isSafariOnMac && !event.relatedTarget) {
+				if (!isUsingKeyboard.value && !isTypeableElement(target)) return;
+			} else if (!matchesFocusVisible(target)) return;
+		}
+		try {
+			setOpen(true, "focus", event);
+		} catch (error) {
+			console.error("[useFocus] Error in onFocus handler:", error);
+		}
+	}
+	function onBlur(event) {
+		clearTimeout(timeoutId);
+		timeoutId = window.setTimeout(() => {
+			const activeEl = (anchorEl.value?.ownerDocument ?? document).activeElement;
+			if (!event.relatedTarget && activeEl === anchorEl.value) return;
+			if (activeEl && floatingEl.value?.contains(activeEl)) return;
+			try {
+				setOpen(false, "blur", event);
+			} catch (error) {
+				console.error("[useFocus] Error in onBlur handler:", error);
+			}
+		}, BLUR_CHECK_DELAY);
+	}
+	useEventListener(document, "focusin", (evt) => {
+		if (!toValue(enabled)) return;
+		if (!(evt.target instanceof Element)) return;
+		if (isEventTargetWithin(evt, anchorEl.value)) return;
+		if (isEventTargetWithin(evt, floatingEl.value)) return;
+		try {
+			setOpen(false, "blur", evt);
+		} catch (error) {
+			console.error("[useFocus] Error in document focusin handler:", error);
+		}
+	}, { capture: true });
+	const removeWatcher = watchPostEffect(() => {
+		if (!toValue(enabled)) return;
+		const el = anchorEl.value;
+		if (!el || !(el instanceof HTMLElement)) return;
+		el.addEventListener("focus", onFocus);
+		el.addEventListener("blur", onBlur);
+		onWatcherCleanup(() => {
+			el.removeEventListener("focus", onFocus);
+			el.removeEventListener("blur", onBlur);
+		});
+	});
+	tryOnScopeDispose(() => {
+		clearTimeout(timeoutId);
+	});
+	return { cleanup: () => {
+		clearTimeout(timeoutId);
+		removeWatcher();
+	} };
+}
+//#endregion
+//#region src/composables/interactions/use-focus-trap.ts
+const supportsInert = typeof HTMLElement !== "undefined" && "inert" in HTMLElement.prototype;
+function resolveInitialFocus(initialFocus) {
+	return () => typeof initialFocus === "function" ? initialFocus() : initialFocus;
+}
+function resolveIsolationMode(modal, outsideElementsInert) {
+	if (!modal) return false;
+	if (outsideElementsInert && supportsInert) return "inert";
+	return "aria-hidden";
+}
+/**
+* Creates a focus trap for a floating element using focus-trap library.
+* Manages focus containment, modal behavior, and accessibility features.
+*
+* @param context - Floating context containing floating element refs
+* @param options - Configuration options for the focus trap
+* @returns Object with isActive state, and manual control methods
+*/
+function useFocusTrap(context, options = {}) {
+	const { floatingEl } = getFloatingRefs(context);
+	const { open, setOpen } = getFloatingState(context);
+	const { enabled = true, modal = false, initialFocus, returnFocus = true, closeOnFocusOut = false, preventScroll = true, outsideElementsInert = false, onError } = options;
+	const isEnabled = computed(() => !!toValue(enabled));
+	const isModal = computed(() => !!toValue(modal));
+	const shouldCloseOnFocusOut = computed(() => !isModal.value && !!toValue(closeOnFocusOut));
+	const shouldInertOutside = computed(() => !!toValue(outsideElementsInert));
+	const trapRef = shallowRef(null);
+	const isActive = computed(() => trapRef.value !== null);
+	let shouldCloseOnDeactivate = false;
+	let isDeactivating = false;
+	/**
+	* Deactivates the focus trap and cleans up state.
+	*/
+	const deactivateTrap = (options = {}) => {
+		if (isDeactivating || !trapRef.value) return;
+		isDeactivating = true;
+		if (options.closeFloating) shouldCloseOnDeactivate = true;
+		try {
+			trapRef.value.deactivate({ returnFocus: options.returnFocus ?? toValue(returnFocus) });
+			trapRef.value = null;
+		} finally {
+			isDeactivating = false;
+		}
+	};
+	/**
+	* Creates and activates the focus trap.
+	*/
+	const createTrap = () => {
+		if (!isEnabled.value || !open.value) return;
+		deactivateTrap({ returnFocus: false });
+		const container = floatingEl.value;
+		if (!container) {
+			if (import.meta.env.DEV) console.warn("[useFocusTrap] No floating element available for focus trap");
+			return;
+		}
+		trapRef.value = createFocusTrap(container, {
+			onActivate: () => {
+				shouldCloseOnDeactivate = false;
+			},
+			onDeactivate: () => {
+				trapRef.value = null;
+				if (shouldCloseOnDeactivate) {
+					shouldCloseOnDeactivate = false;
+					setOpen(false);
+				}
+			},
+			initialFocus: resolveInitialFocus(initialFocus),
+			fallbackFocus: () => container,
+			returnFocusOnDeactivate: toValue(returnFocus),
+			clickOutsideDeactivates: () => {
+				if (!shouldCloseOnFocusOut.value) return false;
+				shouldCloseOnDeactivate = true;
+				return true;
+			},
+			allowOutsideClick: !isModal.value,
+			escapeDeactivates: false,
+			preventScroll: toValue(preventScroll),
+			isolateSubtrees: resolveIsolationMode(isModal.value, shouldInertOutside.value),
+			tabbableOptions: { displayCheck: "none" }
+		});
+		try {
+			trapRef.value.activate();
+		} catch (error) {
+			shouldCloseOnDeactivate = false;
+			trapRef.value = null;
+			if (onError) onError(error);
+			else if (import.meta.env.DEV) console.error("[useFocusTrap] Failed to activate focus trap:", error);
+		}
+	};
+	watchPostEffect(() => {
+		if (isEnabled.value && open.value && floatingEl.value) createTrap();
+		else deactivateTrap();
+	});
+	tryOnScopeDispose(() => {
+		deactivateTrap();
+	});
+	return {
+		isActive,
+		activate: createTrap,
+		deactivate: () => deactivateTrap({ closeFloating: true })
+	};
+}
+//#endregion
+//#region src/composables/interactions/polygon/geometry.ts
+function isInside(point, rect) {
+	return point[0] >= rect.x && point[0] <= rect.x + rect.width && point[1] >= rect.y && point[1] <= rect.y + rect.height;
+}
+function isPointInPolygon(point, polygon) {
+	const [x, y] = point;
+	let isInsidePolygon = false;
+	const length = polygon.length;
+	for (let i = 0, j = length - 1; i < length; j = i++) {
+		const [xi, yi] = polygon[i] || [0, 0];
+		const [xj, yj] = polygon[j] || [0, 0];
+		if (yi >= y !== yj >= y && x <= (xj - xi) * (y - yi) / (yj - yi) + xi) isInsidePolygon = !isInsidePolygon;
+	}
+	return isInsidePolygon;
+}
+function getCursorSpeed(x, y, lastX, lastY, lastCursorTime, currentTime) {
+	const elapsedTime = currentTime - lastCursorTime;
+	if (lastX === null || lastY === null || elapsedTime === 0) return {
+		speed: null,
+		lastX: x,
+		lastY: y,
+		lastCursorTime: currentTime
+	};
+	const deltaX = x - lastX;
+	const deltaY = y - lastY;
+	return {
+		speed: Math.sqrt(deltaX * deltaX + deltaY * deltaY) / elapsedTime,
+		lastX: x,
+		lastY: y,
+		lastCursorTime: currentTime
+	};
+}
+function isPointerLeavingOppositeSide(side, leaveX, leaveY, refRect) {
+	return side === "top" && leaveY >= (refRect?.bottom ?? 0) - 1 || side === "bottom" && leaveY <= (refRect?.top ?? 0) + 1 || side === "left" && leaveX >= (refRect?.right ?? 0) - 1 || side === "right" && leaveX <= (refRect?.left ?? 0) + 1;
+}
+function buildRectangularTrough(side, rect, refRect) {
+	const isFloatingWider = (rect?.width ?? 0) > (refRect?.width ?? 0);
+	const isFloatingTaller = (rect?.height ?? 0) > (refRect?.height ?? 0);
+	const left = (isFloatingWider ? refRect : rect)?.left ?? 0;
+	const right = (isFloatingWider ? refRect : rect)?.right ?? 0;
+	const top = (isFloatingTaller ? refRect : rect)?.top ?? 0;
+	const bottom = (isFloatingTaller ? refRect : rect)?.bottom ?? 0;
+	switch (side) {
+		case "top": return [
+			[left, (refRect?.top ?? 0) + 1],
+			[left, (rect?.bottom ?? 0) - 1],
+			[right, (rect?.bottom ?? 0) - 1],
+			[right, (refRect?.top ?? 0) + 1]
+		];
+		case "bottom": return [
+			[left, (rect?.top ?? 0) + 1],
+			[left, (refRect?.bottom ?? 0) - 1],
+			[right, (refRect?.bottom ?? 0) - 1],
+			[right, (rect?.top ?? 0) + 1]
+		];
+		case "left": return [
+			[(rect?.right ?? 0) - 1, bottom],
+			[(rect?.right ?? 0) - 1, top],
+			[(refRect?.left ?? 0) + 1, top],
+			[(refRect?.left ?? 0) + 1, bottom]
+		];
+		case "right": return [
+			[(refRect?.right ?? 0) - 1, bottom],
+			[(refRect?.right ?? 0) - 1, top],
+			[(rect?.left ?? 0) + 1, top],
+			[(rect?.left ?? 0) + 1, bottom]
+		];
+	}
+}
+function buildSafePolygon(side, leaveX, leaveY, rect, refRect, buffer) {
+	const isFloatingWider = (rect?.width ?? 0) > (refRect?.width ?? 0);
+	const isFloatingTaller = (rect?.height ?? 0) > (refRect?.height ?? 0);
+	const cursorLeaveFromRight = leaveX > (rect?.right ?? 0) - (rect?.width ?? 0) / 2;
+	const cursorLeaveFromBottom = leaveY > (rect?.bottom ?? 0) - (rect?.height ?? 0) / 2;
+	switch (side) {
+		case "top": return [
+			[isFloatingWider ? leaveX + buffer / 2 : cursorLeaveFromRight ? leaveX + buffer * 4 : leaveX - buffer * 4, leaveY + buffer + 1],
+			[isFloatingWider ? leaveX - buffer / 2 : cursorLeaveFromRight ? leaveX + buffer * 4 : leaveX - buffer * 4, leaveY + buffer + 1],
+			...[[rect?.left ?? 0, cursorLeaveFromRight ? (rect?.bottom ?? 0) - buffer : isFloatingWider ? (rect?.bottom ?? 0) - buffer : rect?.top ?? 0], [rect?.right ?? 0, cursorLeaveFromRight ? isFloatingWider ? (rect?.bottom ?? 0) - buffer : rect?.top ?? 0 : (rect?.bottom ?? 0) - buffer]]
+		];
+		case "bottom": return [
+			[isFloatingWider ? leaveX + buffer / 2 : cursorLeaveFromRight ? leaveX + buffer * 4 : leaveX - buffer * 4, leaveY - buffer],
+			[isFloatingWider ? leaveX - buffer / 2 : cursorLeaveFromRight ? leaveX + buffer * 4 : leaveX - buffer * 4, leaveY - buffer],
+			...[[rect?.left ?? 0, cursorLeaveFromRight ? (rect?.top ?? 0) + buffer : isFloatingWider ? (rect?.top ?? 0) + buffer : rect?.bottom ?? 0], [rect?.right ?? 0, cursorLeaveFromRight ? isFloatingWider ? (rect?.top ?? 0) + buffer : rect?.bottom ?? 0 : (rect?.top ?? 0) + buffer]]
+		];
+		case "left": {
+			const cursorPointOne = [leaveX + buffer + 1, isFloatingTaller ? leaveY + buffer / 2 : cursorLeaveFromBottom ? leaveY + buffer * 4 : leaveY - buffer * 4];
+			const cursorPointTwo = [leaveX + buffer + 1, isFloatingTaller ? leaveY - buffer / 2 : cursorLeaveFromBottom ? leaveY + buffer * 4 : leaveY - buffer * 4];
+			return [
+				...[[cursorLeaveFromBottom ? (rect?.right ?? 0) - buffer : isFloatingTaller ? (rect?.right ?? 0) - buffer : rect?.left ?? 0, rect?.top ?? 0], [cursorLeaveFromBottom ? isFloatingTaller ? (rect?.right ?? 0) - buffer : rect?.left ?? 0 : (rect?.right ?? 0) - buffer, rect?.bottom ?? 0]],
+				cursorPointOne,
+				cursorPointTwo
+			];
+		}
+		case "right": return [
+			[leaveX - buffer, isFloatingTaller ? leaveY + buffer / 2 : cursorLeaveFromBottom ? leaveY + buffer * 4 : leaveY - buffer * 4],
+			[leaveX - buffer, isFloatingTaller ? leaveY - buffer / 2 : cursorLeaveFromBottom ? leaveY + buffer * 4 : leaveY - buffer * 4],
+			...[[cursorLeaveFromBottom ? (rect?.left ?? 0) + buffer : isFloatingTaller ? (rect?.left ?? 0) + buffer : rect?.right ?? 0, rect?.top ?? 0], [cursorLeaveFromBottom ? isFloatingTaller ? (rect?.left ?? 0) + buffer : rect?.right ?? 0 : (rect?.left ?? 0) + buffer, rect?.bottom ?? 0]]
+		];
+	}
+}
+//#endregion
+//#region src/composables/interactions/polygon/bridge.ts
+function safePolygon(options = {}) {
+	const { requireIntent = true } = options;
+	let timeoutId = -1;
+	let hasLanded = false;
+	return function createSafePolygonHandler(context) {
+		const { x, y, placement, elements, buffer: contextBuffer, onClose } = context;
+		const referenceEl = computed(() => {
+			const domReference = elements.domReference;
+			if (isHTMLElement(domReference)) return domReference;
+			return domReference?.contextElement ?? null;
+		});
+		let lastX = null;
+		let lastY = null;
+		let lastCursorTime = getCurrentTime();
+		const close = () => {
+			clearTimeoutIfSet(timeoutId);
+			timeoutId = -1;
+			onClose();
+		};
+		return function onMouseMove(event) {
+			clearTimeoutIfSet(timeoutId);
+			timeoutId = -1;
+			if (!elements.domReference || !elements.floating || placement == null || x == null || y == null) return;
+			const { clientX, clientY } = event;
+			const clientPoint = [clientX, clientY];
+			const target = getTarget(event);
+			const isLeave = event.type === "mouseleave";
+			const isOverFloatingEl = elements.floating && contains(elements.floating, target);
+			const isOverReferenceEl = referenceEl.value && contains(referenceEl.value, target);
+			const refRect = referenceEl.value?.getBoundingClientRect();
+			const rect = elements.floating?.getBoundingClientRect();
+			const side = placement.split("-")[0];
+			const isOverReferenceRect = refRect ? isInside(clientPoint, refRect) : false;
+			if (isOverFloatingEl) {
+				hasLanded = true;
+				if (!isLeave) return;
+			}
+			if (isOverReferenceEl) hasLanded = false;
+			if (isOverReferenceEl && !isLeave) {
+				hasLanded = true;
+				return;
+			}
+			if (isLeave && isHTMLElement(event.relatedTarget) && elements.floating && contains(elements.floating, event.relatedTarget)) return;
+			if (isPointerLeavingOppositeSide(side, x, y, refRect)) {
+				close();
+				return;
+			}
+			const rectPoly = buildRectangularTrough(side, rect, refRect);
+			const polygon = buildSafePolygon(side, x, y, rect, refRect, contextBuffer);
+			options.onPolygonChange?.(polygon);
+			if (isPointInPolygon(clientPoint, rectPoly)) return;
+			if (isPointInPolygon(clientPoint, polygon)) {
+				if (!hasLanded && requireIntent) {
+					const speedResult = getCursorSpeed(event.clientX, event.clientY, lastX, lastY, lastCursorTime, getCurrentTime());
+					lastX = speedResult.lastX;
+					lastY = speedResult.lastY;
+					lastCursorTime = speedResult.lastCursorTime;
+					if (speedResult.speed !== null && speedResult.speed < .1) timeoutId = window.setTimeout(close, 40);
+				}
+				return;
+			}
+			if (hasLanded && !isOverReferenceRect) {
+				close();
+				return;
+			}
+			close();
+		};
+	};
+}
+//#endregion
+//#region src/composables/interactions/use-hover.ts
+const POINTER_MOVE_THRESHOLD = 10;
+function useDelayedOpen(show, hide, options) {
+	const { delay } = options;
+	const showDelay = computed(() => {
+		const delayVal = toValue(delay);
+		return (typeof delayVal === "number" ? delayVal : delayVal.open) ?? 0;
+	});
+	const hideDelay = computed(() => {
+		const delayVal = toValue(delay);
+		return (typeof delayVal === "number" ? delayVal : delayVal.close) ?? 0;
+	});
+	let showTimeoutID;
+	let hideTimeoutID;
+	const clearTimeouts = () => {
+		clearTimeout(showTimeoutID);
+		clearTimeout(hideTimeoutID);
+	};
+	tryOnScopeDispose(clearTimeouts);
+	return {
+		show: (overrideDelay, event) => {
+			clearTimeouts();
+			const resolvedDelay = overrideDelay ?? showDelay.value;
+			if (resolvedDelay === 0) show(event);
+			else showTimeoutID = setTimeout(() => show(event), resolvedDelay);
+		},
+		hide: (overrideDelay, event) => {
+			clearTimeouts();
+			const resolvedDelay = overrideDelay ?? hideDelay.value;
+			if (resolvedDelay === 0) hide(event);
+			else hideTimeoutID = setTimeout(() => hide(event), resolvedDelay);
+		},
+		showDelay,
+		hideDelay,
+		clearTimeouts
+	};
+}
+/**
+* Enables showing/hiding the floating element when hovering the reference element
+* with enhanced behaviors like delayed open/close, rest detection, and custom
+* exit handling.
+*
+* @param context - The floating context with open state and change handler
+* @param options - Configuration options for hover behavior
+*
+* @example Basic usage
+* ```ts
+* const context = useFloating(...)
+* useHover(context, {
+*   delay: { open: 100, close: 300 },
+*   restMs: 150
+* })
+* ```
+*/
+function useHover(context, options = {}) {
+	const { open, setOpen } = getFloatingState(context);
+	const { placement } = getFloatingPosition(context);
+	const { anchorEl, floatingEl } = getFloatingRefs(context);
+	const { enabled: enabledOption = true, delay = 0, restMs: restMsOption = 0, mouseOnly = false, safePolygon: safePolygonOption = false } = options;
+	const enabled = computed(() => toValue(enabledOption));
+	const restMs = computed(() => toValue(restMsOption));
+	const reference = computed(() => {
+		const el = anchorEl.value;
+		if (!el || el instanceof HTMLElement) return el;
+		return el.contextElement ?? null;
+	});
+	const { hide, show, showDelay, clearTimeouts } = useDelayedOpen((event) => {
+		open.value || setOpen(true, "hover", event);
+	}, (event) => {
+		open.value && setOpen(false, "hover", event);
+	}, { delay });
+	let restCoords = null;
+	let restTimeoutId;
+	const isRestMsEnabled = computed(() => showDelay.value === 0 && restMs.value > 0);
+	function onPointerMoveForRest(e) {
+		if (!enabled.value || !isValidPointerType(e) || !isRestMsEnabled.value) return;
+		if (!restCoords) return;
+		const newCoords = {
+			x: e.clientX,
+			y: e.clientY
+		};
+		const dx = Math.abs(newCoords.x - restCoords.x);
+		const dy = Math.abs(newCoords.y - restCoords.y);
+		if (dx > POINTER_MOVE_THRESHOLD || dy > POINTER_MOVE_THRESHOLD) {
+			restCoords = newCoords;
+			clearTimeout(restTimeoutId);
+			restTimeoutId = setTimeout(() => {
+				show(0, e);
+			}, restMs.value);
+		}
+	}
+	function onPointerEnterForRest(e) {
+		if (!enabled.value || !isValidPointerType(e) || !isRestMsEnabled.value) return;
+		restCoords = {
+			x: e.clientX,
+			y: e.clientY
+		};
+		restTimeoutId = setTimeout(() => {
+			show(0, e);
+		}, restMs.value);
+	}
+	function onPointerLeaveForRest() {
+		clearTimeout(restTimeoutId);
+		restCoords = null;
+	}
+	watchPostEffect(() => {
+		const el = reference.value;
+		if (!el || !enabled.value || !isRestMsEnabled.value) return;
+		el.addEventListener("pointerenter", onPointerEnterForRest);
+		el.addEventListener("pointermove", onPointerMoveForRest);
+		el.addEventListener("pointerleave", onPointerLeaveForRest);
+		onWatcherCleanup(() => {
+			el.removeEventListener("pointerenter", onPointerEnterForRest);
+			el.removeEventListener("pointermove", onPointerMoveForRest);
+			el.removeEventListener("pointerleave", onPointerLeaveForRest);
+		});
+	});
+	tryOnScopeDispose(() => {
+		clearTimeout(restTimeoutId);
+	});
+	function isValidPointerType(e) {
+		if (toValue(mouseOnly)) return e.pointerType === "mouse";
+		return true;
+	}
+	function onPointerEnterReference(e) {
+		if (!enabled.value || !isValidPointerType(e) || isRestMsEnabled.value) return;
+		cleanupPolygon();
+		show(void 0, e);
+	}
+	function onPointerEnterFloating(e) {
+		if (!enabled.value || !isValidPointerType(e)) return;
+		clearTimeouts();
+		cleanupPolygon();
+	}
+	let polygonMouseMoveHandler = null;
+	function cleanupPolygon() {
+		if (polygonMouseMoveHandler) {
+			document.removeEventListener("pointermove", polygonMouseMoveHandler);
+			polygonMouseMoveHandler = null;
+		}
+		const polygonOptions = safePolygonOptions.value;
+		if (polygonOptions?.onPolygonChange) polygonOptions.onPolygonChange([]);
+	}
+	const safePolygonEnabled = computed(() => !!toValue(safePolygonOption));
+	const safePolygonOptions = computed(() => {
+		const val = toValue(safePolygonOption);
+		if (typeof val === "object" && val) return val;
+		if (val === true) return {};
+	});
+	function onPointerLeave(e) {
+		if (!enabled.value || !isValidPointerType(e)) return;
+		const { clientX, clientY } = e;
+		const relatedTarget = e.relatedTarget;
+		if (safePolygonEnabled.value) setTimeout(() => {
+			cleanupPolygon();
+			const refEl = reference.value;
+			const floatEl = floatingEl.value;
+			if (!refEl || !floatEl) {
+				hide(void 0, e);
+				return;
+			}
+			polygonMouseMoveHandler = safePolygon(safePolygonOptions.value)({
+				x: clientX,
+				y: clientY,
+				placement: placement.value,
+				elements: {
+					domReference: refEl,
+					floating: floatEl
+				},
+				buffer: safePolygonOptions.value?.buffer ?? 1,
+				onClose: () => {
+					cleanupPolygon();
+					hide(void 0);
+				}
+			});
+			if (polygonMouseMoveHandler) document.addEventListener("pointermove", polygonMouseMoveHandler);
+		}, 0);
+		else {
+			if (floatingEl.value?.contains(relatedTarget)) return;
+			hide(void 0, e);
+		}
+	}
+	watchPostEffect(() => {
+		const el = reference.value;
+		if (!el || !enabled.value) return;
+		el.addEventListener("pointerenter", onPointerEnterReference);
+		el.addEventListener("pointerleave", onPointerLeave);
+		onWatcherCleanup(() => {
+			el.removeEventListener("pointerenter", onPointerEnterReference);
+			el.removeEventListener("pointerleave", onPointerLeave);
+		});
+	});
+	watchPostEffect(() => {
+		const el = floatingEl.value;
+		if (!el || !enabled.value) return;
+		el.addEventListener("pointerenter", onPointerEnterFloating);
+		el.addEventListener("pointerleave", onPointerLeave);
+		onWatcherCleanup(() => {
+			el.removeEventListener("pointerenter", onPointerEnterFloating);
+			el.removeEventListener("pointerleave", onPointerLeave);
+		});
+	});
+	tryOnScopeDispose(() => {
+		cleanupPolygon();
+	});
+}
+//#endregion
+//#region src/composables/utils/use-active-descendant.ts
+/**
+* Manages "Virtual Focus" (via aria-activedescendant) for a list of items.
+*
+* **Important:** All items in `listRef` MUST have an `id` attribute set in the template.
+* The composable will not auto-generate IDs to avoid hydration mismatches and re-render issues.
+*
+* @param anchorEl - The element that will receive the aria-activedescendant attribute
+* @param listRef - Array of list item elements (each must have an id attribute)
+* @param activeIndex - The currently active index in the list
+* @param options - Configuration options
+* @returns Object containing the activeItem ref
+*/
+function useActiveDescendant(anchorEl, listRef, activeIndex, options) {
+	const activeItem = ref(null);
+	watch([
+		() => toValue(options.virtual),
+		options.open,
+		() => toValue(activeIndex),
+		anchorEl,
+		listRef
+	], ([isVirtual, isOpen, idx], _oldValues, onCleanup) => {
+		const anchor = anchorEl.value;
+		onCleanup(() => {
+			anchor?.removeAttribute("aria-activedescendant");
+		});
+		if (!anchor || !isVirtual || !isOpen || idx == null) {
+			activeItem.value = null;
+			return;
+		}
+		const el = listRef.value[idx];
+		if (!el) {
+			activeItem.value = null;
+			return;
+		}
+		if (!el.id) {
+			if (import.meta.env.DEV) console.warn("[useActiveDescendant] List item at index", idx, "is missing an 'id' attribute. All list items must have stable IDs for proper accessibility.");
+			activeItem.value = null;
+			return;
+		}
+		anchor.setAttribute("aria-activedescendant", el.id);
+		activeItem.value = el;
+	}, { flush: "post" });
+	return { activeItem };
+}
+//#endregion
+//#region src/composables/interactions/list-navigation/strategies.ts
+function resolveLinearMove(current, dir, context) {
+	const { items, loop, allowEscape, isVirtual, findNextEnabled, getFirstEnabledIndex, getLastEnabledIndex } = context;
+	const itemCount = items.length;
+	let next = findNextEnabled(current == null ? dir === 1 ? 0 : itemCount - 1 : current + dir, dir, loop);
+	if (next == null && loop) {
+		if (allowEscape && isVirtual) return {
+			type: "navigate",
+			index: null
+		};
+		next = dir === 1 ? getFirstEnabledIndex() : getLastEnabledIndex();
+	}
+	if (next != null) return {
+		type: "navigate",
+		index: next
+	};
+	return null;
+}
+var VerticalNavigationStrategy = class {
+	handleKey(key, context) {
+		const { isRtl, nested } = context;
+		if (key === "ArrowDown") return resolveLinearMove(context.current, 1, context);
+		if (key === "ArrowUp") return resolveLinearMove(context.current, -1, context);
+		if (nested) {
+			if (key === (isRtl ? "ArrowRight" : "ArrowLeft")) return { type: "close" };
+		}
+		return null;
+	}
+};
+var HorizontalNavigationStrategy = class {
+	handleKey(key, context) {
+		const { isRtl, nested } = context;
+		if (key === "ArrowRight") return resolveLinearMove(context.current, isRtl ? -1 : 1, context);
+		if (key === "ArrowLeft") return resolveLinearMove(context.current, isRtl ? 1 : -1, context);
+		if (nested && key === "ArrowUp") return { type: "close" };
+		return null;
+	}
+};
+var GridNavigationStrategy = class {
+	constructor(fallbackToLinear = false, loopDirection = "row") {
+		this.fallbackToLinear = fallbackToLinear;
+		this.loopDirection = loopDirection;
+	}
+	handleKey(key, context) {
+		const { current, items, isDisabled, loop, allowEscape, isVirtual, getFirstEnabledIndex, getLastEnabledIndex, cols } = context;
+		if (key === "ArrowRight" || key === "ArrowLeft") {
+			const dir = key === "ArrowRight" ? 1 : -1;
+			if (current === null) return resolveLinearMove(current, dir, context);
+			const next = current + dir;
+			const currentRow = Math.floor(current / cols);
+			const nextRow = Math.floor(next / cols);
+			if (next >= 0 && next < items.length && currentRow === nextRow && !isDisabled(next)) return {
+				type: "navigate",
+				index: next
+			};
+			if (loop) {
+				if (allowEscape && isVirtual) {
+					const isAtStart = current === 0;
+					const isAtEnd = current === items.length - 1;
+					if (dir === -1 && isAtStart || dir === 1 && isAtEnd) return {
+						type: "navigate",
+						index: null
+					};
+				}
+				let wrapCandidate;
+				if (this.loopDirection === "next") {
+					wrapCandidate = dir === 1 ? current + 1 : current - 1;
+					if (wrapCandidate >= items.length) wrapCandidate = 0;
+					if (wrapCandidate < 0) wrapCandidate = items.length - 1;
+				} else wrapCandidate = dir === 1 ? currentRow * cols : Math.min((currentRow + 1) * cols - 1, items.length - 1);
+				if (this.loopDirection === "next") {
+					let candidate = wrapCandidate;
+					for (let i = 0; i < items.length; i++) {
+						if (!isDisabled(candidate)) return {
+							type: "navigate",
+							index: candidate
+						};
+						candidate += dir;
+						if (candidate >= items.length) candidate = 0;
+						if (candidate < 0) candidate = items.length - 1;
+						if (candidate === wrapCandidate) break;
+					}
+				} else {
+					const rowStart = currentRow * cols;
+					const rowEnd = Math.min((currentRow + 1) * cols - 1, items.length - 1);
+					while (wrapCandidate >= rowStart && wrapCandidate <= rowEnd) {
+						if (!isDisabled(wrapCandidate)) return {
+							type: "navigate",
+							index: wrapCandidate
+						};
+						wrapCandidate += dir;
+						if (wrapCandidate < rowStart || wrapCandidate > rowEnd) break;
+					}
+				}
+			}
+			return resolveLinearMove(current, dir, context);
+		}
+		if (key === "ArrowDown" || key === "ArrowUp") {
+			if (cols <= 1) return null;
+			const offset = key === "ArrowDown" ? cols : -cols;
+			const step = offset > 0 ? cols : -cols;
+			let candidate = (current == null ? offset > 0 ? -cols : items.length : current) + offset;
+			while (candidate >= 0 && candidate < items.length && isDisabled(candidate)) candidate += step;
+			if (candidate >= 0 && candidate < items.length) return {
+				type: "navigate",
+				index: candidate
+			};
+			if (loop) {
+				if (allowEscape && isVirtual) return {
+					type: "navigate",
+					index: null
+				};
+				if (current === null) {
+					const boundary = offset > 0 ? getFirstEnabledIndex() : getLastEnabledIndex();
+					return boundary != null ? {
+						type: "navigate",
+						index: boundary
+					} : null;
+				}
+				const col = current % cols;
+				let wrapCandidate;
+				if (offset > 0) wrapCandidate = col;
+				else {
+					wrapCandidate = (Math.ceil(items.length / cols) - 1) * cols + col;
+					if (wrapCandidate >= items.length) wrapCandidate -= cols;
+				}
+				while (wrapCandidate >= 0 && wrapCandidate < items.length && isDisabled(wrapCandidate)) wrapCandidate += step;
+				if (wrapCandidate >= 0 && wrapCandidate < items.length) return {
+					type: "navigate",
+					index: wrapCandidate
+				};
+			}
+			if (this.fallbackToLinear) return resolveLinearMove(current, key === "ArrowDown" ? 1 : -1, context);
+		}
+		return null;
+	}
+};
+function doSwitch(orientation, vertical, horizontal) {
+	switch (orientation) {
+		case "vertical": return vertical;
+		case "horizontal": return horizontal;
+		default: return vertical || horizontal;
+	}
+}
+function isMainOrientationKey(key, orientation) {
+	return doSwitch(orientation, key === "ArrowUp" || key === "ArrowDown", key === "ArrowLeft" || key === "ArrowRight");
+}
+function isMainOrientationToEndKey(key, orientation, isRtl) {
+	return doSwitch(orientation, key === "ArrowDown", isRtl ? key === "ArrowLeft" : key === "ArrowRight") || key === "Enter" || key === " " || key === "";
+}
+function createNavigationStrategy(orientation, cols, gridLoopDirection) {
+	if (orientation === "vertical") return new VerticalNavigationStrategy();
+	if (orientation === "horizontal") return cols > 1 ? new GridNavigationStrategy(false, gridLoopDirection) : new HorizontalNavigationStrategy();
+	return new GridNavigationStrategy(true, gridLoopDirection);
+}
+//#endregion
+//#region src/composables/interactions/use-list-navigation.ts
+function useListNavigation(context, options) {
+	const { refs, open, setOpen } = context;
+	const { listRef, activeIndex, onNavigate, enabled = true, loop = false, orientation = "vertical", disabledIndices, focusItemOnHover = true, openOnArrowKeyDown = true, scrollItemIntoView = true, selectedIndex = null, focusItemOnOpen = "auto", nested = false, rtl = false, virtual = false, virtualItemRef, cols = 1, allowEscape = false } = options;
+	const isEnabled = computed(() => toValue(enabled));
+	const anchorEl = computed(() => {
+		const el = refs.anchorEl.value;
+		if (el instanceof HTMLElement) return el;
+		if (el && "contextElement" in el && el.contextElement instanceof HTMLElement) return el.contextElement;
+		return null;
+	});
+	const floatingEl = computed(() => refs.floatingEl.value);
+	const isVirtual = computed(() => !!toValue(virtual));
+	const isRtl = computed(() => !!toValue(rtl));
+	const gridCols = computed(() => Math.max(1, Number(toValue(cols) ?? 1)));
+	const cleanupFns = [];
+	const registerCleanup = (fn) => {
+		cleanupFns.push(fn);
+		return fn;
+	};
+	const runCleanups = () => {
+		while (cleanupFns.length) cleanupFns.pop()?.();
+	};
+	const getActiveIndex = () => activeIndex !== void 0 ? toValue(activeIndex) : null;
+	const isDisabled = (idx) => {
+		if (!disabledIndices) return false;
+		return Array.isArray(disabledIndices) ? disabledIndices.includes(idx) : !!disabledIndices(idx);
+	};
+	const getFirstEnabledIndex = () => {
+		const items = listRef.value;
+		for (let i = 0; i < items.length; i++) if (items[i] && !isDisabled(i)) return i;
+		return null;
+	};
+	const getLastEnabledIndex = () => {
+		const items = listRef.value;
+		for (let i = items.length - 1; i >= 0; i--) if (items[i] && !isDisabled(i)) return i;
+		return null;
+	};
+	const findNextEnabled = (start, dir, wrap) => {
+		const items = listRef.value;
+		const len = items.length;
+		let i = start;
+		for (let step = 0; step < len; step++) {
+			if (i < 0 || i >= len) {
+				if (!wrap) return null;
+				i = (i + len) % len;
+			}
+			if (items[i] && !isDisabled(i)) return i;
+			i += dir;
+		}
+		return null;
+	};
+	const focusItem = (index, forceScroll = false) => {
+		if (index == null) return;
+		const el = listRef.value[index];
+		if (!el) return;
+		if (isVirtual.value) return;
+		el.focus({ preventScroll: true });
+		const opts = scrollItemIntoView;
+		if (!!opts && (forceScroll || isUsingKeyboard.value)) el.scrollIntoView?.(typeof opts === "boolean" ? {
+			block: "nearest",
+			inline: "nearest"
+		} : opts);
+	};
+	let lastKey = null;
+	const handleAnchorKeyDown = (e) => {
+		if (e.defaultPrevented) return;
+		const target = e.target;
+		if (target && isTypeableElement(target) && target !== anchorEl.value) return;
+		const key = e.key;
+		const ori = toValue(orientation);
+		lastKey = key;
+		if (open.value && isVirtual.value) {
+			handleFloatingKeyDown(e);
+			return;
+		}
+		if (!isMainOrientationKey(key, ori)) return;
+		if (open.value || !toValue(openOnArrowKeyDown)) return;
+		e.preventDefault();
+		setOpen(true, "keyboard-activate", e);
+		const initial = (selectedIndex !== void 0 ? toValue(selectedIndex) : null) ?? (isMainOrientationToEndKey(key, ori, isRtl.value) ? getFirstEnabledIndex() : getLastEnabledIndex());
+		if (initial != null) onNavigate?.(initial);
+	};
+	const handleFloatingKeyDown = (e) => {
+		if (e.defaultPrevented) return;
+		const key = e.key;
+		const ori = toValue(orientation);
+		const items = listRef.value;
+		if (!items.length) return;
+		if (!isVirtual.value) {
+			if (key === "Home") {
+				e.preventDefault();
+				const idx = getFirstEnabledIndex();
+				if (idx != null) onNavigate?.(idx);
+				return;
+			}
+			if (key === "End") {
+				e.preventDefault();
+				const idx = getLastEnabledIndex();
+				if (idx != null) onNavigate?.(idx);
+				return;
+			}
+		}
+		const strategy = createNavigationStrategy(ori, gridCols.value, toValue(options.gridLoopDirection) ?? "row");
+		const strategyContext = {
+			current: getActiveIndex(),
+			items,
+			isRtl: isRtl.value,
+			loop: !!toValue(loop),
+			allowEscape: !!toValue(allowEscape),
+			isVirtual: isVirtual.value,
+			cols: gridCols.value,
+			nested: !!toValue(nested),
+			isDisabled,
+			findNextEnabled,
+			getFirstEnabledIndex,
+			getLastEnabledIndex
+		};
+		const result = strategy.handleKey(key, strategyContext);
+		if (!result) return;
+		e.preventDefault();
+		if (result.type === "navigate") onNavigate?.(result.index);
+		else if (result.type === "close") setOpen(false, "programmatic", e);
+	};
+	registerCleanup(watch([open, computed(() => getActiveIndex())], ([isOpen, idx]) => {
+		if (!isEnabled.value || !isOpen || idx == null) return;
+		focusItem(idx);
+	}, { flush: "post" }));
+	registerCleanup(useEventListener(() => isEnabled.value ? anchorEl.value : null, "keydown", handleAnchorKeyDown));
+	registerCleanup(useEventListener(() => isEnabled.value ? floatingEl.value : null, "keydown", handleFloatingKeyDown));
+	registerCleanup(watchPostEffect(() => {
+		if (!isEnabled.value || !toValue(focusItemOnHover)) return;
+		const container = floatingEl.value;
+		if (!container) return;
+		let lastX = null;
+		let lastY = null;
+		const onMove = (evt) => {
+			if (lastX === evt.clientX && lastY === evt.clientY) return;
+			lastX = evt.clientX;
+			lastY = evt.clientY;
+			const target = evt.target;
+			if (!target) return;
+			const idx = findItemIndexFromTarget(target);
+			if (idx >= 0) onNavigate?.(idx);
+		};
+		container.addEventListener("mousemove", onMove);
+		onWatcherCleanup(() => container.removeEventListener("mousemove", onMove));
+	}));
+	const prevOpen = ref(false);
+	registerCleanup(watch(() => open.value, (isOpen) => {
+		if (!isEnabled.value) return;
+		if (isOpen && !prevOpen.value) {
+			const f = toValue(focusItemOnOpen);
+			if (f === true || f === "auto" && lastKey != null) {
+				const idx = (selectedIndex !== void 0 ? toValue(selectedIndex) : null) ?? (lastKey && isMainOrientationToEndKey(lastKey, toValue(orientation), isRtl.value) ? getFirstEnabledIndex() : getLastEnabledIndex());
+				if (idx != null) {
+					onNavigate?.(idx);
+					focusItem(idx, true);
+				}
+			}
+		}
+		prevOpen.value = isOpen;
+	}, {
+		flush: "post",
+		immediate: true
+	}));
+	const findItemIndexFromTarget = (target) => {
+		const items = listRef.value;
+		for (let i = 0; i < items.length; i++) {
+			const el = items[i];
+			if (el && (el === target || el.contains(target))) return i;
+		}
+		return -1;
+	};
+	const { activeItem } = useActiveDescendant(anchorEl, listRef, computed(() => getActiveIndex()), {
+		virtual,
+		open
+	});
+	if (virtualItemRef) registerCleanup(watch(activeItem, (item) => {
+		virtualItemRef.value = item;
+	}, { flush: "post" }));
+	return { cleanup: runCleanups };
+}
+//#endregion
+//#region src/composables/middlewares/arrow.ts
+/**
+* Positions an inner element of the floating element such that it is centered to the anchor element.
+*
+* This middleware is used to position arrow elements within floating elements.
+*
+* @param options - The arrow options including padding and element reference
+* @returns A middleware function for arrow positioning
+*/
+function arrow(options) {
+	return {
+		name: "arrow",
+		options,
+		fn(args) {
+			const element = toValue(options.element);
+			if (element == null) return {};
+			return arrow$1({
+				element,
+				padding: options.padding
+			}).fn(args);
+		}
+	};
+}
+//#endregion
+//#region src/core/floating-internals.ts
+const floatingInternals = /* @__PURE__ */ new WeakMap();
+function setFloatingInternals(target, internals) {
+	floatingInternals.set(target, internals);
+}
+function getFloatingInternals(target) {
+	return floatingInternals.get(target);
+}
+//#endregion
+//#region src/composables/positioning/use-arrow.ts
+function useArrow(contextOrArrow, contextOrOptions, maybeOptions = {}) {
+	const { context, arrowEl, options } = normalizeArrowArgs(contextOrArrow, contextOrOptions, maybeOptions);
+	const { refs } = context;
+	const { middlewareData, placement } = getFloatingPosition(context);
+	const { offset = "-4px" } = options;
+	watch(arrowEl, (element) => {
+		refs.setArrow(element);
+	}, { immediate: true });
+	getFloatingInternals(context)?.middlewareRegistry.register(computed(() => {
+		if (!arrowEl.value) return null;
+		return arrow({ element: arrowEl });
+	}));
+	const arrowX = computed(() => middlewareData.value.arrow?.x ?? 0);
+	const arrowY = computed(() => middlewareData.value.arrow?.y ?? 0);
+	return {
+		arrowX,
+		arrowY,
+		arrowStyles: computed(() => {
+			if (!(arrowEl.value || refs.arrowEl.value) || !middlewareData.value.arrow) return {};
+			const side = toValue(placement).split("-")[0];
+			if (side === "bottom") return {
+				"inset-inline-start": `${arrowX.value}px`,
+				"inset-block-start": offset
+			};
+			if (side === "top") return {
+				"inset-inline-start": `${arrowX.value}px`,
+				"inset-block-end": offset
+			};
+			if (side === "right") return {
+				"inset-block-start": `${arrowY.value}px`,
+				"inset-inline-start": offset
+			};
+			return {
+				"inset-block-start": `${arrowY.value}px`,
+				"inset-inline-end": offset
+			};
+		})
+	};
+}
+function normalizeArrowArgs(contextOrArrow, contextOrOptions, maybeOptions = {}) {
+	if (isFloatingContext(contextOrArrow)) {
+		const context = contextOrArrow;
+		const options = contextOrOptions ?? {};
+		if (!options.element) throw new Error("[useArrow] `options.element` is required when calling useArrow(context, options).");
+		getFloatingRefs(context);
+		return {
+			context,
+			arrowEl: options.element,
+			options
+		};
+	}
+	return {
+		context: contextOrOptions,
+		arrowEl: contextOrArrow,
+		options: maybeOptions
+	};
+}
+function isFloatingContext(value) {
+	return typeof value === "object" && value !== null && "refs" in value;
+}
+//#endregion
+//#region src/composables/positioning/client-point/tracking-strategies.ts
+var TrackingStrategy = class {
+	lastKnownCoordinates = null;
+	getCoordinatesForOpening() {
+		return this.lastKnownCoordinates;
+	}
+	onClose() {
+		this.lastKnownCoordinates = null;
+	}
+	reset() {
+		this.lastKnownCoordinates = null;
+	}
+};
+var FollowTracker = class extends TrackingStrategy {
+	name = "follow";
+	getRequiredEvents() {
+		return [
+			"pointerdown",
+			"pointermove",
+			"pointerenter"
+		];
+	}
+	process(event, context) {
+		const coordinates = event.coordinates;
+		this.lastKnownCoordinates = coordinates;
+		switch (event.type) {
+			case "pointerdown": return coordinates;
+			case "pointermove":
+				if (context.isOpen && isMouseLikePointerType(event.originalEvent.pointerType, true)) return coordinates;
+				return null;
+			case "pointerenter": return coordinates;
+			default: return null;
+		}
+	}
+};
+var StaticTracker = class extends TrackingStrategy {
+	name = "static";
+	triggerCoordinates = null;
+	getRequiredEvents() {
+		return ["pointerdown", "pointermove"];
+	}
+	process(event, context) {
+		const coordinates = event.coordinates;
+		this.lastKnownCoordinates = coordinates;
+		if (event.type === "pointerdown") {
+			this.triggerCoordinates = coordinates;
+			return context.isOpen ? coordinates : null;
+		}
+		return null;
+	}
+	getCoordinatesForOpening() {
+		if (this.triggerCoordinates) return this.triggerCoordinates;
+		return this.lastKnownCoordinates;
+	}
+	reset() {
+		super.reset();
+		this.triggerCoordinates = null;
+	}
+	onClose() {
+		this.triggerCoordinates = null;
+	}
+};
+//#endregion
+//#region src/composables/positioning/client-point/virtual-element-factory.ts
+var VirtualElementFactory = class VirtualElementFactory {
+	static DEFAULT_DIMENSIONS = {
+		width: 100,
+		height: 30
+	};
+	create(options) {
+		const config = this.buildConfiguration(options);
+		return {
+			contextElement: config.referenceElement || void 0,
+			getBoundingClientRect: () => this.buildBoundingRect(config)
+		};
+	}
+	buildConfiguration(options) {
+		return {
+			coordinates: options.coordinates,
+			referenceElement: options.referenceElement ?? null,
+			baselineCoordinates: options.baselineCoordinates ?? null,
+			axis: options.axis ?? "both"
+		};
+	}
+	buildBoundingRect(config) {
+		const referenceRect = this.getReferenceRect(config.referenceElement);
+		const position = this.resolvePosition(config, referenceRect);
+		const size = this.calculateSize(config.axis, referenceRect);
+		return this.buildDOMRect({
+			x: position.x,
+			y: position.y,
+			width: size.width,
+			height: size.height
+		});
+	}
+	getReferenceRect(element) {
+		if (element) try {
+			return element.getBoundingClientRect();
+		} catch (error) {
+			if (import.meta.env.DEV) console.warn("VirtualElementFactory: Failed to get element bounds", {
+				element,
+				error
+			});
+		}
+		return this.buildDOMRect({
+			x: 0,
+			y: 0,
+			width: VirtualElementFactory.DEFAULT_DIMENSIONS.width,
+			height: VirtualElementFactory.DEFAULT_DIMENSIONS.height
+		});
+	}
+	resolvePosition(config, referenceRect) {
+		return {
+			x: this.resolveAxisCoordinate({
+				current: config.coordinates.x,
+				baseline: config.baselineCoordinates?.x ?? null,
+				fallback: referenceRect.x,
+				isAxisEnabled: config.axis === "x" || config.axis === "both"
+			}),
+			y: this.resolveAxisCoordinate({
+				current: config.coordinates.y,
+				baseline: config.baselineCoordinates?.y ?? null,
+				fallback: referenceRect.y,
+				isAxisEnabled: config.axis === "y" || config.axis === "both"
+			})
+		};
+	}
+	resolveAxisCoordinate(sources) {
+		const { current, baseline, fallback, isAxisEnabled } = sources;
+		if (isAxisEnabled && current !== null) return current;
+		if (baseline !== null) return baseline;
+		return fallback;
+	}
+	calculateSize(axis, referenceRect) {
+		const ensurePositive = (value, fallback) => Math.max(0, value || fallback);
+		switch (axis) {
+			case "both": return {
+				width: 0,
+				height: 0
+			};
+			case "x": return {
+				width: ensurePositive(referenceRect.width, VirtualElementFactory.DEFAULT_DIMENSIONS.width),
+				height: 0
+			};
+			case "y": return {
+				width: 0,
+				height: ensurePositive(referenceRect.height, VirtualElementFactory.DEFAULT_DIMENSIONS.height)
+			};
+		}
+	}
+	buildDOMRect(rect) {
+		const { x, y, width, height } = rect;
+		const safeWidth = Math.max(0, width);
+		const safeHeight = Math.max(0, height);
+		return {
+			x,
+			y,
+			width: safeWidth,
+			height: safeHeight,
+			top: y,
+			right: x + safeWidth,
+			bottom: y + safeHeight,
+			left: x,
+			toJSON: () => ({
+				x,
+				y,
+				width: safeWidth,
+				height: safeHeight
+			})
+		};
+	}
+};
+//#endregion
+//#region src/composables/positioning/use-client-point.ts
+const sanitizeCoordinate = (value) => {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+};
+function useClientPoint(contextOrPointerTarget, contextOrOptions = {}, maybeOptions = {}) {
+	const { pointerTarget, context, options } = normalizeClientPointArgs(contextOrPointerTarget, contextOrOptions, maybeOptions);
+	const { open } = getFloatingState(context);
+	const refs = context.refs;
+	const update = "position" in context && context.position ? context.position.update : context.update;
+	const virtualElementFactory = new VirtualElementFactory();
+	const internalCoordinates = ref({
+		x: null,
+		y: null
+	});
+	const lockedCoordinates = ref(null);
+	const axis = computed(() => toValue(options.axis ?? "both"));
+	const enabled = computed(() => toValue(options.enabled ?? true));
+	const externalX = computed(() => sanitizeCoordinate(toValue(options.x ?? null)));
+	const externalY = computed(() => sanitizeCoordinate(toValue(options.y ?? null)));
+	const isExternallyControlled = computed(() => externalX.value !== null && externalY.value !== null);
+	const coordinates = computed(() => {
+		if (isExternallyControlled.value) return {
+			x: externalX.value,
+			y: externalY.value
+		};
+		return internalCoordinates.value;
+	});
+	const constrainedCoordinates = computed(() => {
+		const coords = coordinates.value;
+		switch (axis.value) {
+			case "x": return {
+				x: coords.x,
+				y: null
+			};
+			case "y": return {
+				x: null,
+				y: coords.y
+			};
+			case "both": return coords;
+		}
+	});
+	const trackingStrategy = createTrackingStrategy(options.trackingMode ?? "follow");
+	const setCoordinates = (x, y) => {
+		if (isExternallyControlled.value) return;
+		internalCoordinates.value = {
+			x: sanitizeCoordinate(x),
+			y: sanitizeCoordinate(y)
+		};
+	};
+	const resetCoordinates = () => {
+		if (!isExternallyControlled.value) internalCoordinates.value = {
+			x: null,
+			y: null
+		};
+	};
+	const processPointerEvent = (event, type) => {
+		const nextCoordinates = trackingStrategy.process({
+			type,
+			coordinates: {
+				x: event.clientX,
+				y: event.clientY
+			},
+			originalEvent: event
+		}, { isOpen: open.value });
+		if (nextCoordinates) setCoordinates(nextCoordinates.x, nextCoordinates.y);
+	};
+	watch([
+		constrainedCoordinates,
+		lockedCoordinates,
+		axis,
+		pointerTarget
+	], () => {
+		refs.anchorEl.value = virtualElementFactory.create({
+			coordinates: constrainedCoordinates.value,
+			referenceElement: pointerTarget.value,
+			baselineCoordinates: lockedCoordinates.value,
+			axis: axis.value
+		});
+		if (open.value) update?.();
+	}, { immediate: true });
+	watch(open, (isOpen) => {
+		if (!enabled.value || isExternallyControlled.value) return;
+		if (isOpen) {
+			const openingCoordinates = trackingStrategy.getCoordinatesForOpening();
+			if (openingCoordinates) {
+				setCoordinates(openingCoordinates.x, openingCoordinates.y);
+				lockedCoordinates.value = { ...openingCoordinates };
+			} else lockedCoordinates.value = { ...internalCoordinates.value };
+			return;
+		}
+		trackingStrategy.onClose();
+		resetCoordinates();
+		lockedCoordinates.value = null;
+	});
+	const handlers = {
+		pointerdown: (event) => processPointerEvent(event, "pointerdown"),
+		pointerenter: (event) => processPointerEvent(event, "pointerenter"),
+		pointermove: (event) => processPointerEvent(event, "pointermove")
+	};
+	watchEffect((onCleanup) => {
+		if (isExternallyControlled.value || !enabled.value) return;
+		const target = pointerTarget.value;
+		if (!target) return;
+		const requiredEvents = trackingStrategy.getRequiredEvents();
+		for (const eventType of requiredEvents) target.addEventListener(eventType, handlers[eventType]);
+		onCleanup(() => {
+			for (const eventType of requiredEvents) target.removeEventListener(eventType, handlers[eventType]);
+		});
+	});
+	return {
+		coordinates: readonly(constrainedCoordinates),
+		updatePosition: (x, y) => setCoordinates(x, y)
+	};
+}
+function createTrackingStrategy(trackingMode) {
+	return trackingMode === "follow" ? new FollowTracker() : new StaticTracker();
+}
+function normalizeClientPointArgs(contextOrPointerTarget, contextOrOptions, maybeOptions) {
+	if (isClientPointContext(contextOrPointerTarget)) {
+		const context = contextOrPointerTarget;
+		const options = contextOrOptions;
+		if (!options.pointerTarget) throw new Error("[useClientPoint] `options.pointerTarget` is required when calling useClientPoint(context, options).");
+		return {
+			context,
+			pointerTarget: options.pointerTarget,
+			options
+		};
+	}
+	return {
+		pointerTarget: contextOrPointerTarget,
+		context: contextOrOptions,
+		options: maybeOptions
+	};
+}
+function isClientPointContext(value) {
+	return typeof value === "object" && value !== null && "refs" in value;
+}
+//#endregion
+//#region src/core/elements.ts
+function createRefSetter(target) {
+	return (value) => {
+		target.value = value;
+	};
+}
+//#endregion
+//#region src/composables/positioning/internal/open-state.ts
+function createOpenStateController(options = {}) {
+	const open = options.open ?? ref(false);
+	const setOpen = (value, reason, event) => {
+		if (open.value === value) return;
+		open.value = value;
+		options.onOpenChange?.(value, reason ?? "programmatic", event);
+	};
+	return {
+		open,
+		setOpen
+	};
+}
+//#endregion
+//#region src/composables/positioning/internal/middleware-registry.ts
+function createMiddlewareRegistry(baseMiddlewares) {
+	const registrations = ref([]);
+	let nextRegistrationId = 0;
+	const middlewares = computed(() => {
+		const merged = [...toValue(baseMiddlewares) ?? []];
+		for (const registration of registrations.value) {
+			const middleware = toValue(registration.middleware);
+			if (!middleware) continue;
+			const existingIndex = merged.findIndex((candidate) => candidate.name === middleware.name);
+			if (existingIndex === -1) merged.push(middleware);
+			else merged[existingIndex] = middleware;
+		}
+		return merged;
+	});
+	const register = (middleware) => {
+		const registration = {
+			id: nextRegistrationId++,
+			middleware
+		};
+		registrations.value = [...registrations.value, registration];
+		const unregister = () => {
+			registrations.value = registrations.value.filter((candidate) => candidate.id !== registration.id);
+		};
+		tryOnScopeDispose(unregister);
+		return unregister;
+	};
+	return {
+		middlewares,
+		register
+	};
+}
+//#endregion
+//#region src/composables/positioning/internal/position-controller.ts
+function createPositionController(options) {
+	const { anchorEl, floatingEl, open, transform = true, middlewares = [], autoUpdate: autoUpdateOptions = true } = options;
+	const preferredPlacement = computed(() => toValue(options.placement) ?? "bottom");
+	const preferredStrategy = computed(() => toValue(options.strategy) ?? "absolute");
+	const middlewareRegistry = createMiddlewareRegistry(middlewares);
+	const x = ref(0);
+	const y = ref(0);
+	const placement = ref(preferredPlacement.value);
+	const strategy = ref(preferredStrategy.value);
+	const middlewareData = shallowRef({});
+	const isPositioned = ref(false);
+	const update = async () => {
+		if (!anchorEl.value || !floatingEl.value) return;
+		try {
+			const result = await computePosition(anchorEl.value, floatingEl.value, {
+				placement: preferredPlacement.value,
+				strategy: preferredStrategy.value,
+				middleware: middlewareRegistry.middlewares.value
+			});
+			x.value = result.x;
+			y.value = result.y;
+			placement.value = result.placement;
+			strategy.value = result.strategy;
+			middlewareData.value = result.middlewareData;
+			isPositioned.value = open.value;
+		} catch (error) {
+			if (import.meta.env.DEV) console.error("[useFloating] Failed to compute position:", error);
+		}
+	};
+	watch([
+		preferredPlacement,
+		preferredStrategy,
+		middlewareRegistry.middlewares
+	], () => {
+		if (open.value) update();
+	});
+	watch([
+		anchorEl,
+		floatingEl,
+		open
+	], ([currentAnchor, currentFloating, isOpen], _oldValue, onCleanup) => {
+		if (!isOpen || !currentAnchor || !currentFloating) return;
+		update();
+		if (!autoUpdateOptions) return;
+		onCleanup(autoUpdate(currentAnchor, currentFloating, update, typeof autoUpdateOptions === "object" ? autoUpdateOptions : void 0));
+	}, { immediate: true });
+	watch(open, (isOpen) => {
+		if (!isOpen) isPositioned.value = false;
+	});
+	const styles = computed(() => {
+		const floatingElement = floatingEl.value;
+		const baseStyles = {
+			position: strategy.value,
+			left: "0",
+			top: "0"
+		};
+		if (!floatingElement) return baseStyles;
+		const resolvedTransform = toValue(transform);
+		const roundedX = roundByDPR(floatingElement, x.value);
+		const roundedY = roundByDPR(floatingElement, y.value);
+		if (!resolvedTransform) return {
+			...baseStyles,
+			left: `${roundedX}px`,
+			top: `${roundedY}px`
+		};
+		return {
+			...baseStyles,
+			transform: `translate(${roundedX}px, ${roundedY}px)`,
+			...getDPR(floatingElement) >= 1.5 ? { "will-change": "transform" } : {}
+		};
+	});
+	tryOnScopeDispose(() => {
+		isPositioned.value = false;
+	});
+	return {
+		middlewareRegistry,
+		position: {
+			x,
+			y,
+			strategy,
+			placement,
+			middlewareData,
+			isPositioned,
+			styles,
+			update
+		}
+	};
+}
+function roundByDPR(el, value) {
+	const dpr = getDPR(el);
+	return Math.round(value * dpr) / dpr;
+}
+function getDPR(el) {
+	if (typeof window === "undefined") return 1;
+	return (el.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+//#endregion
+//#region src/composables/positioning/use-floating.ts
+function useFloating(anchorEl, floatingEl, options = {}) {
+	const stateController = createOpenStateController({
+		open: options.open,
+		onOpenChange: options.onOpenChange
+	});
+	const arrowEl = ref(null);
+	const refs = {
+		anchorEl,
+		floatingEl,
+		arrowEl,
+		setAnchor: createRefSetter(anchorEl),
+		setFloating: createRefSetter(floatingEl),
+		setArrow: createRefSetter(arrowEl)
+	};
+	const positionController = createPositionController({
+		anchorEl,
+		floatingEl,
+		open: stateController.open,
+		placement: options.placement,
+		strategy: options.strategy,
+		transform: options.transform,
+		middlewares: options.middlewares,
+		autoUpdate: options.autoUpdate
+	});
+	const state = {
+		open: stateController.open,
+		setOpen: stateController.setOpen
+	};
+	const position = {
+		x: positionController.position.x,
+		y: positionController.position.y,
+		strategy: positionController.position.strategy,
+		placement: positionController.position.placement,
+		middlewareData: positionController.position.middlewareData,
+		isPositioned: positionController.position.isPositioned,
+		styles: positionController.position.styles,
+		update: positionController.position.update
+	};
+	const context = {
+		refs,
+		state,
+		position,
+		open: state.open,
+		setOpen: state.setOpen,
+		x: position.x,
+		y: position.y,
+		strategy: position.strategy,
+		placement: position.placement,
+		middlewareData: position.middlewareData,
+		isPositioned: position.isPositioned,
+		floatingStyles: position.styles,
+		update: position.update
+	};
+	setFloatingInternals(context, { middlewareRegistry: positionController.middlewareRegistry });
+	return context;
+}
+//#endregion
+export { FollowTracker, StaticTracker, TrackingStrategy, VirtualElementFactory, arrow, autoPlacement, flip, hide, offset, shift, size, useArrow, useClick, useClientPoint, useEscapeKey, useFloating, useFocus, useFocusTrap, useHover, useListNavigation };
+
+//# sourceMappingURL=index.mjs.map