@sprawlify/primitives 0.0.1

package/dist/dom-query-CWZdWUGp.cjs

@@ -0,0 +1,2141 @@
+const require_defineProperty = require('./defineProperty-BoUOT9Ie.cjs');
+
+//#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() {
+		require_defineProperty._defineProperty(this, "id", null);
+		require_defineProperty._defineProperty(this, "fn_cleanup", void 0);
+		require_defineProperty._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
+Object.defineProperty(exports, 'AnimationFrame', {
+  enumerable: true,
+  get: function () {
+    return AnimationFrame;
+  }
+});
+Object.defineProperty(exports, 'MAX_Z_INDEX', {
+  enumerable: true,
+  get: function () {
+    return MAX_Z_INDEX;
+  }
+});
+Object.defineProperty(exports, 'addDomEvent', {
+  enumerable: true,
+  get: function () {
+    return addDomEvent;
+  }
+});
+Object.defineProperty(exports, 'ariaAttr', {
+  enumerable: true,
+  get: function () {
+    return ariaAttr;
+  }
+});
+Object.defineProperty(exports, 'clickIfLink', {
+  enumerable: true,
+  get: function () {
+    return clickIfLink;
+  }
+});
+Object.defineProperty(exports, 'contains', {
+  enumerable: true,
+  get: function () {
+    return contains;
+  }
+});
+Object.defineProperty(exports, 'createScope', {
+  enumerable: true,
+  get: function () {
+    return createScope;
+  }
+});
+Object.defineProperty(exports, 'dataAttr', {
+  enumerable: true,
+  get: function () {
+    return dataAttr;
+  }
+});
+Object.defineProperty(exports, 'defaultItemToId', {
+  enumerable: true,
+  get: function () {
+    return defaultItemToId;
+  }
+});
+Object.defineProperty(exports, 'disableTextSelection', {
+  enumerable: true,
+  get: function () {
+    return disableTextSelection;
+  }
+});
+Object.defineProperty(exports, 'dispatchInputCheckedEvent', {
+  enumerable: true,
+  get: function () {
+    return dispatchInputCheckedEvent;
+  }
+});
+Object.defineProperty(exports, 'dispatchInputValueEvent', {
+  enumerable: true,
+  get: function () {
+    return dispatchInputValueEvent;
+  }
+});
+Object.defineProperty(exports, 'findControlledElements', {
+  enumerable: true,
+  get: function () {
+    return findControlledElements;
+  }
+});
+Object.defineProperty(exports, 'getActiveElement', {
+  enumerable: true,
+  get: function () {
+    return getActiveElement;
+  }
+});
+Object.defineProperty(exports, 'getBeforeInputValue', {
+  enumerable: true,
+  get: function () {
+    return getBeforeInputValue;
+  }
+});
+Object.defineProperty(exports, 'getByText', {
+  enumerable: true,
+  get: function () {
+    return getByText;
+  }
+});
+Object.defineProperty(exports, 'getByTypeahead', {
+  enumerable: true,
+  get: function () {
+    return getByTypeahead;
+  }
+});
+Object.defineProperty(exports, 'getComputedStyle', {
+  enumerable: true,
+  get: function () {
+    return getComputedStyle;
+  }
+});
+Object.defineProperty(exports, 'getControlledElements', {
+  enumerable: true,
+  get: function () {
+    return getControlledElements;
+  }
+});
+Object.defineProperty(exports, 'getDataUrl', {
+  enumerable: true,
+  get: function () {
+    return getDataUrl;
+  }
+});
+Object.defineProperty(exports, 'getDocument', {
+  enumerable: true,
+  get: function () {
+    return getDocument;
+  }
+});
+Object.defineProperty(exports, 'getDocumentElement', {
+  enumerable: true,
+  get: function () {
+    return getDocumentElement;
+  }
+});
+Object.defineProperty(exports, 'getEventKey', {
+  enumerable: true,
+  get: function () {
+    return getEventKey;
+  }
+});
+Object.defineProperty(exports, 'getEventPoint', {
+  enumerable: true,
+  get: function () {
+    return getEventPoint;
+  }
+});
+Object.defineProperty(exports, 'getEventStep', {
+  enumerable: true,
+  get: function () {
+    return getEventStep;
+  }
+});
+Object.defineProperty(exports, 'getEventTarget', {
+  enumerable: true,
+  get: function () {
+    return getEventTarget;
+  }
+});
+Object.defineProperty(exports, 'getFirstFocusable', {
+  enumerable: true,
+  get: function () {
+    return getFirstFocusable;
+  }
+});
+Object.defineProperty(exports, 'getFirstTabbable', {
+  enumerable: true,
+  get: function () {
+    return getFirstTabbable;
+  }
+});
+Object.defineProperty(exports, 'getFocusables', {
+  enumerable: true,
+  get: function () {
+    return getFocusables;
+  }
+});
+Object.defineProperty(exports, 'getInitialFocus', {
+  enumerable: true,
+  get: function () {
+    return getInitialFocus;
+  }
+});
+Object.defineProperty(exports, 'getLastTabbable', {
+  enumerable: true,
+  get: function () {
+    return getLastTabbable;
+  }
+});
+Object.defineProperty(exports, 'getNativeEvent', {
+  enumerable: true,
+  get: function () {
+    return getNativeEvent;
+  }
+});
+Object.defineProperty(exports, 'getNearestOverflowAncestor', {
+  enumerable: true,
+  get: function () {
+    return getNearestOverflowAncestor;
+  }
+});
+Object.defineProperty(exports, 'getNextTabbable', {
+  enumerable: true,
+  get: function () {
+    return getNextTabbable;
+  }
+});
+Object.defineProperty(exports, 'getNodeName', {
+  enumerable: true,
+  get: function () {
+    return getNodeName;
+  }
+});
+Object.defineProperty(exports, 'getOverflowAncestors', {
+  enumerable: true,
+  get: function () {
+    return getOverflowAncestors;
+  }
+});
+Object.defineProperty(exports, 'getParentNode', {
+  enumerable: true,
+  get: function () {
+    return getParentNode;
+  }
+});
+Object.defineProperty(exports, 'getPlatform', {
+  enumerable: true,
+  get: function () {
+    return getPlatform;
+  }
+});
+Object.defineProperty(exports, 'getRelativePoint', {
+  enumerable: true,
+  get: function () {
+    return getRelativePoint;
+  }
+});
+Object.defineProperty(exports, 'getRootNode', {
+  enumerable: true,
+  get: function () {
+    return getRootNode;
+  }
+});
+Object.defineProperty(exports, 'getScrollPosition', {
+  enumerable: true,
+  get: function () {
+    return getScrollPosition;
+  }
+});
+Object.defineProperty(exports, 'getTabIndex', {
+  enumerable: true,
+  get: function () {
+    return getTabIndex;
+  }
+});
+Object.defineProperty(exports, 'getTabbableEdges', {
+  enumerable: true,
+  get: function () {
+    return getTabbableEdges;
+  }
+});
+Object.defineProperty(exports, 'getTabbables', {
+  enumerable: true,
+  get: function () {
+    return getTabbables;
+  }
+});
+Object.defineProperty(exports, 'getUserAgent', {
+  enumerable: true,
+  get: function () {
+    return getUserAgent;
+  }
+});
+Object.defineProperty(exports, 'getWindow', {
+  enumerable: true,
+  get: function () {
+    return getWindow;
+  }
+});
+Object.defineProperty(exports, 'hasControllerElements', {
+  enumerable: true,
+  get: function () {
+    return hasControllerElements;
+  }
+});
+Object.defineProperty(exports, 'indexOfId', {
+  enumerable: true,
+  get: function () {
+    return indexOfId;
+  }
+});
+Object.defineProperty(exports, 'isActiveElement', {
+  enumerable: true,
+  get: function () {
+    return isActiveElement;
+  }
+});
+Object.defineProperty(exports, 'isAnchorElement', {
+  enumerable: true,
+  get: function () {
+    return isAnchorElement;
+  }
+});
+Object.defineProperty(exports, 'isAndroid', {
+  enumerable: true,
+  get: function () {
+    return isAndroid;
+  }
+});
+Object.defineProperty(exports, 'isApple', {
+  enumerable: true,
+  get: function () {
+    return isApple;
+  }
+});
+Object.defineProperty(exports, 'isCaretAtStart', {
+  enumerable: true,
+  get: function () {
+    return isCaretAtStart;
+  }
+});
+Object.defineProperty(exports, 'isChrome', {
+  enumerable: true,
+  get: function () {
+    return isChrome;
+  }
+});
+Object.defineProperty(exports, 'isComposingEvent', {
+  enumerable: true,
+  get: function () {
+    return isComposingEvent;
+  }
+});
+Object.defineProperty(exports, 'isContextMenuEvent', {
+  enumerable: true,
+  get: function () {
+    return isContextMenuEvent;
+  }
+});
+Object.defineProperty(exports, 'isControlledByExpandedController', {
+  enumerable: true,
+  get: function () {
+    return isControlledByExpandedController;
+  }
+});
+Object.defineProperty(exports, 'isControlledElement', {
+  enumerable: true,
+  get: function () {
+    return isControlledElement;
+  }
+});
+Object.defineProperty(exports, 'isControllerElement', {
+  enumerable: true,
+  get: function () {
+    return isControllerElement;
+  }
+});
+Object.defineProperty(exports, 'isCtrlOrMetaKey', {
+  enumerable: true,
+  get: function () {
+    return isCtrlOrMetaKey;
+  }
+});
+Object.defineProperty(exports, 'isDocument', {
+  enumerable: true,
+  get: function () {
+    return isDocument;
+  }
+});
+Object.defineProperty(exports, 'isDom', {
+  enumerable: true,
+  get: function () {
+    return isDom;
+  }
+});
+Object.defineProperty(exports, 'isDownloadingEvent', {
+  enumerable: true,
+  get: function () {
+    return isDownloadingEvent;
+  }
+});
+Object.defineProperty(exports, 'isEditableElement', {
+  enumerable: true,
+  get: function () {
+    return isEditableElement;
+  }
+});
+Object.defineProperty(exports, 'isElementVisible', {
+  enumerable: true,
+  get: function () {
+    return isElementVisible;
+  }
+});
+Object.defineProperty(exports, 'isFirefox', {
+  enumerable: true,
+  get: function () {
+    return isFirefox;
+  }
+});
+Object.defineProperty(exports, 'isFocusable', {
+  enumerable: true,
+  get: function () {
+    return isFocusable;
+  }
+});
+Object.defineProperty(exports, 'isHTMLElement', {
+  enumerable: true,
+  get: function () {
+    return isHTMLElement;
+  }
+});
+Object.defineProperty(exports, 'isIPad', {
+  enumerable: true,
+  get: function () {
+    return isIPad;
+  }
+});
+Object.defineProperty(exports, 'isIPhone', {
+  enumerable: true,
+  get: function () {
+    return isIPhone;
+  }
+});
+Object.defineProperty(exports, 'isInView', {
+  enumerable: true,
+  get: function () {
+    return isInView;
+  }
+});
+Object.defineProperty(exports, 'isInputElement', {
+  enumerable: true,
+  get: function () {
+    return isInputElement;
+  }
+});
+Object.defineProperty(exports, 'isInteractiveContainerElement', {
+  enumerable: true,
+  get: function () {
+    return isInteractiveContainerElement;
+  }
+});
+Object.defineProperty(exports, 'isIos', {
+  enumerable: true,
+  get: function () {
+    return isIos;
+  }
+});
+Object.defineProperty(exports, 'isKeyboardClick', {
+  enumerable: true,
+  get: function () {
+    return isKeyboardClick;
+  }
+});
+Object.defineProperty(exports, 'isLeftClick', {
+  enumerable: true,
+  get: function () {
+    return isLeftClick;
+  }
+});
+Object.defineProperty(exports, 'isMac', {
+  enumerable: true,
+  get: function () {
+    return isMac;
+  }
+});
+Object.defineProperty(exports, 'isModifierKey', {
+  enumerable: true,
+  get: function () {
+    return isModifierKey;
+  }
+});
+Object.defineProperty(exports, 'isNode', {
+  enumerable: true,
+  get: function () {
+    return isNode;
+  }
+});
+Object.defineProperty(exports, 'isOpeningInNewTab', {
+  enumerable: true,
+  get: function () {
+    return isOpeningInNewTab;
+  }
+});
+Object.defineProperty(exports, 'isOverflowElement', {
+  enumerable: true,
+  get: function () {
+    return isOverflowElement;
+  }
+});
+Object.defineProperty(exports, 'isPrintableKey', {
+  enumerable: true,
+  get: function () {
+    return isPrintableKey;
+  }
+});
+Object.defineProperty(exports, 'isRootElement', {
+  enumerable: true,
+  get: function () {
+    return isRootElement;
+  }
+});
+Object.defineProperty(exports, 'isSafari', {
+  enumerable: true,
+  get: function () {
+    return isSafari;
+  }
+});
+Object.defineProperty(exports, 'isSelfTarget', {
+  enumerable: true,
+  get: function () {
+    return isSelfTarget;
+  }
+});
+Object.defineProperty(exports, 'isShadowRoot', {
+  enumerable: true,
+  get: function () {
+    return isShadowRoot;
+  }
+});
+Object.defineProperty(exports, 'isTabbable', {
+  enumerable: true,
+  get: function () {
+    return isTabbable;
+  }
+});
+Object.defineProperty(exports, 'isTouchDevice', {
+  enumerable: true,
+  get: function () {
+    return isTouchDevice;
+  }
+});
+Object.defineProperty(exports, 'isTouchEvent', {
+  enumerable: true,
+  get: function () {
+    return isTouchEvent;
+  }
+});
+Object.defineProperty(exports, 'isValidTabEvent', {
+  enumerable: true,
+  get: function () {
+    return isValidTabEvent;
+  }
+});
+Object.defineProperty(exports, 'isVirtualClick', {
+  enumerable: true,
+  get: function () {
+    return isVirtualClick;
+  }
+});
+Object.defineProperty(exports, 'isVirtualPointerEvent', {
+  enumerable: true,
+  get: function () {
+    return isVirtualPointerEvent;
+  }
+});
+Object.defineProperty(exports, 'isVisualViewport', {
+  enumerable: true,
+  get: function () {
+    return isVisualViewport;
+  }
+});
+Object.defineProperty(exports, 'isWebKit', {
+  enumerable: true,
+  get: function () {
+    return isWebKit;
+  }
+});
+Object.defineProperty(exports, 'isWindow', {
+  enumerable: true,
+  get: function () {
+    return isWindow;
+  }
+});
+Object.defineProperty(exports, 'itemById', {
+  enumerable: true,
+  get: function () {
+    return itemById;
+  }
+});
+Object.defineProperty(exports, 'navigate', {
+  enumerable: true,
+  get: function () {
+    return navigate;
+  }
+});
+Object.defineProperty(exports, 'nextById', {
+  enumerable: true,
+  get: function () {
+    return nextById;
+  }
+});
+Object.defineProperty(exports, 'nextTick', {
+  enumerable: true,
+  get: function () {
+    return nextTick;
+  }
+});
+Object.defineProperty(exports, 'observeAttributes', {
+  enumerable: true,
+  get: function () {
+    return observeAttributes;
+  }
+});
+Object.defineProperty(exports, 'observeChildren', {
+  enumerable: true,
+  get: function () {
+    return observeChildren;
+  }
+});
+Object.defineProperty(exports, 'prevById', {
+  enumerable: true,
+  get: function () {
+    return prevById;
+  }
+});
+Object.defineProperty(exports, 'proxyTabFocus', {
+  enumerable: true,
+  get: function () {
+    return proxyTabFocus;
+  }
+});
+Object.defineProperty(exports, 'query', {
+  enumerable: true,
+  get: function () {
+    return query;
+  }
+});
+Object.defineProperty(exports, 'queryAll', {
+  enumerable: true,
+  get: function () {
+    return queryAll;
+  }
+});
+Object.defineProperty(exports, 'queueBeforeEvent', {
+  enumerable: true,
+  get: function () {
+    return queueBeforeEvent;
+  }
+});
+Object.defineProperty(exports, 'raf', {
+  enumerable: true,
+  get: function () {
+    return raf;
+  }
+});
+Object.defineProperty(exports, 'requestPointerLock', {
+  enumerable: true,
+  get: function () {
+    return requestPointerLock;
+  }
+});
+Object.defineProperty(exports, 'resizeObserverBorderBox', {
+  enumerable: true,
+  get: function () {
+    return resizeObserverBorderBox;
+  }
+});
+Object.defineProperty(exports, 'resizeObserverContentBox', {
+  enumerable: true,
+  get: function () {
+    return resizeObserverContentBox;
+  }
+});
+Object.defineProperty(exports, 'resizeObserverDevicePixelContentBox', {
+  enumerable: true,
+  get: function () {
+    return resizeObserverDevicePixelContentBox;
+  }
+});
+Object.defineProperty(exports, 'restoreTextSelection', {
+  enumerable: true,
+  get: function () {
+    return restoreTextSelection;
+  }
+});
+Object.defineProperty(exports, 'scrollIntoView', {
+  enumerable: true,
+  get: function () {
+    return scrollIntoView;
+  }
+});
+Object.defineProperty(exports, 'setAttribute', {
+  enumerable: true,
+  get: function () {
+    return setAttribute;
+  }
+});
+Object.defineProperty(exports, 'setCaretToEnd', {
+  enumerable: true,
+  get: function () {
+    return setCaretToEnd;
+  }
+});
+Object.defineProperty(exports, 'setElementChecked', {
+  enumerable: true,
+  get: function () {
+    return setElementChecked;
+  }
+});
+Object.defineProperty(exports, 'setElementValue', {
+  enumerable: true,
+  get: function () {
+    return setElementValue;
+  }
+});
+Object.defineProperty(exports, 'setProperty', {
+  enumerable: true,
+  get: function () {
+    return setProperty;
+  }
+});
+Object.defineProperty(exports, 'setStyle', {
+  enumerable: true,
+  get: function () {
+    return setStyle;
+  }
+});
+Object.defineProperty(exports, 'setStyleProperty', {
+  enumerable: true,
+  get: function () {
+    return setStyleProperty;
+  }
+});
+Object.defineProperty(exports, 'setVisuallyHidden', {
+  enumerable: true,
+  get: function () {
+    return setVisuallyHidden;
+  }
+});
+Object.defineProperty(exports, 'trackFormControl', {
+  enumerable: true,
+  get: function () {
+    return trackFormControl;
+  }
+});
+Object.defineProperty(exports, 'trackPointerMove', {
+  enumerable: true,
+  get: function () {
+    return trackPointerMove;
+  }
+});
+Object.defineProperty(exports, 'trackPress', {
+  enumerable: true,
+  get: function () {
+    return trackPress;
+  }
+});
+Object.defineProperty(exports, 'trackVisualViewport', {
+  enumerable: true,
+  get: function () {
+    return trackVisualViewport;
+  }
+});
+Object.defineProperty(exports, 'visuallyHiddenStyle', {
+  enumerable: true,
+  get: function () {
+    return visuallyHiddenStyle;
+  }
+});
+Object.defineProperty(exports, 'waitForElement', {
+  enumerable: true,
+  get: function () {
+    return waitForElement;
+  }
+});
+Object.defineProperty(exports, 'waitForPromise', {
+  enumerable: true,
+  get: function () {
+    return waitForPromise;
+  }
+});