@proyecto-viviana/solidaria 0.4.2 → 0.6.0-rc.0

package/dist/_chunk/dom.jsx

@@ -0,0 +1,1200 @@
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/interactions/useFocusVisible.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+/*
+* Copyright 2024 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+/*
+* Copyright 2021 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+/*
+* Copyright 2025 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+/*
+* Copyright 2023 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/focus/FocusScope.tsx
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/interactions/usePress.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/utils/domHelpers.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/utils/getScrollParent.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/utils/getScrollParents.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/utils/isElementVisible.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/utils/isFocusable.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/utils/isScrollable.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/utils/keyboard.tsx
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/utils/openLink.tsx
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/utils/shadowdom/DOMFunctions.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+/*
+* Copyright 2022 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/interactions/utils.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/utils/chain.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/utils/isVirtualEvent.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the 'License');
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/interactions/focusSafely.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/interactions/utils.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/utils/focusWithoutScrolling.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/utils/platform.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/utils/runAfterTransition.ts
+import { r as isTestEnv } from "./env.jsx";
+import { createSignal, createTrackedEffect } from "solid-js";
+import { shadowDOM } from "@proyecto-viviana/solid-stately/private/flags/flags";
+import { isServer } from "@solidjs/web";
+//#region src/utils/platform.ts
+function getNavigator() {
+	if (typeof window === "undefined" || window.navigator == null) return null;
+	return window.navigator;
+}
+function testPlatform(re) {
+	const nav = getNavigator();
+	if (!nav) return false;
+	return re.test(nav.platform || nav.userAgentData?.platform || "");
+}
+function testUserAgent(re) {
+	const nav = getNavigator();
+	return nav ? re.test(nav.userAgent) : false;
+}
+function isMac() {
+	return testPlatform(/^Mac/i);
+}
+function isIPhone() {
+	return testPlatform(/^iPhone/i);
+}
+function isIPad() {
+	return testPlatform(/^iPad/i) || isMac() && navigator.maxTouchPoints > 1;
+}
+function isIOS() {
+	return isIPhone() || isIPad();
+}
+function isAppleDevice() {
+	return isMac() || isIOS();
+}
+function isWebKit() {
+	return testUserAgent(/AppleWebKit/i) && !isChrome();
+}
+function isChrome() {
+	return testUserAgent(/Chrome/i);
+}
+function isAndroid() {
+	return testUserAgent(/Android/i);
+}
+function isFirefox() {
+	return testUserAgent(/Firefox/i);
+}
+//#endregion
+//#region src/utils/events.ts
+/**
+* Event utilities for detecting virtual clicks and event handling.
+* Based on these pinned React Aria sources:
+* - packages/react-aria/src/utils/isVirtualEvent.ts
+* - packages/react-aria/src/utils/chain.ts
+* - packages/react-aria/src/interactions/utils.ts
+*
+* createMouseEvent is a local event adapter.
+*/
+/**
+* Checks if a click event was generated from a virtual source like a screen reader.
+* Virtual clicks typically have detail of 0 and may have zero coordinates.
+*/
+function isVirtualClick(event) {
+	if (event.pointerType === "" && event.isTrusted) return true;
+	if (isAndroid() && event.pointerType) return event.type === "click" && event.buttons === 1;
+	return event.detail === 0 && !event.pointerType;
+}
+/**
+* Checks if a pointer event was generated by a virtual source.
+* iOS VoiceOver fires pointer events with incorrect coordinates.
+* These events have zero width/height.
+*/
+function isVirtualPointerEvent(event) {
+	return !isAndroid() && event.width === 0 && event.height === 0 || isAndroid() && event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "mouse";
+}
+/**
+* Creates a synthetic mouse event for programmatic clicking.
+*/
+function createMouseEvent(type, nativeEvent) {
+	const init = {
+		bubbles: true,
+		cancelable: true,
+		view: window
+	};
+	if (nativeEvent) {
+		const e = nativeEvent;
+		init.screenX = e.screenX;
+		init.screenY = e.screenY;
+		init.clientX = e.clientX;
+		init.clientY = e.clientY;
+		init.ctrlKey = e.ctrlKey;
+		init.shiftKey = e.shiftKey;
+		init.altKey = e.altKey;
+		init.metaKey = e.metaKey;
+		init.button = e.button;
+		init.buttons = e.buttons;
+		init.relatedTarget = e.relatedTarget;
+	}
+	return new MouseEvent(type, init);
+}
+/**
+* Creates a chain of event handlers that calls each in sequence.
+*/
+function chain(...callbacks) {
+	return ((...args) => {
+		for (const callback of callbacks) if (typeof callback === "function") callback(...args);
+	});
+}
+/**
+* Sets the target property on an event object.
+* Used for synthetic events where target needs to be modified.
+*/
+function setEventTarget(event, target) {
+	Object.defineProperty(event, "target", {
+		value: target,
+		writable: false,
+		configurable: true
+	});
+	Object.defineProperty(event, "currentTarget", {
+		value: target,
+		writable: false,
+		configurable: true
+	});
+}
+//#endregion
+//#region src/interactions/createInteractionModality.ts
+/**
+* createInteractionModality + focus-visible tracking for solidaria
+*
+* Port of @react-aria/interactions useFocusVisible/useInteractionModality.
+* Tracks the current interaction modality (keyboard, pointer, or virtual) and
+* provides focus-visible state and listeners.
+*/
+let currentModalityValue = null;
+const [modalityEpoch, bumpModalityEpoch] = createSignal(0, { ownedWrite: true });
+let currentPointerType = "keyboard";
+function writeModality(next) {
+	currentModalityValue = next;
+}
+function publishModality(next) {
+	currentModalityValue = next;
+	bumpModalityEpoch((n) => n + 1);
+}
+const changeHandlers = /* @__PURE__ */ new Set();
+let hasSetupGlobalListeners = /* @__PURE__ */ new Map();
+let hasEventBeforeFocus = false;
+let hasBlurredWindowRecently = false;
+/** @private Set by `preventFocus` so programmatic refocus is not treated as a modality change. */
+let ignoreFocusEvent = false;
+/** @private */
+function setIgnoreFocusEvent(value) {
+	ignoreFocusEvent = value;
+}
+const FOCUS_VISIBLE_INPUT_KEYS = {
+	Tab: true,
+	Escape: true
+};
+function triggerChangeHandlers(modality, e) {
+	for (const handler of changeHandlers) handler(modality, e);
+}
+function isValidKey(e) {
+	return !(e.metaKey || !isMac() && e.altKey || e.ctrlKey || e.key === "Control" || e.key === "Shift" || e.key === "Meta");
+}
+function handleKeyboardEvent(e) {
+	hasEventBeforeFocus = true;
+	if (!openLink.isOpening && isValidKey(e)) {
+		publishModality("keyboard");
+		currentPointerType = "keyboard";
+		triggerChangeHandlers("keyboard", e);
+	}
+}
+function handlePointerEvent(e) {
+	currentPointerType = "pointerType" in e ? e.pointerType : "mouse";
+	if (e.type === "mousedown" || e.type === "pointerdown") {
+		publishModality("pointer");
+		hasEventBeforeFocus = true;
+		triggerChangeHandlers("pointer", e);
+	} else writeModality("pointer");
+}
+function handleClickEvent(e) {
+	if (!openLink.isOpening && isVirtualClick(e)) {
+		hasEventBeforeFocus = true;
+		publishModality("virtual");
+		currentPointerType = "virtual";
+	}
+}
+function handleFocusEvent(e) {
+	if (ignoreFocusEvent) return;
+	const target = getEventTarget(e);
+	const ownerWindow = getOwnerWindow(target);
+	const ownerDocument = getOwnerDocument(target);
+	if (target === ownerWindow) {
+		hasBlurredWindowRecently = true;
+		return;
+	}
+	if (target === ownerDocument || !e.isTrusted) return;
+	if (!hasEventBeforeFocus && !hasBlurredWindowRecently) {
+		publishModality("virtual");
+		currentPointerType = "virtual";
+		triggerChangeHandlers("virtual", e);
+	}
+	hasEventBeforeFocus = false;
+	hasBlurredWindowRecently = false;
+}
+function handleWindowBlur() {
+	if (ignoreFocusEvent) return;
+	hasEventBeforeFocus = false;
+	hasBlurredWindowRecently = true;
+}
+function setupGlobalFocusEvents(element) {
+	if (typeof window === "undefined" || typeof document === "undefined") return;
+	const windowObject = getOwnerWindow(element);
+	if (hasSetupGlobalListeners.get(windowObject)) return;
+	const documentObject = getOwnerDocument(element);
+	const originalFocus = windowObject.HTMLElement.prototype.focus;
+	Reflect.defineProperty(windowObject.HTMLElement.prototype, "focus", {
+		configurable: true,
+		writable: true,
+		value: function() {
+			hasEventBeforeFocus = true;
+			originalFocus.apply(this, arguments);
+		}
+	});
+	documentObject.addEventListener("keydown", handleKeyboardEvent, true);
+	documentObject.addEventListener("keyup", handleKeyboardEvent, true);
+	documentObject.addEventListener("click", handleClickEvent, true);
+	windowObject.addEventListener("focus", handleFocusEvent, true);
+	windowObject.addEventListener("blur", handleWindowBlur, false);
+	if (typeof windowObject.PointerEvent !== "undefined") {
+		documentObject.addEventListener("pointerdown", handlePointerEvent, true);
+		documentObject.addEventListener("pointermove", handlePointerEvent, true);
+		documentObject.addEventListener("pointerup", handlePointerEvent, true);
+	} else {
+		documentObject.addEventListener("mousedown", handlePointerEvent, true);
+		documentObject.addEventListener("mousemove", handlePointerEvent, true);
+		documentObject.addEventListener("mouseup", handlePointerEvent, true);
+	}
+	windowObject.addEventListener("beforeunload", () => {
+		tearDownWindowFocusTracking(element);
+	}, { once: true });
+	hasSetupGlobalListeners.set(windowObject, { focus: originalFocus });
+}
+function tearDownWindowFocusTracking(element, loadListener) {
+	if (typeof window === "undefined" || typeof document === "undefined") return;
+	const windowObject = getOwnerWindow(element);
+	const documentObject = getOwnerDocument(element);
+	if (loadListener) documentObject.removeEventListener("DOMContentLoaded", loadListener);
+	if (!hasSetupGlobalListeners.has(windowObject)) return;
+	const entry = hasSetupGlobalListeners.get(windowObject);
+	Reflect.defineProperty(windowObject.HTMLElement.prototype, "focus", {
+		configurable: true,
+		writable: true,
+		value: entry.focus
+	});
+	documentObject.removeEventListener("keydown", handleKeyboardEvent, true);
+	documentObject.removeEventListener("keyup", handleKeyboardEvent, true);
+	documentObject.removeEventListener("click", handleClickEvent, true);
+	windowObject.removeEventListener("focus", handleFocusEvent, true);
+	windowObject.removeEventListener("blur", handleWindowBlur, false);
+	if (typeof windowObject.PointerEvent !== "undefined") {
+		documentObject.removeEventListener("pointerdown", handlePointerEvent, true);
+		documentObject.removeEventListener("pointermove", handlePointerEvent, true);
+		documentObject.removeEventListener("pointerup", handlePointerEvent, true);
+	} else {
+		documentObject.removeEventListener("mousedown", handlePointerEvent, true);
+		documentObject.removeEventListener("mousemove", handlePointerEvent, true);
+		documentObject.removeEventListener("mouseup", handlePointerEvent, true);
+	}
+	hasSetupGlobalListeners.delete(windowObject);
+}
+/**
+* Adds a window (i.e. iframe) to the list of windows that are being tracked for focus visible.
+*/
+function addWindowFocusTracking(element) {
+	const documentObject = getOwnerDocument(element);
+	let loadListener;
+	if (documentObject.readyState !== "loading") setupGlobalFocusEvents(element);
+	else {
+		loadListener = () => {
+			setupGlobalFocusEvents(element);
+		};
+		documentObject.addEventListener("DOMContentLoaded", loadListener);
+	}
+	return () => tearDownWindowFocusTracking(element, loadListener);
+}
+function setupGlobalFocusListeners() {
+	addWindowFocusTracking();
+}
+if (typeof document !== "undefined") addWindowFocusTracking();
+function focusVisibleSnapshot() {
+	return currentModalityValue !== "pointer";
+}
+/**
+* If true, keyboard focus is visible. The only tracked read of modality:
+* useOption's render predicate re-reads this on every render.
+*/
+function isFocusVisible() {
+	modalityEpoch();
+	return focusVisibleSnapshot();
+}
+/**
+* Gets the current interaction modality.
+* The module let, not the signal. An effect that calls this does not re-run
+* when modality changes; upstream's query is a plain variable.
+*/
+function getInteractionModality() {
+	return currentModalityValue;
+}
+/**
+* Sets the current interaction modality.
+*/
+function setInteractionModality(modality) {
+	publishModality(modality);
+	currentPointerType = modality === "pointer" ? "mouse" : modality;
+	triggerChangeHandlers(modality, null);
+}
+/**
+* Gets the current pointer type. Separate from modality; this let is never
+* the modality signal.
+*/
+function getPointerType() {
+	return currentPointerType;
+}
+function isKeyboardFocusEvent(isTextInput, modality, e) {
+	if (!e) return true;
+	const target = "target" in e ? e.target : null;
+	const ownerDocument = target ? getOwnerDocument(target) : document;
+	const ownerWindow = target ? getOwnerWindow(target) : window;
+	const IHTMLInputElement = ownerWindow.HTMLInputElement;
+	const IHTMLTextAreaElement = ownerWindow.HTMLTextAreaElement;
+	const IHTMLElement = ownerWindow.HTMLElement;
+	const IKeyboardEvent = ownerWindow.KeyboardEvent;
+	const nonTextInputTypes = /* @__PURE__ */ new Set([
+		"checkbox",
+		"radio",
+		"range",
+		"color",
+		"file",
+		"image",
+		"button",
+		"submit",
+		"reset"
+	]);
+	isTextInput = isTextInput || ownerDocument.activeElement instanceof IHTMLInputElement && !nonTextInputTypes.has(ownerDocument.activeElement.type) || ownerDocument.activeElement instanceof IHTMLTextAreaElement || ownerDocument.activeElement instanceof IHTMLElement && ownerDocument.activeElement.isContentEditable;
+	return !(isTextInput && modality === "keyboard" && e instanceof IKeyboardEvent && !FOCUS_VISIBLE_INPUT_KEYS[e.key]);
+}
+/**
+* Listens for trigger change and reports if focus is visible.
+*/
+function createFocusVisibleListener(handler, opts) {
+	setupGlobalFocusEvents();
+	if (opts?.enabled === false) return () => {};
+	const listener = (modality, e) => {
+		if (!isKeyboardFocusEvent(!!opts?.isTextInput, modality, e)) return;
+		handler(focusVisibleSnapshot());
+	};
+	changeHandlers.add(listener);
+	return () => {
+		changeHandlers.delete(listener);
+	};
+}
+/**
+* Manages focus visible state for the page.
+*/
+function createFocusVisible(props = {}) {
+	const [isVisible, setIsVisible] = createSignal(isServer ? false : props.autoFocus || focusVisibleSnapshot());
+	createTrackedEffect(() => {
+		const _s2Cleanups = [];
+		const cleanup = createFocusVisibleListener(setIsVisible, { isTextInput: props.isTextInput });
+		_s2Cleanups.push(cleanup);
+		return () => {
+			for (const c of _s2Cleanups) c();
+		};
+	});
+	return { isFocusVisible: isVisible };
+}
+/**
+* Tracks the current interaction modality.
+*/
+function createInteractionModality() {
+	const [modality, setModality] = createSignal(isServer ? null : currentModalityValue);
+	createTrackedEffect(() => {
+		if (isServer) return;
+		const _s2Cleanups = [];
+		setupGlobalFocusEvents();
+		const handler = (newModality) => {
+			setModality(newModality);
+		};
+		changeHandlers.add(handler);
+		_s2Cleanups.push(() => {
+			changeHandlers.delete(handler);
+		});
+		return () => {
+			for (const c of _s2Cleanups) c();
+		};
+	});
+	return { modality };
+}
+/**
+* Adds a listener for modality changes.
+*/
+function addModalityListener(handler) {
+	const wrapped = (modality) => {
+		handler(modality);
+	};
+	changeHandlers.add(wrapped);
+	return () => {
+		changeHandlers.delete(wrapped);
+	};
+}
+/**
+* Hook to track whether the user is currently interacting with the keyboard.
+*/
+function useIsKeyboardFocused() {
+	const { modality } = createInteractionModality();
+	return () => modality() === "keyboard";
+}
+//#endregion
+//#region src/utils/runAfterTransition.ts
+/**
+* Run a callback after in-flight CSS transitions end.
+* Ported from packages/react-aria/src/utils/runAfterTransition.ts.
+*
+* Track properties per element rather than a count: Chrome can fire both
+* transitionend and transitioncancel for the same property.
+*/
+const transitionsByElement = /* @__PURE__ */ new Map();
+const transitionCallbacks = /* @__PURE__ */ new Set();
+function setupGlobalEvents() {
+	if (typeof window === "undefined" || typeof document === "undefined" || !document.body) return;
+	function isTransitionEvent(event) {
+		return "propertyName" in event;
+	}
+	const onTransitionStart = (e) => {
+		const eventTarget = getEventTarget(e);
+		if (!isTransitionEvent(e) || !eventTarget) return;
+		let transitions = transitionsByElement.get(eventTarget);
+		if (!transitions) {
+			transitions = /* @__PURE__ */ new Set();
+			transitionsByElement.set(eventTarget, transitions);
+			eventTarget.addEventListener("transitioncancel", onTransitionEnd, { once: true });
+		}
+		transitions.add(e.propertyName);
+	};
+	const onTransitionEnd = (e) => {
+		const eventTarget = getEventTarget(e);
+		if (!isTransitionEvent(e) || !eventTarget) return;
+		const properties = transitionsByElement.get(eventTarget);
+		if (!properties) return;
+		properties.delete(e.propertyName);
+		if (properties.size === 0) {
+			eventTarget.removeEventListener("transitioncancel", onTransitionEnd);
+			transitionsByElement.delete(eventTarget);
+		}
+		if (transitionsByElement.size === 0) {
+			for (const cb of transitionCallbacks) cb();
+			transitionCallbacks.clear();
+		}
+	};
+	document.body.addEventListener("transitionrun", onTransitionStart);
+	document.body.addEventListener("transitionend", onTransitionEnd);
+}
+if (typeof document !== "undefined") {
+	if (document.readyState !== "loading") setupGlobalEvents();
+	else document.addEventListener("DOMContentLoaded", setupGlobalEvents);
+}
+function cleanupDetachedElements() {
+	for (const [eventTarget] of transitionsByElement) if ("isConnected" in eventTarget && !eventTarget.isConnected) transitionsByElement.delete(eventTarget);
+}
+function runAfterTransition(fn) {
+	const win = typeof window !== "undefined" ? window : void 0;
+	if (!win || typeof win.requestAnimationFrame !== "function") {
+		fn();
+		return;
+	}
+	win.requestAnimationFrame(() => {
+		cleanupDetachedElements();
+		if (transitionsByElement.size === 0) fn();
+		else transitionCallbacks.add(fn);
+	});
+}
+//#endregion
+//#region src/utils/focus.ts
+/**
+* Focus management utilities.
+* Based on these pinned React Aria sources:
+* - packages/react-aria/src/utils/focusWithoutScrolling.ts
+* - packages/react-aria/src/interactions/utils.ts
+* - packages/react-aria/src/interactions/focusSafely.ts
+*
+* runAfterPaint and the focusVisible option are local Solid adapters.
+*/
+/**
+* Focuses an element without scrolling the page.
+* Uses preventScroll option with fallback for older browsers.
+*/
+function focusWithoutScrolling(element, options) {
+	if (!element) return;
+	const focusOptions = {
+		preventScroll: true,
+		...options
+	};
+	try {
+		element.focus(focusOptions);
+	} catch {
+		const scrollPositions = getScrollableAncestors(element).map((el) => ({
+			element: el,
+			scrollTop: el.scrollTop,
+			scrollLeft: el.scrollLeft
+		}));
+		element.focus(options);
+		for (const { element: el, scrollTop, scrollLeft } of scrollPositions) {
+			el.scrollTop = scrollTop;
+			el.scrollLeft = scrollLeft;
+		}
+	}
+}
+/**
+* Gets all scrollable ancestors of an element.
+*/
+function getScrollableAncestors(element) {
+	const ancestors = [];
+	let parent = element.parentElement;
+	while (parent) {
+		const style = getComputedStyle(parent);
+		const overflowY = style.overflowY;
+		const overflowX = style.overflowX;
+		if (overflowY === "auto" || overflowY === "scroll" || overflowX === "auto" || overflowX === "scroll") ancestors.push(parent);
+		parent = parent.parentElement;
+	}
+	const doc = getOwnerDocument(element);
+	ancestors.push(doc.documentElement);
+	return ancestors;
+}
+/**
+* Run `fn` after paint. Mirrors React `useEffect` relative to `preventFocus`,
+* which holds focus with capture listeners until the next animation frame.
+* Overlay auto-focus that runs in the same flush as the opening click is yanked
+* back onto the trigger; this delay is the Solid equivalent of upstream's
+* `useEffect` auto-focus.
+*/
+function runAfterPaint(fn, doc) {
+	const ownerDoc = doc ?? (typeof document !== "undefined" ? document : void 0);
+	const win = ownerDoc ? ownerDoc.defaultView ?? void 0 : typeof window !== "undefined" ? window : void 0;
+	if (!win) {
+		fn();
+		return () => {};
+	}
+	let timeoutId;
+	let cancelled = false;
+	const run = () => {
+		if (cancelled) return;
+		fn();
+	};
+	const scheduleTimeout = () => {
+		if (cancelled) return;
+		timeoutId = win.setTimeout(run, 0);
+	};
+	let frameId;
+	if (typeof win.requestAnimationFrame === "function") frameId = win.requestAnimationFrame(scheduleTimeout);
+	else scheduleTimeout();
+	return () => {
+		cancelled = true;
+		if (frameId != null) win.cancelAnimationFrame(frameId);
+		if (timeoutId !== void 0) win.clearTimeout(timeoutId);
+	};
+}
+/**
+* Prevents focus from moving to a new element temporarily.
+* Used when clicking on a button that shouldn't steal focus.
+*/
+function preventFocus(target) {
+	while (target && !isFocusable(target, { skipVisibilityCheck: true })) target = target.parentElement;
+	const ownerWindow = getOwnerWindow(target);
+	const activeElement = getActiveElement(ownerWindow.document);
+	if (!activeElement || activeElement === target) return;
+	const targetRoot = target?.getRootNode();
+	const root = targetRoot != null && isShadowRoot(targetRoot) ? targetRoot : ownerWindow;
+	const isFocusMovingToTarget = (focusTarget) => focusTarget === target || focusTarget != null && nodeContains(target, focusTarget);
+	const isBlurFromActiveElement = (eventTarget) => eventTarget === activeElement || activeElement != null && eventTarget != null && nodeContains(activeElement, eventTarget);
+	setIgnoreFocusEvent(true);
+	let isRefocusing = false;
+	const onBlur = (e) => {
+		if (isBlurFromActiveElement(getEventTarget(e)) || isRefocusing) e.stopImmediatePropagation();
+	};
+	const onFocusOut = (e) => {
+		if (isBlurFromActiveElement(getEventTarget(e)) || isRefocusing) {
+			e.stopImmediatePropagation();
+			if (!target && !isRefocusing) {
+				isRefocusing = true;
+				focusWithoutScrolling(activeElement);
+				cleanup();
+			}
+		}
+	};
+	const onFocus = (e) => {
+		if (isFocusMovingToTarget(getEventTarget(e)) || isRefocusing) e.stopImmediatePropagation();
+	};
+	const onFocusIn = (e) => {
+		if (isFocusMovingToTarget(getEventTarget(e)) || isRefocusing) {
+			e.stopImmediatePropagation();
+			if (!isRefocusing) {
+				isRefocusing = true;
+				focusWithoutScrolling(activeElement);
+				cleanup();
+			}
+		}
+	};
+	root.addEventListener("blur", onBlur, true);
+	root.addEventListener("focusout", onFocusOut, true);
+	root.addEventListener("focusin", onFocusIn, true);
+	root.addEventListener("focus", onFocus, true);
+	const raf = ownerWindow.requestAnimationFrame(cleanup);
+	function cleanup() {
+		ownerWindow.cancelAnimationFrame(raf);
+		root.removeEventListener("blur", onBlur, true);
+		root.removeEventListener("focusout", onFocusOut, true);
+		root.removeEventListener("focusin", onFocusIn, true);
+		root.removeEventListener("focus", onFocus, true);
+		setIgnoreFocusEvent(false);
+		isRefocusing = false;
+	}
+	return cleanup;
+}
+/**
+* Focus an element while avoiding page scroll and VoiceOver/iOS transition
+* side effects. Port of @react-aria/interactions focusSafely: virtual-modality
+* focus waits until in-flight CSS transitions end so contain-restore after a
+* programmatic focus (Playwright `.focus()`, screen readers) does not beat a
+* following pointermove.
+*/
+function focusSafely(element, options) {
+	if (!element?.isConnected) return;
+	const ownerDocument = getOwnerDocument(element);
+	if (getInteractionModality() === "virtual") {
+		const lastFocusedElement = getActiveElement(ownerDocument);
+		runAfterTransition(() => {
+			const activeElement = getActiveElement(ownerDocument);
+			if ((activeElement === lastFocusedElement || activeElement === ownerDocument.body) && element.isConnected) focusWithoutScrolling(element, options);
+		});
+	} else focusWithoutScrolling(element, options);
+}
+//#endregion
+//#region src/utils/dom.ts
+/**
+* DOM utilities for cross-browser compatibility.
+* Based on these pinned React Aria sources:
+* - packages/react-aria/src/utils/domHelpers.ts
+* - packages/react-aria/src/utils/shadowdom/DOMFunctions.ts
+* - packages/react-aria/src/utils/isElementVisible.ts
+* - packages/react-aria/src/utils/isFocusable.ts
+* - packages/react-aria/src/interactions/usePress.ts
+* - packages/react-aria/src/utils/openLink.tsx
+* - packages/react-aria/src/utils/isScrollable.ts
+* - packages/react-aria/src/utils/getScrollParent.ts
+* - packages/react-aria/src/utils/getScrollParents.ts
+* - packages/react-aria/src/utils/keyboard.tsx
+* - packages/react-aria/src/focus/FocusScope.tsx
+*/
+/**
+* Gets the owner document of an element, or the global document.
+* Accepts Window / Document / Node so window-target focus events resolve correctly.
+*/
+function getOwnerDocument(target) {
+	if (isWindow(target)) return target.document;
+	if (isDocument(target)) return target;
+	return target?.ownerDocument ?? document;
+}
+/**
+* Gets the owner window of an element, or the global window.
+*/
+function getOwnerWindow(target) {
+	return getOwnerDocument(target)?.defaultView ?? window;
+}
+function isNode(value) {
+	return value !== null && typeof value === "object" && "nodeType" in value && typeof value.nodeType === "number";
+}
+function isWindow(value) {
+	return typeof value === "object" && value != null && "window" in value && value.window === value;
+}
+function isDocument(value) {
+	return isNode(value) && value.nodeType === 9;
+}
+/**
+* Type guard that checks if a value is a ShadowRoot.
+*/
+function isShadowRoot(value) {
+	return isNode(value) && value.nodeType === 11 && "host" in value;
+}
+/**
+* Attaches an event listener on target(s) and returns a cleanup function.
+* Mirrors @react-aria/utils `addEvent`.
+*/
+function addEvent(target, event, listener, options) {
+	if (listener == null || target == null) return () => {};
+	const eventTargets = Array.isArray(target) ? target : [target];
+	for (const eventTarget of eventTargets) eventTarget.addEventListener(event, listener, options);
+	return () => {
+		for (const eventTarget of eventTargets) eventTarget.removeEventListener(event, listener, options);
+	};
+}
+/**
+* Returns the set of event targets a listener must be attached to in order to
+* globally observe an event.
+*
+* @param from - The target element to start from.
+* @param to - The element to stop at when bubbling. @default getOwnerWindow(from)
+*   `to` is generally going to be either `document` or `window`, but
+*   it can be any intermediate node.
+* @returns [global, ...shadowRoots]
+*/
+function getPropagationTargets(from, to) {
+	if (to === null) return [];
+	to = to ?? getOwnerWindow(from);
+	const targets = [to];
+	if (!shadowDOM() || !from || from === to) return targets;
+	if (!("getRootNode" in from) || typeof from.getRootNode !== "function") return targets;
+	const toRoot = "getRootNode" in to ? to.getRootNode() : null;
+	let current = from.getRootNode() ?? null;
+	while (isShadowRoot(current) && current !== toRoot) {
+		targets.push(current);
+		current = current.host.getRootNode();
+	}
+	return targets;
+}
+/**
+* Sets a CSS property on an element and returns a cleanup function.
+* Property names are kebab-case (`scrollbar-gutter`, `padding-right`), matching
+* @react-aria/utils `setStyle` which uses `style.setProperty`.
+*/
+function setStyle(target, property, value, priority) {
+	if (target == null) return () => {};
+	const restore = [];
+	const styleTargets = Array.isArray(target) ? target : [target];
+	for (const styleTarget of styleTargets) {
+		const initialValue = styleTarget.style.getPropertyValue(property);
+		const initialPriority = styleTarget.style.getPropertyPriority(property);
+		styleTarget.style.setProperty(property, value, priority);
+		restore.unshift(() => {
+			if (initialValue) styleTarget.style.setProperty(property, initialValue, initialPriority);
+			else styleTarget.style.removeProperty(property);
+		});
+	}
+	return () => {
+		for (const cleanup of restore) cleanup();
+	};
+}
+/**
+* Cross-browser implementation of Node.contains that works with ShadowDOM.
+* In Safari, Node.contains doesn't properly detect elements inside shadow roots.
+*/
+function nodeContains(parent, child) {
+	if (!parent || !child) return false;
+	let node = child;
+	while (node) {
+		if (node === parent) return true;
+		if (typeof node.assignedElements !== "function" && node.assignedSlot?.parentNode) node = node.assignedSlot.parentNode;
+		else if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE && node.host) node = node.host;
+		else node = node.parentNode;
+	}
+	return false;
+}
+/**
+* Gets the event target, handling composed path for shadow DOM.
+*/
+function getEventTarget(event) {
+	if (typeof event.composedPath === "function") {
+		const path = event.composedPath();
+		if (path.length > 0) return path[0];
+	}
+	return event.target;
+}
+const supportsCheckVisibility = typeof Element !== "undefined" && "checkVisibility" in Element.prototype;
+function isHTMLOrSVGElement(element) {
+	const windowObject = getOwnerWindow(element);
+	return element instanceof windowObject.HTMLElement || element instanceof windowObject.SVGElement || typeof HTMLElement !== "undefined" && element instanceof HTMLElement || typeof SVGElement !== "undefined" && element instanceof SVGElement;
+}
+function isStyleVisible(element) {
+	if (!isHTMLOrSVGElement(element)) return false;
+	const { display, visibility } = element.style;
+	let isVisible = display !== "none" && visibility !== "hidden" && visibility !== "collapse";
+	if (isVisible) {
+		const { getComputedStyle } = getOwnerWindow(element);
+		const { display: computedDisplay, visibility: computedVisibility } = getComputedStyle(element);
+		isVisible = computedDisplay !== "none" && computedVisibility !== "hidden" && computedVisibility !== "collapse";
+	}
+	return isVisible;
+}
+function isAttributeVisible(element, childElement) {
+	return !element.hasAttribute("hidden") && !element.hasAttribute("data-react-aria-prevent-focus") && (element.nodeName === "DETAILS" && childElement && childElement.nodeName !== "SUMMARY" ? element.hasAttribute("open") : true);
+}
+/**
+* Whether an element is visible, and so eligible for focus. Adapted from
+* @react-aria/utils, which adapts testing-library/jest-dom and
+* vue-test-utils-next (MIT): uses `checkVisibility` when supported, otherwise
+* walks computed style and visibility-affecting attributes up the ancestor chain.
+*/
+function isElementVisible(element, childElement) {
+	if (supportsCheckVisibility) return element.checkVisibility({ visibilityProperty: true }) && !element.closest("[data-react-aria-prevent-focus]");
+	return element.nodeName !== "#comment" && isStyleVisible(element) && isAttributeVisible(element, childElement) && (!element.parentElement || isElementVisible(element.parentElement, element));
+}
+const focusableElements = [
+	"input:not([disabled]):not([type=hidden])",
+	"select:not([disabled])",
+	"textarea:not([disabled])",
+	"button:not([disabled])",
+	"a[href]",
+	"area[href]",
+	"summary",
+	"iframe",
+	"object",
+	"embed",
+	"audio[controls]",
+	"video[controls]",
+	"[contenteditable]:not([contenteditable^=\"false\"])",
+	"permission"
+];
+const FOCUSABLE_ELEMENT_SELECTOR = focusableElements.join(":not([hidden]),") + ",[tabindex]:not([disabled]):not([hidden])";
+focusableElements.push("[tabindex]:not([tabindex=\"-1\"]):not([disabled])");
+const TABBABLE_ELEMENT_SELECTOR = focusableElements.join(":not([hidden]):not([tabindex=\"-1\"]),");
+/**
+* Checks if an element is a valid focusable element: it matches the focusable
+* selector, is not inside an `inert` subtree, and is visible. A negative tabindex
+* is programmatically focusable (matched here) but not tabbable. `skipVisibilityCheck`
+* lets callers (e.g. the press-path `preventFocus` ancestor walk) skip the
+* `isElementVisible` step, which also avoids touching layout on detached documents.
+*/
+function isFocusable(element, options) {
+	return element.matches(FOCUSABLE_ELEMENT_SELECTOR) && !isInert(element) && (options?.skipVisibilityCheck || isElementVisible(element));
+}
+/**
+* Checks if an element is tabbable (reachable via the Tab key): focusable,
+* visible, not inert, and not `tabindex="-1"`.
+*/
+function isTabbable(element) {
+	return element.matches(TABBABLE_ELEMENT_SELECTOR) && isElementVisible(element) && !isInert(element);
+}
+function isInert(element) {
+	let node = element;
+	while (node != null) {
+		if ((node instanceof getOwnerWindow(node).HTMLElement || typeof HTMLElement !== "undefined" && node instanceof HTMLElement) && node.inert) return true;
+		node = node.parentElement;
+	}
+	return false;
+}
+/**
+* Checks if a keyboard event should trigger the default action (like clicking).
+*/
+function isValidKeyboardEvent(event, currentTarget) {
+	const { key, code } = event;
+	const element = currentTarget;
+	const tagName = element.tagName.toLowerCase();
+	const role = element.getAttribute("role");
+	if (!(key === "Enter" || key === " " || key === "Spacebar" || code === "Space")) return false;
+	if (tagName === "textarea") return false;
+	if (element.isContentEditable) return false;
+	if ((role === "link" || !role && isHTMLAnchorLink(element)) && key !== "Enter") return false;
+	if (tagName === "input") return isValidInputKey(element, key);
+	return true;
+}
+/**
+* Checks if a key is valid for a specific input type.
+*/
+function isValidInputKey(target, key) {
+	const type = target.type.toLowerCase();
+	if (type === "checkbox" || type === "radio") return key === " " || key === "Spacebar";
+	if ([
+		"text",
+		"search",
+		"url",
+		"tel",
+		"email",
+		"password",
+		"date",
+		"month",
+		"week",
+		"time",
+		"datetime-local",
+		"number"
+	].includes(type)) return false;
+	return true;
+}
+/**
+* Checks if an element is an HTML anchor link (has href attribute).
+*/
+function isHTMLAnchorLink(target) {
+	return target.tagName === "A" && target.hasAttribute("href");
+}
+/**
+* Whether to prevent default on keyboard events for this element.
+*/
+function shouldPreventDefaultKeyboard(target, key) {
+	if (target instanceof HTMLInputElement) return !isValidInputKey(target, key);
+	return shouldPreventDefaultUp(target);
+}
+/**
+* Whether to prevent default on pointer up for this element.
+*/
+function shouldPreventDefaultUp(target) {
+	const tagName = target.tagName.toLowerCase();
+	if (tagName === "input" || tagName === "textarea" || tagName === "select") return false;
+	if (tagName === "a" || target.getAttribute("role") === "link") return false;
+	if (tagName === "button") {
+		const type = target.type;
+		if (type === "submit" || type === "reset") return false;
+	}
+	return true;
+}
+/**
+* Opens a link by dispatching the click the browser would have produced, so the
+* link's own `target`, `rel`, `download` and any router listening for clicks all
+* still apply. Used for keyboard activation of links, and for elements that act
+* as links without being one.
+*
+* 1:1 with `openLink` in @react-aria/utils: it never navigates itself.
+*/
+function openLink(target, modifiers, setOpening = true) {
+	let { metaKey, ctrlKey } = modifiers;
+	const { altKey, shiftKey } = modifiers;
+	if (!isWebKit() && isFirefox() && window.event?.type?.startsWith("key") && target.target === "_blank") {
+		if (isMac()) metaKey = true;
+		else ctrlKey = true;
+	}
+	const event = isWebKit() && isMac() && !isIPad() && !isTestEnv() ? new KeyboardEvent("keydown", {
+		keyIdentifier: "Enter",
+		metaKey,
+		ctrlKey,
+		altKey,
+		shiftKey
+	}) : new MouseEvent("click", {
+		metaKey,
+		ctrlKey,
+		altKey,
+		shiftKey,
+		detail: 1,
+		bubbles: true,
+		cancelable: true
+	});
+	openLink.isOpening = setOpening;
+	focusWithoutScrolling(target);
+	target.dispatchEvent(event);
+	openLink.isOpening = false;
+}
+openLink.isOpening = false;
+/**
+* Checks if an element is scrollable based on its overflow style.
+* @param node - The element to check
+* @param checkForOverflow - If true, also check if the element actually overflows
+*/
+function isScrollable(node, checkForOverflow) {
+	if (!node) return false;
+	const style = window.getComputedStyle(node);
+	const scrollable = /(auto|scroll)/.test(style.overflow + style.overflowX + style.overflowY);
+	if (scrollable && checkForOverflow) return node.scrollHeight !== node.clientHeight || node.scrollWidth !== node.clientWidth;
+	return scrollable;
+}
+/**
+* Gets the nearest scrollable parent element.
+* @param node - The starting element
+* @param checkForOverflow - If true, only return parents that actually overflow
+*/
+function getScrollParent(node, checkForOverflow) {
+	let scrollableNode = node;
+	if (isScrollable(scrollableNode, checkForOverflow)) scrollableNode = scrollableNode.parentElement;
+	while (scrollableNode && !isScrollable(scrollableNode, checkForOverflow)) scrollableNode = scrollableNode.parentElement;
+	return scrollableNode || document.scrollingElement || document.documentElement;
+}
+/**
+* Gets every scrollable ancestor of an element, from the nearest up to (and
+* including) the document scrolling element.
+* @param node - The starting element
+* @param checkForOverflow - If true, only include parents that actually overflow
+*/
+function getScrollParents(node, checkForOverflow) {
+	const parentElements = [];
+	const root = document.scrollingElement || document.documentElement;
+	let current = node;
+	while (current) {
+		if (isScrollable(current, checkForOverflow)) parentElements.push(current);
+		if (current === root) break;
+		current = current.parentElement;
+	}
+	return parentElements;
+}
+/**
+* Checks if an element will open a virtual keyboard when focused.
+* Used for iOS Safari scroll handling.
+*/
+function willOpenKeyboard(target) {
+	if (!target) return false;
+	const tagName = target.tagName.toLowerCase();
+	if (tagName === "input") {
+		const type = target.type.toLowerCase();
+		return [
+			"text",
+			"search",
+			"url",
+			"tel",
+			"email",
+			"password",
+			"date",
+			"month",
+			"week",
+			"time",
+			"datetime-local",
+			"number"
+		].includes(type);
+	}
+	if (tagName === "textarea") return true;
+	if (target.hasAttribute("contenteditable") && target.getAttribute("contenteditable") !== "false") return true;
+	return false;
+}
+/**
+* Returns the deepest active element, descending through open shadow roots.
+* Mirrors @react-aria/utils' `getActiveElement`.
+*/
+function getActiveElement(doc = document) {
+	let activeElement = doc.activeElement;
+	while (activeElement?.shadowRoot?.activeElement) activeElement = activeElement.shadowRoot.activeElement;
+	return activeElement;
+}
+/**
+* Whether the (deepest) active element is `element` or is contained within it.
+* Mirrors @react-aria/utils' `isFocusWithin`.
+*/
+function isFocusWithin(element) {
+	const activeElement = getActiveElement(getOwnerDocument(element));
+	return !!activeElement && nodeContains(element, activeElement);
+}
+/**
+* Creates a `TreeWalker` that visits the focusable (or, when `tabbable`, the
+* tabbable) descendants of `root`, skipping invisible and inert elements.
+* Mirrors @react-aria/focus's `getFocusableTreeWalker`, minus the focus-scope
+* containment filter (we don't model nested scopes here). Used to treat a
+* selectable collection as a single tab stop.
+*/
+function getFocusableTreeWalker(root, opts) {
+	const accept = (node) => (opts?.tabbable ? isTabbable(node) : isFocusable(node)) && (!opts?.accept || opts.accept(node));
+	const walker = getOwnerDocument(root).createTreeWalker(root, NodeFilter.SHOW_ELEMENT, { acceptNode(node) {
+		if (opts?.from?.contains(node)) return NodeFilter.FILTER_REJECT;
+		if (accept(node)) return NodeFilter.FILTER_ACCEPT;
+		return NodeFilter.FILTER_SKIP;
+	} });
+	if (opts?.from) walker.currentNode = opts.from;
+	return walker;
+}
+//#endregion
+export { createFocusVisible as A, createMouseEvent as B, willOpenKeyboard as C, runAfterPaint as D, preventFocus as E, isFocusVisible as F, isAppleDevice as G, isVirtualPointerEvent as H, setInteractionModality as I, isIOS as J, isChrome as K, setupGlobalFocusListeners as L, createInteractionModality as M, getInteractionModality as N, addModalityListener as O, getPointerType as P, isWebKit as Q, useIsKeyboardFocused as R, shouldPreventDefaultUp as S, focusWithoutScrolling as T, setEventTarget as U, isVirtualClick as V, isAndroid as W, isIPhone as X, isIPad as Y, isMac as Z, isValidKeyboardEvent as _, getOwnerDocument as a, setStyle as b, getScrollParent as c, isFocusWithin as d, isFocusable as f, isValidInputKey as g, isTabbable as h, getFocusableTreeWalker as i, createFocusVisibleListener as j, addWindowFocusTracking as k, getScrollParents as l, isScrollable as m, getActiveElement as n, getOwnerWindow as o, isHTMLAnchorLink as p, isFirefox as q, getEventTarget as r, getPropagationTargets as s, addEvent as t, isElementVisible as u, nodeContains as v, focusSafely as w, shouldPreventDefaultKeyboard as x, openLink as y, chain as z };
+
+//# sourceMappingURL=dom.jsx.map