@sprawlify/primitives 0.0.1

package/dist/dom-query-DFCRhyj1.mjs

@@ -0,0 +1,1374 @@
+import { t as _defineProperty } from "./defineProperty-DrXfyjd4.mjs";
+
+//#region src/shared/dom-query/caret.ts
+function isCaretAtStart(input) {
+	if (!input) return false;
+	try {
+		return input.selectionStart === 0 && input.selectionEnd === 0;
+	} catch {
+		return input.value === "";
+	}
+}
+function setCaretToEnd(input) {
+	if (!input) return;
+	const start = input.selectionStart ?? 0;
+	const end = input.selectionEnd ?? 0;
+	if (Math.abs(end - start) !== 0) return;
+	if (start !== 0) return;
+	input.setSelectionRange(input.value.length, input.value.length);
+}
+
+//#endregion
+//#region src/shared/dom-query/shared.ts
+const clamp = (value) => Math.max(0, Math.min(1, value));
+const wrap = (v, idx) => {
+	return v.map((_, index) => v[(Math.max(idx, 0) + index) % v.length]);
+};
+const pipe = (...fns) => (arg) => fns.reduce((acc, fn) => fn(acc), arg);
+const noop = () => void 0;
+const isObject = (v) => typeof v === "object" && v !== null;
+const MAX_Z_INDEX = 2147483647;
+const dataAttr = (guard) => guard ? "" : void 0;
+const ariaAttr = (guard) => guard ? "true" : void 0;
+
+//#endregion
+//#region src/shared/dom-query/node.ts
+const ELEMENT_NODE = 1;
+const DOCUMENT_NODE = 9;
+const DOCUMENT_FRAGMENT_NODE = 11;
+const isHTMLElement = (el) => isObject(el) && el.nodeType === ELEMENT_NODE && typeof el.nodeName === "string";
+const isDocument = (el) => isObject(el) && el.nodeType === DOCUMENT_NODE;
+const isWindow = (el) => isObject(el) && el === el.window;
+const isVisualViewport = (el) => isObject(el) && el.constructor.name === "VisualViewport";
+const getNodeName = (node) => {
+	if (isHTMLElement(node)) return node.localName || "";
+	return "#document";
+};
+function isRootElement(node) {
+	return [
+		"html",
+		"body",
+		"#document"
+	].includes(getNodeName(node));
+}
+const isNode = (el) => isObject(el) && el.nodeType !== void 0;
+const isShadowRoot = (el) => isNode(el) && el.nodeType === DOCUMENT_FRAGMENT_NODE && "host" in el;
+const isInputElement = (el) => isHTMLElement(el) && el.localName === "input";
+const isAnchorElement = (el) => !!el?.matches("a[href]");
+const isElementVisible = (el) => {
+	if (!isHTMLElement(el)) return false;
+	return el.offsetWidth > 0 || el.offsetHeight > 0 || el.getClientRects().length > 0;
+};
+function isActiveElement(element) {
+	if (!element) return false;
+	return getActiveElement(element.getRootNode()) === element;
+}
+const TEXTAREA_SELECT_REGEX = /(textarea|select)/;
+function isEditableElement(el) {
+	if (el == null || !isHTMLElement(el)) return false;
+	try {
+		return isInputElement(el) && el.selectionStart != null || TEXTAREA_SELECT_REGEX.test(el.localName) || el.isContentEditable || el.getAttribute("contenteditable") === "true" || el.getAttribute("contenteditable") === "";
+	} catch {
+		return false;
+	}
+}
+function contains(parent, child) {
+	if (!parent || !child) return false;
+	if (!isHTMLElement(parent) || !isHTMLElement(child)) return false;
+	const rootNode = child.getRootNode?.();
+	if (parent === child) return true;
+	if (parent.contains(child)) return true;
+	if (rootNode && isShadowRoot(rootNode)) {
+		let next = child;
+		while (next) {
+			if (parent === next) return true;
+			next = next.parentNode || next.host;
+		}
+	}
+	return false;
+}
+function getDocument(el) {
+	if (isDocument(el)) return el;
+	if (isWindow(el)) return el.document;
+	return el?.ownerDocument ?? document;
+}
+function getDocumentElement(el) {
+	return getDocument(el).documentElement;
+}
+function getWindow(el) {
+	if (isShadowRoot(el)) return getWindow(el.host);
+	if (isDocument(el)) return el.defaultView ?? window;
+	if (isHTMLElement(el)) return el.ownerDocument?.defaultView ?? window;
+	return window;
+}
+function getActiveElement(rootNode) {
+	let activeElement = rootNode.activeElement;
+	while (activeElement?.shadowRoot) {
+		const el = activeElement.shadowRoot.activeElement;
+		if (!el || el === activeElement) break;
+		else activeElement = el;
+	}
+	return activeElement;
+}
+function getParentNode(node) {
+	if (getNodeName(node) === "html") return node;
+	const result = node.assignedSlot || node.parentNode || isShadowRoot(node) && node.host || getDocumentElement(node);
+	return isShadowRoot(result) ? result.host : result;
+}
+function getRootNode(node) {
+	let result;
+	try {
+		result = node.getRootNode({ composed: true });
+		if (isDocument(result) || isShadowRoot(result)) return result;
+	} catch {}
+	return node.ownerDocument ?? document;
+}
+
+//#endregion
+//#region src/shared/dom-query/computed-style.ts
+const styleCache = /* @__PURE__ */ new WeakMap();
+function getComputedStyle(el) {
+	if (!styleCache.has(el)) styleCache.set(el, getWindow(el).getComputedStyle(el));
+	return styleCache.get(el);
+}
+
+//#endregion
+//#region src/shared/dom-query/controller.ts
+const INTERACTIVE_CONTAINER_ROLE = new Set([
+	"menu",
+	"listbox",
+	"dialog",
+	"grid",
+	"tree",
+	"region"
+]);
+const isInteractiveContainerRole = (role) => INTERACTIVE_CONTAINER_ROLE.has(role);
+const getAriaControls = (element) => element.getAttribute("aria-controls")?.split(" ") || [];
+function isControlledElement(container, element) {
+	const visitedIds = /* @__PURE__ */ new Set();
+	const rootNode = getRootNode(container);
+	const checkElement = (searchRoot) => {
+		const controllingElements = searchRoot.querySelectorAll("[aria-controls]");
+		for (const controller of controllingElements) {
+			if (controller.getAttribute("aria-expanded") !== "true") continue;
+			const controlledIds = getAriaControls(controller);
+			for (const id of controlledIds) {
+				if (!id || visitedIds.has(id)) continue;
+				visitedIds.add(id);
+				const controlledElement = rootNode.getElementById(id);
+				if (controlledElement) {
+					const role = controlledElement.getAttribute("role");
+					const modal = controlledElement.getAttribute("aria-modal") === "true";
+					if (role && isInteractiveContainerRole(role) && !modal) {
+						if (controlledElement === element || controlledElement.contains(element)) return true;
+						if (checkElement(controlledElement)) return true;
+					}
+				}
+			}
+		}
+		return false;
+	};
+	return checkElement(container);
+}
+function findControlledElements(searchRoot, callback) {
+	const rootNode = getRootNode(searchRoot);
+	const visitedIds = /* @__PURE__ */ new Set();
+	const findRecursive = (root) => {
+		const controllingElements = root.querySelectorAll("[aria-controls]");
+		for (const controller of controllingElements) {
+			if (controller.getAttribute("aria-expanded") !== "true") continue;
+			const controlledIds = getAriaControls(controller);
+			for (const id of controlledIds) {
+				if (!id || visitedIds.has(id)) continue;
+				visitedIds.add(id);
+				const controlledElement = rootNode.getElementById(id);
+				if (controlledElement) {
+					const role = controlledElement.getAttribute("role");
+					const modal = controlledElement.getAttribute("aria-modal") === "true";
+					if (role && INTERACTIVE_CONTAINER_ROLE.has(role) && !modal) {
+						callback(controlledElement);
+						findRecursive(controlledElement);
+					}
+				}
+			}
+		}
+	};
+	findRecursive(searchRoot);
+}
+function getControlledElements(container) {
+	const controlledElements = /* @__PURE__ */ new Set();
+	findControlledElements(container, (controlledElement) => {
+		if (!container.contains(controlledElement)) controlledElements.add(controlledElement);
+	});
+	return Array.from(controlledElements);
+}
+function isInteractiveContainerElement(element) {
+	const role = element.getAttribute("role");
+	return Boolean(role && INTERACTIVE_CONTAINER_ROLE.has(role));
+}
+function isControllerElement(element) {
+	return element.hasAttribute("aria-controls") && element.getAttribute("aria-expanded") === "true";
+}
+function hasControllerElements(element) {
+	if (isControllerElement(element)) return true;
+	return Boolean(element.querySelector?.("[aria-controls][aria-expanded=\"true\"]"));
+}
+function isControlledByExpandedController(element) {
+	if (!element.id) return false;
+	const rootNode = getRootNode(element);
+	const escapedId = CSS.escape(element.id);
+	const selector = `[aria-controls~="${escapedId}"][aria-expanded="true"], [aria-controls="${escapedId}"][aria-expanded="true"]`;
+	const controller = rootNode.querySelector(selector);
+	return Boolean(controller && isInteractiveContainerElement(element));
+}
+
+//#endregion
+//#region src/shared/dom-query/data-url.ts
+function getDataUrl(svg, opts) {
+	const { type, quality = .92, background } = opts;
+	if (!svg) throw new Error("[sprawlify-js > getDataUrl]: Could not find the svg element");
+	const win = getWindow(svg);
+	const doc = win.document;
+	const svgBounds = svg.getBoundingClientRect();
+	const svgClone = svg.cloneNode(true);
+	if (!svgClone.hasAttribute("viewBox")) svgClone.setAttribute("viewBox", `0 0 ${svgBounds.width} ${svgBounds.height}`);
+	const source = "<?xml version=\"1.0\" standalone=\"no\"?>\r\n" + new win.XMLSerializer().serializeToString(svgClone);
+	const svgString = "data:image/svg+xml;charset=utf-8," + encodeURIComponent(source);
+	if (type === "image/svg+xml") return Promise.resolve(svgString).then((str) => {
+		svgClone.remove();
+		return str;
+	});
+	const dpr = win.devicePixelRatio || 1;
+	const canvas = doc.createElement("canvas");
+	const image = new win.Image();
+	image.src = svgString;
+	canvas.width = svgBounds.width * dpr;
+	canvas.height = svgBounds.height * dpr;
+	const context = canvas.getContext("2d");
+	if (type === "image/jpeg" || background) {
+		context.fillStyle = background || "white";
+		context.fillRect(0, 0, canvas.width, canvas.height);
+	}
+	return new Promise((resolve) => {
+		image.onload = () => {
+			context?.drawImage(image, 0, 0, canvas.width, canvas.height);
+			resolve(canvas.toDataURL(type, quality));
+			svgClone.remove();
+		};
+	});
+}
+
+//#endregion
+//#region src/shared/dom-query/platform.ts
+const isDom = () => typeof document !== "undefined";
+function getPlatform() {
+	return navigator.userAgentData?.platform ?? navigator.platform;
+}
+function getUserAgent() {
+	const ua$1 = navigator.userAgentData;
+	if (ua$1 && Array.isArray(ua$1.brands)) return ua$1.brands.map(({ brand, version }) => `${brand}/${version}`).join(" ");
+	return navigator.userAgent;
+}
+const pt = (v) => isDom() && v.test(getPlatform());
+const ua = (v) => isDom() && v.test(getUserAgent());
+const vn = (v) => isDom() && v.test(navigator.vendor);
+const isTouchDevice = () => isDom() && !!navigator.maxTouchPoints;
+const isIPhone = () => pt(/^iPhone/i);
+const isIPad = () => pt(/^iPad/i) || isMac() && navigator.maxTouchPoints > 1;
+const isIos = () => isIPhone() || isIPad();
+const isApple = () => isMac() || isIos();
+const isMac = () => pt(/^Mac/i);
+const isSafari = () => isApple() && vn(/apple/i);
+const isFirefox = () => ua(/Firefox/i);
+const isChrome = () => ua(/Chrome/i);
+const isWebKit = () => ua(/AppleWebKit/i) && !isChrome();
+const isAndroid = () => ua(/Android/i);
+
+//#endregion
+//#region src/shared/dom-query/event.ts
+function getBeforeInputValue(event) {
+	const { selectionStart, selectionEnd, value } = event.currentTarget;
+	const data = event.data;
+	return value.slice(0, selectionStart) + (data ?? "") + value.slice(selectionEnd);
+}
+function getComposedPath(event) {
+	return event.composedPath?.() ?? event.nativeEvent?.composedPath?.();
+}
+function getEventTarget(event) {
+	return getComposedPath(event)?.[0] ?? event.target;
+}
+function isOpeningInNewTab(event) {
+	const element = event.currentTarget;
+	if (!element) return false;
+	if (!element.matches("a[href], button[type='submit'], input[type='submit']")) return false;
+	const isMiddleClick = event.button === 1;
+	const isModKeyClick = isCtrlOrMetaKey(event);
+	return isMiddleClick || isModKeyClick;
+}
+function isDownloadingEvent(event) {
+	const element = event.currentTarget;
+	if (!element) return false;
+	const localName = element.localName;
+	if (!event.altKey) return false;
+	if (localName === "a") return true;
+	if (localName === "button" && element.type === "submit") return true;
+	if (localName === "input" && element.type === "submit") return true;
+	return false;
+}
+function isComposingEvent(event) {
+	return getNativeEvent(event).isComposing || event.keyCode === 229;
+}
+function isKeyboardClick(e) {
+	return e.detail === 0 || e.clientX === 0 && e.clientY === 0;
+}
+function isCtrlOrMetaKey(e) {
+	if (isMac()) return e.metaKey;
+	return e.ctrlKey;
+}
+function isPrintableKey(e) {
+	return e.key.length === 1 && !e.ctrlKey && !e.metaKey;
+}
+function isVirtualPointerEvent(e) {
+	return e.width === 0 && e.height === 0 || e.width === 1 && e.height === 1 && e.pressure === 0 && e.detail === 0 && e.pointerType === "mouse";
+}
+function isVirtualClick(e) {
+	if (e.pointerType === "" && e.isTrusted) return true;
+	if (isAndroid() && e.pointerType) return e.type === "click" && e.buttons === 1;
+	return e.detail === 0 && !e.pointerType;
+}
+const isLeftClick = (e) => e.button === 0;
+const isContextMenuEvent = (e) => {
+	return e.button === 2 || isMac() && e.ctrlKey && e.button === 0;
+};
+const isModifierKey = (e) => e.ctrlKey || e.altKey || e.metaKey;
+const isTouchEvent = (event) => "touches" in event && event.touches.length > 0;
+const keyMap = {
+	Up: "ArrowUp",
+	Down: "ArrowDown",
+	Esc: "Escape",
+	" ": "Space",
+	",": "Comma",
+	Left: "ArrowLeft",
+	Right: "ArrowRight"
+};
+const rtlKeyMap = {
+	ArrowLeft: "ArrowRight",
+	ArrowRight: "ArrowLeft"
+};
+function getEventKey(event, options = {}) {
+	const { dir = "ltr", orientation = "horizontal" } = options;
+	let key = event.key;
+	key = keyMap[key] ?? key;
+	if (dir === "rtl" && orientation === "horizontal" && key in rtlKeyMap) key = rtlKeyMap[key];
+	return key;
+}
+function getNativeEvent(event) {
+	return event.nativeEvent ?? event;
+}
+const pageKeys = new Set(["PageUp", "PageDown"]);
+const arrowKeys = new Set([
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight"
+]);
+function getEventStep(event) {
+	if (event.ctrlKey || event.metaKey) return .1;
+	else return pageKeys.has(event.key) || event.shiftKey && arrowKeys.has(event.key) ? 10 : 1;
+}
+function getEventPoint(event, type = "client") {
+	const point = isTouchEvent(event) ? event.touches[0] || event.changedTouches[0] : event;
+	return {
+		x: point[`${type}X`],
+		y: point[`${type}Y`]
+	};
+}
+const addDomEvent = (target, eventName, handler, options) => {
+	const node = typeof target === "function" ? target() : target;
+	node?.addEventListener(eventName, handler, options);
+	return () => {
+		node?.removeEventListener(eventName, handler, options);
+	};
+};
+const isSelfTarget = (event) => {
+	const target = getComposedPath(event)?.[0] ?? event.target;
+	return event.currentTarget === target;
+};
+
+//#endregion
+//#region src/shared/dom-query/form.ts
+function getDescriptor(el, options) {
+	const { type = "HTMLInputElement", property = "value" } = options;
+	const proto = getWindow(el)[type].prototype;
+	return Object.getOwnPropertyDescriptor(proto, property) ?? {};
+}
+function getElementType(el) {
+	if (el.localName === "input") return "HTMLInputElement";
+	if (el.localName === "textarea") return "HTMLTextAreaElement";
+	if (el.localName === "select") return "HTMLSelectElement";
+}
+function setElementValue(el, value, property = "value") {
+	if (!el) return;
+	const type = getElementType(el);
+	if (type) getDescriptor(el, {
+		type,
+		property
+	}).set?.call(el, value);
+	el.setAttribute(property, value);
+}
+function setElementChecked(el, checked) {
+	if (!el) return;
+	getDescriptor(el, {
+		type: "HTMLInputElement",
+		property: "checked"
+	}).set?.call(el, checked);
+	if (checked) el.setAttribute("checked", "");
+	else el.removeAttribute("checked");
+}
+function dispatchInputValueEvent(el, options) {
+	const { value, bubbles = true } = options;
+	if (!el) return;
+	const win = getWindow(el);
+	if (!(el instanceof win.HTMLInputElement)) return;
+	setElementValue(el, `${value}`);
+	el.dispatchEvent(new win.Event("input", { bubbles }));
+}
+function dispatchInputCheckedEvent(el, options) {
+	const { checked, bubbles = true } = options;
+	if (!el) return;
+	const win = getWindow(el);
+	if (!(el instanceof win.HTMLInputElement)) return;
+	setElementChecked(el, checked);
+	el.dispatchEvent(new win.Event("click", { bubbles }));
+}
+function getClosestForm(el) {
+	return isFormElement(el) ? el.form : el.closest("form");
+}
+function isFormElement(el) {
+	return el.matches("textarea, input, select, button");
+}
+function trackFormReset(el, callback) {
+	if (!el) return;
+	const form = getClosestForm(el);
+	const onReset = (e) => {
+		if (e.defaultPrevented) return;
+		callback();
+	};
+	form?.addEventListener("reset", onReset, { passive: true });
+	return () => form?.removeEventListener("reset", onReset);
+}
+function trackFieldsetDisabled(el, callback) {
+	const fieldset = el?.closest("fieldset");
+	if (!fieldset) return;
+	callback(fieldset.disabled);
+	const obs = new (getWindow(fieldset)).MutationObserver(() => callback(fieldset.disabled));
+	obs.observe(fieldset, {
+		attributes: true,
+		attributeFilter: ["disabled"]
+	});
+	return () => obs.disconnect();
+}
+function trackFormControl(el, options) {
+	if (!el) return;
+	const { onFieldsetDisabledChange, onFormReset } = options;
+	const cleanups = [trackFormReset(el, onFormReset), trackFieldsetDisabled(el, onFieldsetDisabledChange)];
+	return () => cleanups.forEach((cleanup) => cleanup?.());
+}
+
+//#endregion
+//#region src/shared/dom-query/tabbable.ts
+const isFrame = (el) => isHTMLElement(el) && el.tagName === "IFRAME";
+const NATURALLY_TABBABLE_REGEX = /^(audio|video|details)$/;
+function parseTabIndex(el) {
+	const attr = el.getAttribute("tabindex");
+	if (!attr) return NaN;
+	return parseInt(attr, 10);
+}
+const hasTabIndex = (el) => !Number.isNaN(parseTabIndex(el));
+const hasNegativeTabIndex = (el) => parseTabIndex(el) < 0;
+function getShadowRootForNode(element, getShadowRoot) {
+	if (!getShadowRoot) return null;
+	if (getShadowRoot === true) return element.shadowRoot || null;
+	const result = getShadowRoot(element);
+	return (result === true ? element.shadowRoot : result) || null;
+}
+function collectElementsWithShadowDOM(elements, getShadowRoot, filterFn) {
+	const allElements = [...elements];
+	const toProcess = [...elements];
+	const processed = /* @__PURE__ */ new Set();
+	const positionMap = /* @__PURE__ */ new Map();
+	elements.forEach((el, i) => positionMap.set(el, i));
+	let processIndex = 0;
+	while (processIndex < toProcess.length) {
+		const element = toProcess[processIndex++];
+		if (!element || processed.has(element)) continue;
+		processed.add(element);
+		const shadowRoot = getShadowRootForNode(element, getShadowRoot);
+		if (shadowRoot) {
+			const shadowElements = Array.from(shadowRoot.querySelectorAll(focusableSelector)).filter(filterFn);
+			const hostIndex = positionMap.get(element);
+			if (hostIndex !== void 0) {
+				const insertPosition = hostIndex + 1;
+				allElements.splice(insertPosition, 0, ...shadowElements);
+				shadowElements.forEach((el, i) => {
+					positionMap.set(el, insertPosition + i);
+				});
+				for (let i = insertPosition + shadowElements.length; i < allElements.length; i++) positionMap.set(allElements[i], i);
+			} else {
+				const insertPosition = allElements.length;
+				allElements.push(...shadowElements);
+				shadowElements.forEach((el, i) => {
+					positionMap.set(el, insertPosition + i);
+				});
+			}
+			toProcess.push(...shadowElements);
+		}
+	}
+	return allElements;
+}
+const focusableSelector = "input:not([type='hidden']):not([disabled]), select:not([disabled]), textarea:not([disabled]), a[href], button:not([disabled]), [tabindex], iframe, object, embed, area[href], audio[controls], video[controls], [contenteditable]:not([contenteditable='false']), details > summary:first-of-type";
+const getFocusables = (container, options = {}) => {
+	if (!container) return [];
+	const { includeContainer = false, getShadowRoot } = options;
+	const elements = Array.from(container.querySelectorAll(focusableSelector));
+	if ((includeContainer == true || includeContainer == "if-empty" && elements.length === 0) && isHTMLElement(container) && isFocusable(container)) elements.unshift(container);
+	const focusableElements = [];
+	for (const element of elements) {
+		if (!isFocusable(element)) continue;
+		if (isFrame(element) && element.contentDocument) {
+			const frameBody = element.contentDocument.body;
+			focusableElements.push(...getFocusables(frameBody, { getShadowRoot }));
+			continue;
+		}
+		focusableElements.push(element);
+	}
+	if (getShadowRoot) return collectElementsWithShadowDOM(focusableElements, getShadowRoot, isFocusable);
+	return focusableElements;
+};
+function isFocusable(element) {
+	if (!isHTMLElement(element) || element.closest("[inert]")) return false;
+	return element.matches(focusableSelector) && isElementVisible(element);
+}
+function getFirstFocusable(container, options = {}) {
+	const [first] = getFocusables(container, options);
+	return first || null;
+}
+function getTabbables(container, options = {}) {
+	if (!container) return [];
+	const { includeContainer, getShadowRoot } = options;
+	const elements = Array.from(container.querySelectorAll(focusableSelector));
+	if (includeContainer && isTabbable(container)) elements.unshift(container);
+	const tabbableElements = [];
+	for (const element of elements) {
+		if (!isTabbable(element)) continue;
+		if (isFrame(element) && element.contentDocument) {
+			const frameBody = element.contentDocument.body;
+			tabbableElements.push(...getTabbables(frameBody, { getShadowRoot }));
+			continue;
+		}
+		tabbableElements.push(element);
+	}
+	if (getShadowRoot) {
+		const allElements = collectElementsWithShadowDOM(tabbableElements, getShadowRoot, isTabbable);
+		if (!allElements.length && includeContainer) return elements;
+		return allElements;
+	}
+	if (!tabbableElements.length && includeContainer) return elements;
+	return tabbableElements;
+}
+function isTabbable(el) {
+	if (isHTMLElement(el) && el.tabIndex > 0) return true;
+	return isFocusable(el) && !hasNegativeTabIndex(el);
+}
+function getFirstTabbable(container, options = {}) {
+	const [first] = getTabbables(container, options);
+	return first || null;
+}
+function getLastTabbable(container, options = {}) {
+	const elements = getTabbables(container, options);
+	return elements[elements.length - 1] || null;
+}
+function getTabbableEdges(container, options = {}) {
+	const elements = getTabbables(container, options);
+	return [elements[0] || null, elements[elements.length - 1] || null];
+}
+function getNextTabbable(container, options = {}) {
+	const { current, getShadowRoot } = options;
+	const tabbables = getTabbables(container, { getShadowRoot });
+	const doc = container?.ownerDocument || document;
+	const currentElement = current ?? getActiveElement(doc);
+	if (!currentElement) return null;
+	return tabbables[tabbables.indexOf(currentElement) + 1] || null;
+}
+function getTabIndex(node) {
+	if (node.tabIndex < 0) {
+		if ((NATURALLY_TABBABLE_REGEX.test(node.localName) || isEditableElement(node)) && !hasTabIndex(node)) return 0;
+	}
+	return node.tabIndex;
+}
+
+//#endregion
+//#region src/shared/dom-query/initial-focus.ts
+function getInitialFocus(options) {
+	const { root, getInitialEl, filter, enabled = true } = options;
+	if (!enabled) return;
+	let node = null;
+	node || (node = typeof getInitialEl === "function" ? getInitialEl() : getInitialEl);
+	node || (node = root?.querySelector("[data-autofocus],[autofocus]"));
+	if (!node) {
+		const tabbables = getTabbables(root);
+		node = filter ? tabbables.filter(filter)[0] : tabbables[0];
+	}
+	return node || root || void 0;
+}
+function isValidTabEvent(event) {
+	const container = event.currentTarget;
+	if (!container) return false;
+	const [firstTabbable, lastTabbable] = getTabbableEdges(container);
+	if (isActiveElement(firstTabbable) && event.shiftKey) return false;
+	if (isActiveElement(lastTabbable) && !event.shiftKey) return false;
+	if (!firstTabbable && !lastTabbable) return false;
+	return true;
+}
+
+//#endregion
+//#region src/shared/dom-query/raf.ts
+var AnimationFrame = class AnimationFrame {
+	constructor() {
+		_defineProperty(this, "id", null);
+		_defineProperty(this, "fn_cleanup", void 0);
+		_defineProperty(this, "cleanup", () => {
+			this.cancel();
+		});
+	}
+	static create() {
+		return new AnimationFrame();
+	}
+	request(fn) {
+		this.cancel();
+		this.id = globalThis.requestAnimationFrame(() => {
+			this.id = null;
+			this.fn_cleanup = fn?.();
+		});
+	}
+	cancel() {
+		if (this.id !== null) {
+			globalThis.cancelAnimationFrame(this.id);
+			this.id = null;
+		}
+		this.fn_cleanup?.();
+		this.fn_cleanup = void 0;
+	}
+	isActive() {
+		return this.id !== null;
+	}
+};
+function raf(fn) {
+	const frame = AnimationFrame.create();
+	frame.request(fn);
+	return frame.cleanup;
+}
+function nextTick(fn) {
+	const set = /* @__PURE__ */ new Set();
+	function raf$1(fn$1) {
+		const id = globalThis.requestAnimationFrame(fn$1);
+		set.add(() => globalThis.cancelAnimationFrame(id));
+	}
+	raf$1(() => raf$1(fn));
+	return function cleanup() {
+		set.forEach((fn$1) => fn$1());
+	};
+}
+function queueBeforeEvent(el, type, cb) {
+	const cancelTimer = raf(() => {
+		el.removeEventListener(type, exec, true);
+		cb();
+	});
+	const exec = () => {
+		cancelTimer();
+		cb();
+	};
+	el.addEventListener(type, exec, {
+		once: true,
+		capture: true
+	});
+	return cancelTimer;
+}
+
+//#endregion
+//#region src/shared/dom-query/mutation-observer.ts
+function observeAttributesImpl(node, options) {
+	if (!node) return;
+	const { attributes, callback: fn } = options;
+	const obs = new (node.ownerDocument.defaultView || window).MutationObserver((changes) => {
+		for (const change of changes) if (change.type === "attributes" && change.attributeName && attributes.includes(change.attributeName)) fn(change);
+	});
+	obs.observe(node, {
+		attributes: true,
+		attributeFilter: attributes
+	});
+	return () => obs.disconnect();
+}
+function observeAttributes(nodeOrFn, options) {
+	const { defer } = options;
+	const func = defer ? raf : (v) => v();
+	const cleanups = [];
+	cleanups.push(func(() => {
+		const node = typeof nodeOrFn === "function" ? nodeOrFn() : nodeOrFn;
+		cleanups.push(observeAttributesImpl(node, options));
+	}));
+	return () => {
+		cleanups.forEach((fn) => fn?.());
+	};
+}
+function observeChildrenImpl(node, options) {
+	const { callback: fn } = options;
+	if (!node) return;
+	const obs = new (node.ownerDocument.defaultView || window).MutationObserver(fn);
+	obs.observe(node, {
+		childList: true,
+		subtree: true
+	});
+	return () => obs.disconnect();
+}
+function observeChildren(nodeOrFn, options) {
+	const { defer } = options;
+	const func = defer ? raf : (v) => v();
+	const cleanups = [];
+	cleanups.push(func(() => {
+		const node = typeof nodeOrFn === "function" ? nodeOrFn() : nodeOrFn;
+		cleanups.push(observeChildrenImpl(node, options));
+	}));
+	return () => {
+		cleanups.forEach((fn) => fn?.());
+	};
+}
+
+//#endregion
+//#region src/shared/dom-query/navigate.ts
+function navigate(items, current, options = {}) {
+	if (!current) return null;
+	const { orientation = "both", loop = true, dir = "ltr", key } = options;
+	if (!items.length || !key) return null;
+	const isVertical = key === "ArrowUp" || key === "ArrowDown";
+	const isHorizontal = key === "ArrowLeft" || key === "ArrowRight";
+	if (!isVertical && !isHorizontal && key !== "Home" && key !== "End") return null;
+	if (orientation === "vertical" && isHorizontal || orientation === "horizontal" && isVertical) return null;
+	if (key === "Home") return items[0] || null;
+	if (key === "End") return items[items.length - 1] || null;
+	const idx = items.indexOf(current);
+	if (idx === -1) return null;
+	let isForward;
+	if (orientation === "both") isForward = key === "ArrowDown" || (dir === "ltr" ? key === "ArrowRight" : key === "ArrowLeft");
+	else isForward = isVertical ? key === "ArrowDown" : dir === "ltr" ? key === "ArrowRight" : key === "ArrowLeft";
+	return items[isForward ? loop ? (idx + 1) % items.length : Math.min(idx + 1, items.length - 1) : loop ? (idx - 1 + items.length) % items.length : Math.max(0, idx - 1)] || null;
+}
+function clickIfLink(el) {
+	const click = () => {
+		const win = getWindow(el);
+		el.dispatchEvent(new win.MouseEvent("click"));
+	};
+	if (isFirefox()) queueBeforeEvent(el, "keyup", click);
+	else queueMicrotask(click);
+}
+
+//#endregion
+//#region src/shared/dom-query/overflow.ts
+function getNearestOverflowAncestor(el) {
+	const parentNode = getParentNode(el);
+	if (isRootElement(parentNode)) return getDocument(parentNode).body;
+	if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) return parentNode;
+	return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(el, list = []) {
+	const scrollableAncestor = getNearestOverflowAncestor(el);
+	const isBody = scrollableAncestor === el.ownerDocument.body;
+	const win = getWindow(scrollableAncestor);
+	if (isBody) return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : []);
+	return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, []));
+}
+const getElementRect = (el) => {
+	if (isHTMLElement(el)) return el.getBoundingClientRect();
+	if (isVisualViewport(el)) return {
+		top: 0,
+		left: 0,
+		bottom: el.height,
+		right: el.width
+	};
+	return {
+		top: 0,
+		left: 0,
+		bottom: el.innerHeight,
+		right: el.innerWidth
+	};
+};
+function isInView(el, ancestor) {
+	if (!isHTMLElement(el)) return true;
+	const ancestorRect = getElementRect(ancestor);
+	const elRect = el.getBoundingClientRect();
+	return elRect.top >= ancestorRect.top && elRect.left >= ancestorRect.left && elRect.bottom <= ancestorRect.bottom && elRect.right <= ancestorRect.right;
+}
+const OVERFLOW_RE = /auto|scroll|overlay|hidden|clip/;
+const nonOverflowValues = new Set(["inline", "contents"]);
+function isOverflowElement(el) {
+	const { overflow, overflowX, overflowY, display } = getWindow(el).getComputedStyle(el);
+	return OVERFLOW_RE.test(overflow + overflowY + overflowX) && !nonOverflowValues.has(display);
+}
+function isScrollable(el) {
+	return el.scrollHeight > el.clientHeight || el.scrollWidth > el.clientWidth;
+}
+function scrollIntoView(el, options) {
+	const { rootEl, ...scrollOptions } = options || {};
+	if (!el || !rootEl) return;
+	if (!isOverflowElement(rootEl) || !isScrollable(rootEl)) return;
+	el.scrollIntoView(scrollOptions);
+}
+function getScrollPosition(element) {
+	if (isHTMLElement(element)) return {
+		scrollLeft: element.scrollLeft,
+		scrollTop: element.scrollTop
+	};
+	return {
+		scrollLeft: element.scrollX,
+		scrollTop: element.scrollY
+	};
+}
+
+//#endregion
+//#region src/shared/dom-query/point.ts
+function getRelativePoint(point, element) {
+	const { left, top, width, height } = element.getBoundingClientRect();
+	const offset = {
+		x: point.x - left,
+		y: point.y - top
+	};
+	const percent = {
+		x: clamp(offset.x / width),
+		y: clamp(offset.y / height)
+	};
+	function getPercentValue(options = {}) {
+		const { dir = "ltr", orientation = "horizontal", inverted } = options;
+		const invertX = typeof inverted === "object" ? inverted.x : inverted;
+		const invertY = typeof inverted === "object" ? inverted.y : inverted;
+		if (orientation === "horizontal") return dir === "rtl" || invertX ? 1 - percent.x : percent.x;
+		return invertY ? 1 - percent.y : percent.y;
+	}
+	return {
+		offset,
+		percent,
+		getPercentValue
+	};
+}
+
+//#endregion
+//#region src/shared/dom-query/pointer-lock.ts
+function requestPointerLock(doc, fn) {
+	const body = doc.body;
+	const supported = "pointerLockElement" in doc || "mozPointerLockElement" in doc;
+	const isLocked = () => !!doc.pointerLockElement;
+	function onPointerChange() {
+		fn?.(isLocked());
+	}
+	function onPointerError(event) {
+		if (isLocked()) fn?.(false);
+		console.error("PointerLock error occurred:", event);
+		doc.exitPointerLock();
+	}
+	if (!supported) return;
+	try {
+		body.requestPointerLock();
+	} catch {}
+	const cleanup = [addDomEvent(doc, "pointerlockchange", onPointerChange, false), addDomEvent(doc, "pointerlockerror", onPointerError, false)];
+	return () => {
+		cleanup.forEach((cleanup$1) => cleanup$1());
+		doc.exitPointerLock();
+	};
+}
+
+//#endregion
+//#region src/shared/dom-query/text-selection.ts
+let state = "default";
+let userSelect = "";
+const elementMap = /* @__PURE__ */ new WeakMap();
+function disableTextSelectionImpl(options = {}) {
+	const { target, doc } = options;
+	const docNode = doc ?? document;
+	const rootEl = docNode.documentElement;
+	if (isIos()) {
+		if (state === "default") {
+			userSelect = rootEl.style.webkitUserSelect;
+			rootEl.style.webkitUserSelect = "none";
+		}
+		state = "disabled";
+	} else if (target) {
+		elementMap.set(target, target.style.userSelect);
+		target.style.userSelect = "none";
+	}
+	return () => restoreTextSelection({
+		target,
+		doc: docNode
+	});
+}
+function restoreTextSelection(options = {}) {
+	const { target, doc } = options;
+	const rootEl = (doc ?? document).documentElement;
+	if (isIos()) {
+		if (state !== "disabled") return;
+		state = "restoring";
+		setTimeout(() => {
+			nextTick(() => {
+				if (state === "restoring") {
+					if (rootEl.style.webkitUserSelect === "none") rootEl.style.webkitUserSelect = userSelect || "";
+					userSelect = "";
+					state = "default";
+				}
+			});
+		}, 300);
+	} else if (target && elementMap.has(target)) {
+		const prevUserSelect = elementMap.get(target);
+		if (target.style.userSelect === "none") target.style.userSelect = prevUserSelect ?? "";
+		if (target.getAttribute("style") === "") target.removeAttribute("style");
+		elementMap.delete(target);
+	}
+}
+function disableTextSelection(options = {}) {
+	const { defer, target, ...restOptions } = options;
+	const func = defer ? raf : (v) => v();
+	const cleanups = [];
+	cleanups.push(func(() => {
+		const node = typeof target === "function" ? target() : target;
+		cleanups.push(disableTextSelectionImpl({
+			...restOptions,
+			target: node
+		}));
+	}));
+	return () => {
+		cleanups.forEach((fn) => fn?.());
+	};
+}
+
+//#endregion
+//#region src/shared/dom-query/pointer-move.ts
+function trackPointerMove(doc, handlers) {
+	const { onPointerMove, onPointerUp } = handlers;
+	const handleMove = (event) => {
+		const point = getEventPoint(event);
+		if (Math.sqrt(point.x ** 2 + point.y ** 2) < (event.pointerType === "touch" ? 10 : 5)) return;
+		if (event.pointerType === "mouse" && event.buttons === 0) {
+			handleUp(event);
+			return;
+		}
+		onPointerMove({
+			point,
+			event
+		});
+	};
+	const handleUp = (event) => {
+		onPointerUp({
+			point: getEventPoint(event),
+			event
+		});
+	};
+	const cleanups = [
+		addDomEvent(doc, "pointermove", handleMove, false),
+		addDomEvent(doc, "pointerup", handleUp, false),
+		addDomEvent(doc, "pointercancel", handleUp, false),
+		addDomEvent(doc, "contextmenu", handleUp, false),
+		disableTextSelection({ doc })
+	];
+	return () => {
+		cleanups.forEach((cleanup) => cleanup());
+	};
+}
+
+//#endregion
+//#region src/shared/dom-query/press.ts
+function trackPress(options) {
+	const { pointerNode, keyboardNode = pointerNode, onPress, onPressStart, onPressEnd, isValidKey = (e) => e.key === "Enter" } = options;
+	if (!pointerNode) return noop;
+	const win = getWindow(pointerNode);
+	let removeStartListeners = noop;
+	let removeEndListeners = noop;
+	let removeAccessibleListeners = noop;
+	const getInfo = (event) => ({
+		point: getEventPoint(event),
+		event
+	});
+	function startPress(event) {
+		onPressStart?.(getInfo(event));
+	}
+	function cancelPress(event) {
+		onPressEnd?.(getInfo(event));
+	}
+	const startPointerPress = (startEvent) => {
+		removeEndListeners();
+		const endPointerPress = (endEvent) => {
+			if (contains(pointerNode, getEventTarget(endEvent))) onPress?.(getInfo(endEvent));
+			else onPressEnd?.(getInfo(endEvent));
+		};
+		removeEndListeners = pipe(addDomEvent(win, "pointerup", endPointerPress, {
+			passive: !onPress,
+			once: true
+		}), addDomEvent(win, "pointercancel", cancelPress, {
+			passive: !onPressEnd,
+			once: true
+		}));
+		if (isActiveElement(keyboardNode) && startEvent.pointerType === "mouse") startEvent.preventDefault();
+		startPress(startEvent);
+	};
+	removeStartListeners = pipe(addDomEvent(pointerNode, "pointerdown", startPointerPress, { passive: !onPressStart }), addDomEvent(keyboardNode, "focus", startAccessiblePress));
+	function startAccessiblePress() {
+		const handleKeydown = (keydownEvent) => {
+			if (!isValidKey(keydownEvent)) return;
+			const handleKeyup = (keyupEvent) => {
+				if (!isValidKey(keyupEvent)) return;
+				const info = getInfo(new win.PointerEvent("pointerup"));
+				onPress?.(info);
+				onPressEnd?.(info);
+			};
+			removeEndListeners();
+			removeEndListeners = addDomEvent(keyboardNode, "keyup", handleKeyup);
+			startPress(new win.PointerEvent("pointerdown"));
+		};
+		const handleBlur = () => {
+			cancelPress(new win.PointerEvent("pointercancel"));
+		};
+		removeAccessibleListeners = pipe(addDomEvent(keyboardNode, "keydown", handleKeydown), addDomEvent(keyboardNode, "blur", handleBlur));
+	}
+	return () => {
+		removeStartListeners();
+		removeEndListeners();
+		removeAccessibleListeners();
+	};
+}
+
+//#endregion
+//#region src/shared/dom-query/proxy-tab-focus.ts
+function proxyTabFocusImpl(container, options = {}) {
+	const { triggerElement, onFocus, onFocusEnter, getShadowRoot } = options;
+	const doc = container?.ownerDocument || document;
+	const body = doc.body;
+	function onKeyDown(event) {
+		if (event.key !== "Tab") return;
+		let elementToFocus = null;
+		const [firstTabbable, lastTabbable] = getTabbableEdges(container, {
+			includeContainer: true,
+			getShadowRoot
+		});
+		const nextTabbableAfterTrigger = getNextTabbable(body, {
+			current: triggerElement,
+			getShadowRoot
+		});
+		const noTabbableElements = !firstTabbable && !lastTabbable;
+		if (event.shiftKey && isActiveElement(nextTabbableAfterTrigger)) {
+			onFocusEnter?.();
+			elementToFocus = lastTabbable;
+		} else if (event.shiftKey && (isActiveElement(firstTabbable) || noTabbableElements)) elementToFocus = triggerElement;
+		else if (!event.shiftKey && isActiveElement(triggerElement)) {
+			onFocusEnter?.();
+			elementToFocus = firstTabbable;
+		} else if (!event.shiftKey && (isActiveElement(lastTabbable) || noTabbableElements)) elementToFocus = nextTabbableAfterTrigger;
+		if (!elementToFocus) return;
+		event.preventDefault();
+		if (typeof onFocus === "function") onFocus(elementToFocus);
+		else elementToFocus.focus();
+	}
+	return addDomEvent(doc, "keydown", onKeyDown, true);
+}
+function proxyTabFocus(container, options) {
+	const { defer, triggerElement, ...restOptions } = options;
+	const func = defer ? raf : (v) => v();
+	const cleanups = [];
+	cleanups.push(func(() => {
+		const node = typeof container === "function" ? container() : container;
+		const trigger = typeof triggerElement === "function" ? triggerElement() : triggerElement;
+		cleanups.push(proxyTabFocusImpl(node, {
+			triggerElement: trigger,
+			...restOptions
+		}));
+	}));
+	return () => {
+		cleanups.forEach((fn) => fn?.());
+	};
+}
+
+//#endregion
+//#region src/shared/dom-query/query.ts
+function queryAll(root, selector) {
+	return Array.from(root?.querySelectorAll(selector) ?? []);
+}
+function query(root, selector) {
+	return root?.querySelector(selector) ?? null;
+}
+const defaultItemToId = (v) => v.id;
+function itemById(v, id, itemToId = defaultItemToId) {
+	return v.find((item) => itemToId(item) === id);
+}
+function indexOfId(v, id, itemToId = defaultItemToId) {
+	const item = itemById(v, id, itemToId);
+	return item ? v.indexOf(item) : -1;
+}
+function nextById(v, id, loop = true) {
+	let idx = indexOfId(v, id);
+	idx = loop ? (idx + 1) % v.length : Math.min(idx + 1, v.length - 1);
+	return v[idx];
+}
+function prevById(v, id, loop = true) {
+	let idx = indexOfId(v, id);
+	if (idx === -1) return loop ? v[v.length - 1] : null;
+	idx = loop ? (idx - 1 + v.length) % v.length : Math.max(0, idx - 1);
+	return v[idx];
+}
+
+//#endregion
+//#region src/shared/dom-query/resize-observer.ts
+function createSharedResizeObserver(options) {
+	const listeners = /* @__PURE__ */ new WeakMap();
+	let observer;
+	const entries = /* @__PURE__ */ new WeakMap();
+	const getObserver = (win) => {
+		if (observer) return observer;
+		observer = new win.ResizeObserver((observedEntries) => {
+			for (const entry of observedEntries) {
+				entries.set(entry.target, entry);
+				const elementListeners = listeners.get(entry.target);
+				if (elementListeners) for (const listener of elementListeners) listener(entry);
+			}
+		});
+		return observer;
+	};
+	const observe = (element, listener) => {
+		let elementListeners = listeners.get(element) || /* @__PURE__ */ new Set();
+		elementListeners.add(listener);
+		listeners.set(element, elementListeners);
+		const win = getWindow(element);
+		getObserver(win).observe(element, options);
+		return () => {
+			const elementListeners$1 = listeners.get(element);
+			if (!elementListeners$1) return;
+			elementListeners$1.delete(listener);
+			if (elementListeners$1.size === 0) {
+				listeners.delete(element);
+				getObserver(win).unobserve(element);
+			}
+		};
+	};
+	const unobserve = (element) => {
+		listeners.delete(element);
+		observer?.unobserve(element);
+	};
+	return {
+		observe,
+		unobserve
+	};
+}
+const resizeObserverContentBox = createSharedResizeObserver({ box: "content-box" });
+const resizeObserverBorderBox = createSharedResizeObserver({ box: "border-box" });
+const resizeObserverDevicePixelContentBox = createSharedResizeObserver({ box: "device-pixel-content-box" });
+
+//#endregion
+//#region src/shared/dom-query/scope.ts
+function createScope(methods) {
+	const dom = {
+		getRootNode: (ctx) => ctx.getRootNode?.() ?? document,
+		getDoc: (ctx) => getDocument(dom.getRootNode(ctx)),
+		getWin: (ctx) => dom.getDoc(ctx).defaultView ?? window,
+		getActiveElement: (ctx) => getActiveElement(dom.getRootNode(ctx)),
+		isActiveElement,
+		getById: (ctx, id) => dom.getRootNode(ctx).getElementById(id),
+		setValue: (elem, value) => {
+			if (elem == null || value == null) return;
+			setElementValue(elem, value.toString());
+		}
+	};
+	return {
+		...dom,
+		...methods
+	};
+}
+
+//#endregion
+//#region src/shared/dom-query/searchable.ts
+const sanitize = (str) => str.split("").map((char) => {
+	const code = char.charCodeAt(0);
+	if (code > 0 && code < 128) return char;
+	if (code >= 128 && code <= 255) return `/x${code.toString(16)}`.replace("/", "\\");
+	return "";
+}).join("").trim();
+const getValueText = (el) => {
+	return sanitize(el.dataset?.valuetext ?? el.textContent ?? "");
+};
+const match = (valueText, query$1) => {
+	return valueText.trim().toLowerCase().startsWith(query$1.toLowerCase());
+};
+function getByText(v, text, currentId, itemToId = defaultItemToId) {
+	const index = currentId ? indexOfId(v, currentId, itemToId) : -1;
+	let items = currentId ? wrap(v, index) : v;
+	if (text.length === 1) items = items.filter((item) => itemToId(item) !== currentId);
+	return items.find((item) => match(getValueText(item), text));
+}
+
+//#endregion
+//#region src/shared/dom-query/set.ts
+function setAttribute(el, attr, v) {
+	const prev = el.getAttribute(attr);
+	const exists = prev != null;
+	el.setAttribute(attr, v);
+	return () => {
+		if (!exists) el.removeAttribute(attr);
+		else el.setAttribute(attr, prev);
+	};
+}
+function setProperty(el, prop, v) {
+	const exists = prop in el;
+	const prev = el[prop];
+	el[prop] = v;
+	return () => {
+		if (!exists) delete el[prop];
+		else el[prop] = prev;
+	};
+}
+function setStyle(el, style) {
+	if (!el) return noop;
+	const prev = Object.keys(style).reduce((acc, key) => {
+		acc[key] = el.style.getPropertyValue(key);
+		return acc;
+	}, {});
+	Object.assign(el.style, style);
+	return () => {
+		Object.assign(el.style, prev);
+		if (el.style.length === 0) el.removeAttribute("style");
+	};
+}
+function setStyleProperty(el, prop, value) {
+	if (!el) return noop;
+	const prev = el.style.getPropertyValue(prop);
+	el.style.setProperty(prop, value);
+	return () => {
+		el.style.setProperty(prop, prev);
+		if (el.style.length === 0) el.removeAttribute("style");
+	};
+}
+
+//#endregion
+//#region src/shared/dom-query/typeahead.ts
+function getByTypeaheadImpl(baseItems, options) {
+	const { state: state$1, activeId, key, timeout = 350, itemToId } = options;
+	const search = state$1.keysSoFar + key;
+	const query$1 = search.length > 1 && Array.from(search).every((char) => char === search[0]) ? search[0] : search;
+	const next = getByText(baseItems.slice(), query$1, activeId, itemToId);
+	function cleanup() {
+		clearTimeout(state$1.timer);
+		state$1.timer = -1;
+	}
+	function update(value) {
+		state$1.keysSoFar = value;
+		cleanup();
+		if (value !== "") state$1.timer = +setTimeout(() => {
+			update("");
+			cleanup();
+		}, timeout);
+	}
+	update(search);
+	return next;
+}
+const getByTypeahead = Object.assign(getByTypeaheadImpl, {
+	defaultOptions: {
+		keysSoFar: "",
+		timer: -1
+	},
+	isValidEvent: isValidTypeaheadEvent
+});
+function isValidTypeaheadEvent(event) {
+	return event.key.length === 1 && !event.ctrlKey && !event.metaKey;
+}
+
+//#endregion
+//#region src/shared/dom-query/visual-viewport.ts
+function trackVisualViewport(doc, fn) {
+	const win = doc?.defaultView || window;
+	const onResize = () => {
+		fn?.(getViewportSize(win));
+	};
+	onResize();
+	return addDomEvent(win.visualViewport ?? win, "resize", onResize);
+}
+function getViewportSize(win) {
+	return {
+		width: win.visualViewport?.width || win.innerWidth,
+		height: win.visualViewport?.height || win.innerHeight
+	};
+}
+
+//#endregion
+//#region src/shared/dom-query/visually-hidden.ts
+const visuallyHiddenStyle = {
+	border: "0",
+	clip: "rect(0 0 0 0)",
+	height: "1px",
+	margin: "-1px",
+	overflow: "hidden",
+	padding: "0",
+	position: "absolute",
+	width: "1px",
+	whiteSpace: "nowrap",
+	wordWrap: "normal"
+};
+function setVisuallyHidden(el) {
+	Object.assign(el.style, visuallyHiddenStyle);
+}
+
+//#endregion
+//#region src/shared/dom-query/wait-for.ts
+function waitForPromise(promise, controller, timeout) {
+	const { signal } = controller;
+	const wrappedPromise = new Promise((resolve, reject) => {
+		const timeoutId = setTimeout(() => {
+			reject(/* @__PURE__ */ new Error(`Timeout of ${timeout}ms exceeded`));
+		}, timeout);
+		signal.addEventListener("abort", () => {
+			clearTimeout(timeoutId);
+			reject(/* @__PURE__ */ new Error("Promise aborted"));
+		});
+		promise.then((result) => {
+			if (!signal.aborted) {
+				clearTimeout(timeoutId);
+				resolve(result);
+			}
+		}).catch((error) => {
+			if (!signal.aborted) {
+				clearTimeout(timeoutId);
+				reject(error);
+			}
+		});
+	});
+	const abort = () => controller.abort();
+	return [wrappedPromise, abort];
+}
+function waitForElement(target, options) {
+	const { timeout, rootNode } = options;
+	const win = getWindow(rootNode);
+	const doc = getDocument(rootNode);
+	const controller = new win.AbortController();
+	return waitForPromise(new Promise((resolve) => {
+		const el = target();
+		if (el) {
+			resolve(el);
+			return;
+		}
+		const observer = new win.MutationObserver(() => {
+			const el$1 = target();
+			if (el$1 && el$1.isConnected) {
+				observer.disconnect();
+				resolve(el$1);
+			}
+		});
+		observer.observe(doc.body, {
+			childList: true,
+			subtree: true
+		});
+	}), controller, timeout);
+}
+
+//#endregion
+export { getTabbables as $, getDocumentElement as $t, getNearestOverflowAncestor as A, isApple as At, AnimationFrame as B, isWebKit as Bt, proxyTabFocus as C, isSelfTarget as Ct, restoreTextSelection as D, getPlatform as Dt, disableTextSelection as E, isVirtualPointerEvent as Et, scrollIntoView as F, isIPhone as Ft, isValidTabEvent as G, isControlledByExpandedController as Gt, queueBeforeEvent as H, findControlledElements as Ht, clickIfLink as I, isIos as It, getFocusables as J, isInteractiveContainerElement as Jt, getFirstFocusable as K, isControlledElement as Kt, navigate as L, isMac as Lt, getScrollPosition as M, isDom as Mt, isInView as N, isFirefox as Nt, requestPointerLock as O, getUserAgent as Ot, isOverflowElement as P, isIPad as Pt, getTabbableEdges as Q, getDocument as Qt, observeAttributes as R, isSafari as Rt, queryAll as S, isPrintableKey as St, trackPointerMove as T, isVirtualClick as Tt, raf as U, getControlledElements as Ut, nextTick as V, getDataUrl as Vt, getInitialFocus as W, hasControllerElements as Wt, getNextTabbable as X, contains as Xt, getLastTabbable as Y, getComputedStyle as Yt, getTabIndex as Z, getActiveElement as Zt, indexOfId as _, ariaAttr as _n, isDownloadingEvent as _t, trackVisualViewport as a, isAnchorElement as an, setElementValue as at, prevById as b, setCaretToEnd as bn, isModifierKey as bt, setProperty as c, isElementVisible as cn, getBeforeInputValue as ct, getByText as d, isNode as dn, getEventStep as dt, getNodeName as en, isFocusable as et, createScope as f, isRootElement as fn, getEventTarget as ft, defaultItemToId as g, MAX_Z_INDEX as gn, isCtrlOrMetaKey as gt, resizeObserverDevicePixelContentBox as h, isWindow as hn, isContextMenuEvent as ht, visuallyHiddenStyle as i, isActiveElement as in, setElementChecked as it, getOverflowAncestors as j, isChrome as jt, getRelativePoint as k, isAndroid as kt, setStyle as l, isHTMLElement as ln, getEventKey as lt, resizeObserverContentBox as m, isVisualViewport as mn, isComposingEvent as mt, waitForPromise as n, getRootNode as nn, dispatchInputCheckedEvent as nt, getByTypeahead as o, isDocument as on, trackFormControl as ot, resizeObserverBorderBox as p, isShadowRoot as pn, getNativeEvent as pt, getFirstTabbable as q, isControllerElement as qt, setVisuallyHidden as r, getWindow as rn, dispatchInputValueEvent as rt, setAttribute as s, isEditableElement as sn, addDomEvent as st, waitForElement as t, getParentNode as tn, isTabbable as tt, setStyleProperty as u, isInputElement as un, getEventPoint as ut, itemById as v, dataAttr as vn, isKeyboardClick as vt, trackPress as w, isTouchEvent as wt, query as x, isOpeningInNewTab as xt, nextById as y, isCaretAtStart as yn, isLeftClick as yt, observeChildren as z, isTouchDevice as zt };