@sprawlify/primitives 0.0.1

package/dist/focus-trap-D4i52S9A.cjs

@@ -0,0 +1,496 @@
+const require_dom_query = require('./dom-query-CWZdWUGp.cjs');
+const require_defineProperty = require('./defineProperty-BoUOT9Ie.cjs');
+
+//#region src/shared/focus-trap/focus-trap.ts
+const activeFocusTraps = {
+	activateTrap(trapStack, trap) {
+		if (trapStack.length > 0) {
+			const activeTrap = trapStack[trapStack.length - 1];
+			if (activeTrap !== trap) activeTrap.pause();
+		}
+		const trapIndex = trapStack.indexOf(trap);
+		if (trapIndex === -1) trapStack.push(trap);
+		else {
+			trapStack.splice(trapIndex, 1);
+			trapStack.push(trap);
+		}
+	},
+	deactivateTrap(trapStack, trap) {
+		const trapIndex = trapStack.indexOf(trap);
+		if (trapIndex !== -1) trapStack.splice(trapIndex, 1);
+		if (trapStack.length > 0) trapStack[trapStack.length - 1].unpause();
+	}
+};
+const sharedTrapStack = [];
+var FocusTrap = class {
+	addPortalContainer(controlledElement) {
+		const portalContainer = controlledElement.parentElement;
+		if (portalContainer && !this.portalContainers.has(portalContainer)) {
+			this.portalContainers.add(portalContainer);
+			if (this.state.active && !this.state.paused) this.observePortalContainer(portalContainer);
+		}
+	}
+	observePortalContainer(portalContainer) {
+		this._mutationObserver?.observe(portalContainer, {
+			subtree: true,
+			childList: true,
+			attributes: true,
+			attributeFilter: ["aria-controls", "aria-expanded"]
+		});
+	}
+	updatePortalContainers() {
+		if (!this.config.followControlledElements) return;
+		this.state.containers.forEach((container) => {
+			require_dom_query.getControlledElements(container).forEach((controlledElement) => {
+				this.addPortalContainer(controlledElement);
+			});
+		});
+	}
+	get active() {
+		return this.state.active;
+	}
+	get paused() {
+		return this.state.paused;
+	}
+	constructor(elements, options) {
+		require_defineProperty._defineProperty(this, "trapStack", void 0);
+		require_defineProperty._defineProperty(this, "config", void 0);
+		require_defineProperty._defineProperty(this, "doc", void 0);
+		require_defineProperty._defineProperty(this, "state", {
+			containers: [],
+			containerGroups: [],
+			tabbableGroups: [],
+			nodeFocusedBeforeActivation: null,
+			mostRecentlyFocusedNode: null,
+			active: false,
+			paused: false,
+			delayInitialFocusTimer: void 0,
+			recentNavEvent: void 0
+		});
+		require_defineProperty._defineProperty(this, "portalContainers", /* @__PURE__ */ new Set());
+		require_defineProperty._defineProperty(this, "listenerCleanups", []);
+		require_defineProperty._defineProperty(this, "handleFocus", (event) => {
+			const target = require_dom_query.getEventTarget(event);
+			const targetContained = this.findContainerIndex(target, event) >= 0;
+			if (targetContained || require_dom_query.isDocument(target)) {
+				if (targetContained) this.state.mostRecentlyFocusedNode = target;
+			} else {
+				event.stopImmediatePropagation();
+				let nextNode;
+				let navAcrossContainers = true;
+				if (this.state.mostRecentlyFocusedNode) {
+					if (require_dom_query.getTabIndex(this.state.mostRecentlyFocusedNode) > 0) {
+						const mruContainerIdx = this.findContainerIndex(this.state.mostRecentlyFocusedNode);
+						const { tabbableNodes } = this.state.containerGroups[mruContainerIdx];
+						if (tabbableNodes.length > 0) {
+							const mruTabIdx = tabbableNodes.findIndex((node) => node === this.state.mostRecentlyFocusedNode);
+							if (mruTabIdx >= 0) {
+								if (this.config.isKeyForward(this.state.recentNavEvent)) {
+									if (mruTabIdx + 1 < tabbableNodes.length) {
+										nextNode = tabbableNodes[mruTabIdx + 1];
+										navAcrossContainers = false;
+									}
+								} else if (mruTabIdx - 1 >= 0) {
+									nextNode = tabbableNodes[mruTabIdx - 1];
+									navAcrossContainers = false;
+								}
+							}
+						}
+					} else if (!this.state.containerGroups.some((g) => g.tabbableNodes.some((n) => require_dom_query.getTabIndex(n) > 0))) navAcrossContainers = false;
+				} else navAcrossContainers = false;
+				if (navAcrossContainers) nextNode = this.findNextNavNode({
+					target: this.state.mostRecentlyFocusedNode,
+					isBackward: this.config.isKeyBackward(this.state.recentNavEvent)
+				});
+				if (nextNode) this.tryFocus(nextNode);
+				else this.tryFocus(this.state.mostRecentlyFocusedNode || this.getInitialFocusNode());
+			}
+			this.state.recentNavEvent = void 0;
+		});
+		require_defineProperty._defineProperty(this, "handlePointerDown", (event) => {
+			const target = require_dom_query.getEventTarget(event);
+			if (this.findContainerIndex(target, event) >= 0) return;
+			if (valueOrHandler(this.config.clickOutsideDeactivates, event)) {
+				this.deactivate({ returnFocus: this.config.returnFocusOnDeactivate });
+				return;
+			}
+			if (valueOrHandler(this.config.allowOutsideClick, event)) return;
+			event.preventDefault();
+		});
+		require_defineProperty._defineProperty(this, "handleClick", (event) => {
+			const target = require_dom_query.getEventTarget(event);
+			if (this.findContainerIndex(target, event) >= 0) return;
+			if (valueOrHandler(this.config.clickOutsideDeactivates, event)) return;
+			if (valueOrHandler(this.config.allowOutsideClick, event)) return;
+			event.preventDefault();
+			event.stopImmediatePropagation();
+		});
+		require_defineProperty._defineProperty(this, "handleTabKey", (event) => {
+			if (this.config.isKeyForward(event) || this.config.isKeyBackward(event)) {
+				this.state.recentNavEvent = event;
+				const isBackward = this.config.isKeyBackward(event);
+				const destinationNode = this.findNextNavNode({
+					event,
+					isBackward
+				});
+				if (!destinationNode) return;
+				if (isTabEvent(event)) event.preventDefault();
+				this.tryFocus(destinationNode);
+			}
+		});
+		require_defineProperty._defineProperty(this, "handleEscapeKey", (event) => {
+			if (isEscapeEvent(event) && valueOrHandler(this.config.escapeDeactivates, event) !== false) {
+				event.preventDefault();
+				this.deactivate();
+			}
+		});
+		require_defineProperty._defineProperty(this, "_mutationObserver", void 0);
+		require_defineProperty._defineProperty(this, "setupMutationObserver", () => {
+			this._mutationObserver = new (this.doc.defaultView || window).MutationObserver((mutations) => {
+				if (mutations.some((mutation) => {
+					return Array.from(mutation.removedNodes).some((node) => node === this.state.mostRecentlyFocusedNode);
+				})) this.tryFocus(this.getInitialFocusNode());
+				if (mutations.some((mutation) => {
+					if (mutation.type === "attributes" && (mutation.attributeName === "aria-controls" || mutation.attributeName === "aria-expanded")) return true;
+					if (mutation.type === "childList" && mutation.addedNodes.length > 0) return Array.from(mutation.addedNodes).some((node) => {
+						if (node.nodeType !== Node.ELEMENT_NODE) return false;
+						const element = node;
+						if (require_dom_query.hasControllerElements(element)) return true;
+						if (element.id && !this.state.containers.some((c) => c.contains(element))) return require_dom_query.isControlledByExpandedController(element);
+						return false;
+					});
+					return false;
+				}) && this.state.active && !this.state.paused) {
+					this.updateTabbableNodes();
+					this.updatePortalContainers();
+				}
+			});
+		});
+		require_defineProperty._defineProperty(this, "updateObservedNodes", () => {
+			this._mutationObserver?.disconnect();
+			if (this.state.active && !this.state.paused) {
+				this.state.containers.map((container) => {
+					this._mutationObserver?.observe(container, {
+						subtree: true,
+						childList: true,
+						attributes: true,
+						attributeFilter: ["aria-controls", "aria-expanded"]
+					});
+				});
+				this.portalContainers.forEach((portalContainer) => {
+					this.observePortalContainer(portalContainer);
+				});
+			}
+		});
+		require_defineProperty._defineProperty(this, "getInitialFocusNode", () => {
+			let node = this.getNodeForOption("initialFocus", { hasFallback: true });
+			if (node === false) return false;
+			if (node === void 0 || node && !require_dom_query.isFocusable(node)) {
+				const activeElement = require_dom_query.getActiveElement(this.doc);
+				if (activeElement && this.findContainerIndex(activeElement) >= 0) node = activeElement;
+				else {
+					const firstTabbableGroup = this.state.tabbableGroups[0];
+					node = firstTabbableGroup && firstTabbableGroup.firstTabbableNode || this.getNodeForOption("fallbackFocus");
+				}
+			} else if (node === null) node = this.getNodeForOption("fallbackFocus");
+			if (!node) throw new Error("Your focus-trap needs to have at least one focusable element");
+			if (!node.isConnected) node = this.getNodeForOption("fallbackFocus");
+			return node;
+		});
+		require_defineProperty._defineProperty(this, "tryFocus", (node) => {
+			if (node === false) return;
+			if (node === require_dom_query.getActiveElement(this.doc)) return;
+			if (!node || !node.focus) {
+				this.tryFocus(this.getInitialFocusNode());
+				return;
+			}
+			node.focus({ preventScroll: !!this.config.preventScroll });
+			this.state.mostRecentlyFocusedNode = node;
+			if (isSelectableInput(node)) node.select();
+		});
+		require_defineProperty._defineProperty(this, "deactivate", (deactivateOptions) => {
+			if (!this.state.active) return this;
+			const options$1 = {
+				onDeactivate: this.config.onDeactivate,
+				onPostDeactivate: this.config.onPostDeactivate,
+				checkCanReturnFocus: this.config.checkCanReturnFocus,
+				...deactivateOptions
+			};
+			clearTimeout(this.state.delayInitialFocusTimer);
+			this.state.delayInitialFocusTimer = void 0;
+			this.removeListeners();
+			this.state.active = false;
+			this.state.paused = false;
+			this.updateObservedNodes();
+			activeFocusTraps.deactivateTrap(this.trapStack, this);
+			this.portalContainers.clear();
+			const onDeactivate = this.getOption(options$1, "onDeactivate");
+			const onPostDeactivate = this.getOption(options$1, "onPostDeactivate");
+			const checkCanReturnFocus = this.getOption(options$1, "checkCanReturnFocus");
+			const returnFocus = this.getOption(options$1, "returnFocus", "returnFocusOnDeactivate");
+			onDeactivate?.();
+			const finishDeactivation = () => {
+				delay(() => {
+					if (returnFocus) {
+						const returnFocusNode = this.getReturnFocusNode(this.state.nodeFocusedBeforeActivation);
+						this.tryFocus(returnFocusNode);
+					}
+					onPostDeactivate?.();
+				});
+			};
+			if (returnFocus && checkCanReturnFocus) {
+				checkCanReturnFocus(this.getReturnFocusNode(this.state.nodeFocusedBeforeActivation)).then(finishDeactivation, finishDeactivation);
+				return this;
+			}
+			finishDeactivation();
+			return this;
+		});
+		require_defineProperty._defineProperty(this, "pause", (pauseOptions) => {
+			if (this.state.paused || !this.state.active) return this;
+			const onPause = this.getOption(pauseOptions, "onPause");
+			const onPostPause = this.getOption(pauseOptions, "onPostPause");
+			this.state.paused = true;
+			onPause?.();
+			this.removeListeners();
+			this.updateObservedNodes();
+			onPostPause?.();
+			return this;
+		});
+		require_defineProperty._defineProperty(this, "unpause", (unpauseOptions) => {
+			if (!this.state.paused || !this.state.active) return this;
+			const onUnpause = this.getOption(unpauseOptions, "onUnpause");
+			const onPostUnpause = this.getOption(unpauseOptions, "onPostUnpause");
+			this.state.paused = false;
+			onUnpause?.();
+			this.updateTabbableNodes();
+			this.addListeners();
+			this.updateObservedNodes();
+			onPostUnpause?.();
+			return this;
+		});
+		require_defineProperty._defineProperty(this, "updateContainerElements", (containerElements) => {
+			this.state.containers = Array.isArray(containerElements) ? containerElements.filter(Boolean) : [containerElements].filter(Boolean);
+			if (this.state.active) this.updateTabbableNodes();
+			this.updateObservedNodes();
+			return this;
+		});
+		require_defineProperty._defineProperty(this, "getReturnFocusNode", (previousActiveElement) => {
+			const node = this.getNodeForOption("setReturnFocus", { params: [previousActiveElement] });
+			return node ? node : node === false ? false : previousActiveElement;
+		});
+		require_defineProperty._defineProperty(this, "getOption", (configOverrideOptions, optionName, configOptionName) => {
+			return configOverrideOptions && configOverrideOptions[optionName] !== void 0 ? configOverrideOptions[optionName] : this.config[configOptionName || optionName];
+		});
+		require_defineProperty._defineProperty(this, "getNodeForOption", (optionName, { hasFallback = false, params = [] } = {}) => {
+			let optionValue = this.config[optionName];
+			if (typeof optionValue === "function") optionValue = optionValue(...params);
+			if (optionValue === true) optionValue = void 0;
+			if (!optionValue) {
+				if (optionValue === void 0 || optionValue === false) return optionValue;
+				throw new Error(`\`${optionName}\` was specified but was not a node, or did not return a node`);
+			}
+			let node = optionValue;
+			if (typeof optionValue === "string") {
+				try {
+					node = this.doc.querySelector(optionValue);
+				} catch (err) {
+					throw new Error(`\`${optionName}\` appears to be an invalid selector; error="${err.message}"`);
+				}
+				if (!node) {
+					if (!hasFallback) throw new Error(`\`${optionName}\` as selector refers to no known node`);
+				}
+			}
+			return node;
+		});
+		require_defineProperty._defineProperty(this, "findNextNavNode", (opts) => {
+			const { event, isBackward = false } = opts;
+			const target = opts.target || require_dom_query.getEventTarget(event);
+			this.updateTabbableNodes();
+			let destinationNode = null;
+			if (this.state.tabbableGroups.length > 0) {
+				const containerIndex = this.findContainerIndex(target, event);
+				const containerGroup = containerIndex >= 0 ? this.state.containerGroups[containerIndex] : void 0;
+				if (containerIndex < 0) if (isBackward) destinationNode = this.state.tabbableGroups[this.state.tabbableGroups.length - 1].lastTabbableNode;
+				else destinationNode = this.state.tabbableGroups[0].firstTabbableNode;
+				else if (isBackward) {
+					let startOfGroupIndex = this.state.tabbableGroups.findIndex(({ firstTabbableNode }) => target === firstTabbableNode);
+					if (startOfGroupIndex < 0 && (containerGroup?.container === target || require_dom_query.isFocusable(target) && !require_dom_query.isTabbable(target) && !containerGroup?.nextTabbableNode(target, false))) startOfGroupIndex = containerIndex;
+					if (startOfGroupIndex >= 0) {
+						const destinationGroupIndex = startOfGroupIndex === 0 ? this.state.tabbableGroups.length - 1 : startOfGroupIndex - 1;
+						const destinationGroup = this.state.tabbableGroups[destinationGroupIndex];
+						destinationNode = require_dom_query.getTabIndex(target) >= 0 ? destinationGroup.lastTabbableNode : destinationGroup.lastDomTabbableNode;
+					} else if (!isTabEvent(event)) destinationNode = containerGroup?.nextTabbableNode(target, false);
+				} else {
+					let lastOfGroupIndex = this.state.tabbableGroups.findIndex(({ lastTabbableNode }) => target === lastTabbableNode);
+					if (lastOfGroupIndex < 0 && (containerGroup?.container === target || require_dom_query.isFocusable(target) && !require_dom_query.isTabbable(target) && !containerGroup?.nextTabbableNode(target))) lastOfGroupIndex = containerIndex;
+					if (lastOfGroupIndex >= 0) {
+						const destinationGroupIndex = lastOfGroupIndex === this.state.tabbableGroups.length - 1 ? 0 : lastOfGroupIndex + 1;
+						const destinationGroup = this.state.tabbableGroups[destinationGroupIndex];
+						destinationNode = require_dom_query.getTabIndex(target) >= 0 ? destinationGroup.firstTabbableNode : destinationGroup.firstDomTabbableNode;
+					} else if (!isTabEvent(event)) destinationNode = containerGroup?.nextTabbableNode(target);
+				}
+			} else destinationNode = this.getNodeForOption("fallbackFocus");
+			return destinationNode;
+		});
+		this.trapStack = options.trapStack || sharedTrapStack;
+		const config = {
+			returnFocusOnDeactivate: true,
+			escapeDeactivates: true,
+			delayInitialFocus: true,
+			followControlledElements: true,
+			isKeyForward(e) {
+				return isTabEvent(e) && !e.shiftKey;
+			},
+			isKeyBackward(e) {
+				return isTabEvent(e) && e.shiftKey;
+			},
+			...options
+		};
+		this.doc = config.document || require_dom_query.getDocument(Array.isArray(elements) ? elements[0] : elements);
+		this.config = config;
+		this.updateContainerElements(elements);
+		this.setupMutationObserver();
+	}
+	findContainerIndex(element, event) {
+		const composedPath = typeof event?.composedPath === "function" ? event.composedPath() : void 0;
+		return this.state.containerGroups.findIndex(({ container, tabbableNodes }) => container.contains(element) || composedPath?.includes(container) || tabbableNodes.find((node) => node === element) || this.isControlledElement(container, element));
+	}
+	isControlledElement(container, element) {
+		if (!this.config.followControlledElements) return false;
+		return require_dom_query.isControlledElement(container, element);
+	}
+	updateTabbableNodes() {
+		this.state.containerGroups = this.state.containers.map((container) => {
+			const tabbableNodes = require_dom_query.getTabbables(container, { getShadowRoot: this.config.getShadowRoot });
+			const focusableNodes = require_dom_query.getFocusables(container, { getShadowRoot: this.config.getShadowRoot });
+			const firstTabbableNode = tabbableNodes[0];
+			const lastTabbableNode = tabbableNodes[tabbableNodes.length - 1];
+			const firstDomTabbableNode = firstTabbableNode;
+			const lastDomTabbableNode = lastTabbableNode;
+			let posTabIndexesFound = false;
+			for (let i = 0; i < tabbableNodes.length; i++) if (require_dom_query.getTabIndex(tabbableNodes[i]) > 0) {
+				posTabIndexesFound = true;
+				break;
+			}
+			function nextTabbableNode(node, forward = true) {
+				const nodeIdx = tabbableNodes.indexOf(node);
+				if (nodeIdx >= 0) return tabbableNodes[nodeIdx + (forward ? 1 : -1)];
+				const focusableIdx = focusableNodes.indexOf(node);
+				if (focusableIdx < 0) return void 0;
+				if (forward) {
+					for (let i = focusableIdx + 1; i < focusableNodes.length; i++) if (require_dom_query.isTabbable(focusableNodes[i])) return focusableNodes[i];
+				} else for (let i = focusableIdx - 1; i >= 0; i--) if (require_dom_query.isTabbable(focusableNodes[i])) return focusableNodes[i];
+			}
+			return {
+				container,
+				tabbableNodes,
+				focusableNodes,
+				posTabIndexesFound,
+				firstTabbableNode,
+				lastTabbableNode,
+				firstDomTabbableNode,
+				lastDomTabbableNode,
+				nextTabbableNode
+			};
+		});
+		this.state.tabbableGroups = this.state.containerGroups.filter((group) => group.tabbableNodes.length > 0);
+		if (this.state.tabbableGroups.length <= 0 && !this.getNodeForOption("fallbackFocus")) throw new Error("Your focus-trap must have at least one container with at least one tabbable node in it at all times");
+		if (this.state.containerGroups.find((g) => g.posTabIndexesFound) && this.state.containerGroups.length > 1) throw new Error("At least one node with a positive tabindex was found in one of your focus-trap's multiple containers. Positive tabindexes are only supported in single-container focus-traps.");
+	}
+	addListeners() {
+		if (!this.state.active) return;
+		activeFocusTraps.activateTrap(this.trapStack, this);
+		this.state.delayInitialFocusTimer = this.config.delayInitialFocus ? delay(() => {
+			this.tryFocus(this.getInitialFocusNode());
+		}) : this.tryFocus(this.getInitialFocusNode());
+		this.listenerCleanups.push(require_dom_query.addDomEvent(this.doc, "focusin", this.handleFocus, true), require_dom_query.addDomEvent(this.doc, "mousedown", this.handlePointerDown, {
+			capture: true,
+			passive: false
+		}), require_dom_query.addDomEvent(this.doc, "touchstart", this.handlePointerDown, {
+			capture: true,
+			passive: false
+		}), require_dom_query.addDomEvent(this.doc, "click", this.handleClick, {
+			capture: true,
+			passive: false
+		}), require_dom_query.addDomEvent(this.doc, "keydown", this.handleTabKey, {
+			capture: true,
+			passive: false
+		}), require_dom_query.addDomEvent(this.doc, "keydown", this.handleEscapeKey));
+		return this;
+	}
+	removeListeners() {
+		if (!this.state.active) return;
+		this.listenerCleanups.forEach((cleanup) => cleanup());
+		this.listenerCleanups = [];
+		return this;
+	}
+	activate(activateOptions) {
+		if (this.state.active) return this;
+		const onActivate = this.getOption(activateOptions, "onActivate");
+		const onPostActivate = this.getOption(activateOptions, "onPostActivate");
+		const checkCanFocusTrap = this.getOption(activateOptions, "checkCanFocusTrap");
+		if (!checkCanFocusTrap) this.updateTabbableNodes();
+		this.state.active = true;
+		this.state.paused = false;
+		this.state.nodeFocusedBeforeActivation = require_dom_query.getActiveElement(this.doc);
+		onActivate?.();
+		const finishActivation = () => {
+			if (checkCanFocusTrap) this.updateTabbableNodes();
+			this.addListeners();
+			this.updateObservedNodes();
+			onPostActivate?.();
+		};
+		if (checkCanFocusTrap) {
+			checkCanFocusTrap(this.state.containers.concat()).then(finishActivation, finishActivation);
+			return this;
+		}
+		finishActivation();
+		return this;
+	}
+};
+const isTabEvent = (event) => event.key === "Tab";
+const valueOrHandler = (value, ...params) => typeof value === "function" ? value(...params) : value;
+const isEscapeEvent = (event) => !event.isComposing && event.key === "Escape";
+const delay = (fn) => setTimeout(fn, 0);
+const isSelectableInput = (node) => node.localName === "input" && "select" in node && typeof node.select === "function";
+
+//#endregion
+//#region src/shared/focus-trap/index.ts
+function trapFocus(el, options = {}) {
+	let trap;
+	const cleanup = require_dom_query.raf(() => {
+		const contentEl = typeof el === "function" ? el() : el;
+		if (!contentEl) return;
+		trap = new FocusTrap(contentEl, {
+			escapeDeactivates: false,
+			allowOutsideClick: true,
+			preventScroll: true,
+			returnFocusOnDeactivate: true,
+			delayInitialFocus: false,
+			fallbackFocus: contentEl,
+			...options,
+			document: require_dom_query.getDocument(contentEl)
+		});
+		try {
+			trap.activate();
+		} catch {}
+	});
+	return function destroy() {
+		trap?.deactivate();
+		cleanup();
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'FocusTrap', {
+  enumerable: true,
+  get: function () {
+    return FocusTrap;
+  }
+});
+Object.defineProperty(exports, 'trapFocus', {
+  enumerable: true,
+  get: function () {
+    return trapFocus;
+  }
+});

package/dist/focus-trap.cjs

@@ -0,0 +1,5 @@
+require('./dom-query-CWZdWUGp.cjs');
+const require_focus_trap = require('./focus-trap-D4i52S9A.cjs');
+
+exports.FocusTrap = require_focus_trap.FocusTrap;
+exports.trapFocus = require_focus_trap.trapFocus;

package/dist/focus-trap.d.cts

@@ -0,0 +1,88 @@
+//#region src/shared/focus-trap/types.d.ts
+type FocusableElement = HTMLElement | SVGElement;
+type FocusTargetValue = FocusableElement | string;
+type FocusTargetValueOrFalse = FocusTargetValue | false;
+type FocusTarget = FocusTargetValue | (() => FocusTargetValue);
+type FocusTargetOrFalse = FocusTargetValueOrFalse | (() => FocusTargetValueOrFalse);
+type MouseEventToBoolean = (event: MouseEvent | TouchEvent) => boolean;
+type KeyboardEventToBoolean = (event: KeyboardEvent) => boolean;
+interface FocusTrapOptions {
+  onActivate?: VoidFunction | undefined;
+  onPostActivate?: VoidFunction | undefined;
+  onPause?: VoidFunction | undefined;
+  onPostPause?: VoidFunction | undefined;
+  onUnpause?: VoidFunction | undefined;
+  onPostUnpause?: VoidFunction | undefined;
+  checkCanFocusTrap?: ((containers: Array<HTMLElement | SVGElement>) => Promise<void>) | undefined;
+  onDeactivate?: VoidFunction | undefined;
+  onPostDeactivate?: VoidFunction | undefined;
+  checkCanReturnFocus?: ((trigger: HTMLElement | SVGElement) => Promise<void>) | undefined;
+  initialFocus?: FocusTargetOrFalse | undefined | VoidFunction;
+  fallbackFocus?: FocusTarget | undefined;
+  returnFocusOnDeactivate?: boolean | undefined;
+  setReturnFocus?: FocusTargetValueOrFalse | ((nodeFocusedBeforeActivation: HTMLElement | SVGElement) => FocusTargetValueOrFalse) | undefined;
+  escapeDeactivates?: boolean | KeyboardEventToBoolean | undefined;
+  clickOutsideDeactivates?: boolean | MouseEventToBoolean | undefined;
+  allowOutsideClick?: boolean | MouseEventToBoolean | undefined;
+  preventScroll?: boolean | undefined;
+  delayInitialFocus?: boolean | undefined;
+  document?: Document | undefined;
+  isKeyForward?: KeyboardEventToBoolean | undefined;
+  isKeyBackward?: KeyboardEventToBoolean | undefined;
+  trapStack?: any[] | undefined;
+  followControlledElements?: boolean | undefined;
+  getShadowRoot?: boolean | ((node: FocusableElement) => ShadowRoot | boolean | undefined) | undefined;
+}
+interface DeactivateOptions extends Pick<FocusTrapOptions, "onDeactivate" | "onPostDeactivate" | "checkCanReturnFocus"> {
+  returnFocus?: boolean | undefined;
+}
+type ActivateOptions = Pick<FocusTrapOptions, "onActivate" | "onPostActivate" | "checkCanFocusTrap">;
+type PauseOptions = Pick<FocusTrapOptions, "onPause" | "onPostPause">;
+type UnpauseOptions = Pick<FocusTrapOptions, "onUnpause" | "onPostUnpause">;
+//#endregion
+//#region src/shared/focus-trap/focus-trap.d.ts
+declare class FocusTrap {
+  private trapStack;
+  private config;
+  private doc;
+  private state;
+  private portalContainers;
+  private addPortalContainer;
+  private observePortalContainer;
+  private updatePortalContainers;
+  get active(): boolean;
+  get paused(): boolean;
+  constructor(elements: HTMLElement | HTMLElement[], options: FocusTrapOptions);
+  private findContainerIndex;
+  private isControlledElement;
+  private updateTabbableNodes;
+  private listenerCleanups;
+  private addListeners;
+  private removeListeners;
+  private handleFocus;
+  private handlePointerDown;
+  private handleClick;
+  private handleTabKey;
+  private handleEscapeKey;
+  private _mutationObserver?;
+  private setupMutationObserver;
+  private updateObservedNodes;
+  private getInitialFocusNode;
+  private tryFocus;
+  activate(activateOptions?: ActivateOptions): this;
+  deactivate: (deactivateOptions?: DeactivateOptions) => this;
+  pause: (pauseOptions?: PauseOptions) => this;
+  unpause: (unpauseOptions?: UnpauseOptions) => this;
+  updateContainerElements: (containerElements: HTMLElement | HTMLElement[]) => this;
+  private getReturnFocusNode;
+  private getOption;
+  private getNodeForOption;
+  private findNextNavNode;
+}
+//#endregion
+//#region src/shared/focus-trap/index.d.ts
+type ElementOrGetter = HTMLElement | null | (() => HTMLElement | null);
+interface TrapFocusOptions extends Omit<FocusTrapOptions, "document"> {}
+declare function trapFocus(el: ElementOrGetter, options?: TrapFocusOptions): () => void;
+//#endregion
+export { FocusTrap, type FocusTrapOptions, TrapFocusOptions, trapFocus };

package/dist/focus-trap.d.mts

@@ -0,0 +1,88 @@
+//#region src/shared/focus-trap/types.d.ts
+type FocusableElement = HTMLElement | SVGElement;
+type FocusTargetValue = FocusableElement | string;
+type FocusTargetValueOrFalse = FocusTargetValue | false;
+type FocusTarget = FocusTargetValue | (() => FocusTargetValue);
+type FocusTargetOrFalse = FocusTargetValueOrFalse | (() => FocusTargetValueOrFalse);
+type MouseEventToBoolean = (event: MouseEvent | TouchEvent) => boolean;
+type KeyboardEventToBoolean = (event: KeyboardEvent) => boolean;
+interface FocusTrapOptions {
+  onActivate?: VoidFunction | undefined;
+  onPostActivate?: VoidFunction | undefined;
+  onPause?: VoidFunction | undefined;
+  onPostPause?: VoidFunction | undefined;
+  onUnpause?: VoidFunction | undefined;
+  onPostUnpause?: VoidFunction | undefined;
+  checkCanFocusTrap?: ((containers: Array<HTMLElement | SVGElement>) => Promise<void>) | undefined;
+  onDeactivate?: VoidFunction | undefined;
+  onPostDeactivate?: VoidFunction | undefined;
+  checkCanReturnFocus?: ((trigger: HTMLElement | SVGElement) => Promise<void>) | undefined;
+  initialFocus?: FocusTargetOrFalse | undefined | VoidFunction;
+  fallbackFocus?: FocusTarget | undefined;
+  returnFocusOnDeactivate?: boolean | undefined;
+  setReturnFocus?: FocusTargetValueOrFalse | ((nodeFocusedBeforeActivation: HTMLElement | SVGElement) => FocusTargetValueOrFalse) | undefined;
+  escapeDeactivates?: boolean | KeyboardEventToBoolean | undefined;
+  clickOutsideDeactivates?: boolean | MouseEventToBoolean | undefined;
+  allowOutsideClick?: boolean | MouseEventToBoolean | undefined;
+  preventScroll?: boolean | undefined;
+  delayInitialFocus?: boolean | undefined;
+  document?: Document | undefined;
+  isKeyForward?: KeyboardEventToBoolean | undefined;
+  isKeyBackward?: KeyboardEventToBoolean | undefined;
+  trapStack?: any[] | undefined;
+  followControlledElements?: boolean | undefined;
+  getShadowRoot?: boolean | ((node: FocusableElement) => ShadowRoot | boolean | undefined) | undefined;
+}
+interface DeactivateOptions extends Pick<FocusTrapOptions, "onDeactivate" | "onPostDeactivate" | "checkCanReturnFocus"> {
+  returnFocus?: boolean | undefined;
+}
+type ActivateOptions = Pick<FocusTrapOptions, "onActivate" | "onPostActivate" | "checkCanFocusTrap">;
+type PauseOptions = Pick<FocusTrapOptions, "onPause" | "onPostPause">;
+type UnpauseOptions = Pick<FocusTrapOptions, "onUnpause" | "onPostUnpause">;
+//#endregion
+//#region src/shared/focus-trap/focus-trap.d.ts
+declare class FocusTrap {
+  private trapStack;
+  private config;
+  private doc;
+  private state;
+  private portalContainers;
+  private addPortalContainer;
+  private observePortalContainer;
+  private updatePortalContainers;
+  get active(): boolean;
+  get paused(): boolean;
+  constructor(elements: HTMLElement | HTMLElement[], options: FocusTrapOptions);
+  private findContainerIndex;
+  private isControlledElement;
+  private updateTabbableNodes;
+  private listenerCleanups;
+  private addListeners;
+  private removeListeners;
+  private handleFocus;
+  private handlePointerDown;
+  private handleClick;
+  private handleTabKey;
+  private handleEscapeKey;
+  private _mutationObserver?;
+  private setupMutationObserver;
+  private updateObservedNodes;
+  private getInitialFocusNode;
+  private tryFocus;
+  activate(activateOptions?: ActivateOptions): this;
+  deactivate: (deactivateOptions?: DeactivateOptions) => this;
+  pause: (pauseOptions?: PauseOptions) => this;
+  unpause: (unpauseOptions?: UnpauseOptions) => this;
+  updateContainerElements: (containerElements: HTMLElement | HTMLElement[]) => this;
+  private getReturnFocusNode;
+  private getOption;
+  private getNodeForOption;
+  private findNextNavNode;
+}
+//#endregion
+//#region src/shared/focus-trap/index.d.ts
+type ElementOrGetter = HTMLElement | null | (() => HTMLElement | null);
+interface TrapFocusOptions extends Omit<FocusTrapOptions, "document"> {}
+declare function trapFocus(el: ElementOrGetter, options?: TrapFocusOptions): () => void;
+//#endregion
+export { FocusTrap, type FocusTrapOptions, TrapFocusOptions, trapFocus };

package/dist/focus-trap.mjs

@@ -0,0 +1,4 @@
+import "./dom-query-DFCRhyj1.mjs";
+import { n as FocusTrap, t as trapFocus } from "./focus-trap-D-bypQEJ.mjs";
+
+export { FocusTrap, trapFocus };