reshaped 2.10.13 → 2.10.15

package/utilities/a11y/TrapFocus.js

@@ -0,0 +1,127 @@
+import Chain from "../Chain.js";
+import * as keys from "../../constants/keys.js";
+import TrapScreenReader from "./TrapScreenReader.js";
+import { getActiveElement, getFocusableElements, focusElement, getFocusData } from "./focus.js";
+import { checkKeyboardMode } from "./keyboardMode.js";
+class TrapFocus {
+    constructor(root) {
+        this.trigger = null;
+        this.options = {};
+        this.mutationObserver = null;
+        /**
+         * Handle keyboard navigation while focus is trapped
+         */
+        this.handleKeyDown = (event) => {
+            if (TrapFocus.chain.tailId !== this.chainId)
+                return;
+            const { mode, onNavigateOutside, pseudoFocus, includeTrigger } = this.options;
+            let navigationMode = "tabs";
+            if (mode === "action-menu" || mode === "selection-menu")
+                navigationMode = "arrows";
+            const key = event.key;
+            const isTab = key === keys.TAB;
+            const isNextTab = isTab && !event.shiftKey;
+            const isBackTab = isTab && event.shiftKey;
+            const isUp = navigationMode === "arrows" && key === keys.UP;
+            const isDown = navigationMode === "arrows" && key === keys.DOWN;
+            const isPrev = (isBackTab && navigationMode === "tabs") || isUp;
+            const isNext = (isNextTab && navigationMode === "tabs") || isDown;
+            const isFocusedOnTrigger = getActiveElement() === this.trigger;
+            const focusData = getFocusData({
+                root: this.root,
+                target: isPrev ? "prev" : "next",
+                options: {
+                    additionalElement: includeTrigger ? this.trigger : undefined,
+                    circular: mode !== "action-menu",
+                },
+            });
+            // Release the trap when tab is used in navigation modes that support arrows
+            const hasNavigatedOutside = (isTab && navigationMode === "arrows") ||
+                (mode === "content-menu" && isTab && focusData.overflow);
+            if (hasNavigatedOutside) {
+                // Prevent shift + tab event to avoid focus moving after the trap release
+                if (isBackTab && !isFocusedOnTrigger)
+                    event.preventDefault();
+                this.release();
+                onNavigateOutside === null || onNavigateOutside === void 0 ? void 0 : onNavigateOutside();
+                return;
+            }
+            if (!isPrev && !isNext)
+                return;
+            event.preventDefault();
+            if (!focusData.el)
+                return;
+            focusElement(focusData.el, { pseudoFocus });
+        };
+        this.addListeners = () => document.addEventListener("keydown", this.handleKeyDown);
+        this.removeListeners = () => document.removeEventListener("keydown", this.handleKeyDown);
+        /**
+         * Trap the focus, add observer and keyboard event listeners
+         * and create a chain item
+         */
+        this.trap = (options = {}) => {
+            const { mode = "dialog", includeTrigger } = options;
+            const trigger = getActiveElement();
+            const focusable = getFocusableElements(this.root, {
+                additionalElement: includeTrigger ? trigger : undefined,
+            });
+            const pseudoFocus = mode === "selection-menu";
+            this.options = Object.assign(Object.assign({}, options), { pseudoFocus });
+            this.trigger = trigger;
+            this.mutationObserver = new MutationObserver(() => {
+                const currentActiveElement = getActiveElement();
+                // Focus stayed inside the wrapper, no need to refocus
+                if (this.root.contains(currentActiveElement))
+                    return;
+                const focusable = getFocusableElements(this.root, {
+                    additionalElement: includeTrigger ? trigger : undefined,
+                });
+                if (!focusable.length)
+                    return;
+                focusElement(focusable[0], { pseudoFocus });
+            });
+            this.removeListeners();
+            if (mode === "dialog")
+                this.screenReaderTrap.trap();
+            this.mutationObserver.observe(this.root, { childList: true, subtree: true });
+            if (!focusable.length)
+                return;
+            this.addListeners();
+            // Don't add back to the chain if we're traversing back
+            const tailItem = TrapFocus.chain.tailId && TrapFocus.chain.get(TrapFocus.chain.tailId);
+            if (!tailItem || this.root !== tailItem.data.root) {
+                this.chainId = TrapFocus.chain.add(this);
+                focusElement(focusable[0], { pseudoFocus });
+            }
+            this.trapped = true;
+        };
+        /**
+         * Disabled the trap focus for the element,
+         * cleanup all observers/handlers and trap for the previous element in the chain
+         */
+        this.release = (releaseOptions = {}) => {
+            var _a;
+            const { withoutFocusReturn } = releaseOptions;
+            if (!this.trapped || !this.chainId)
+                return;
+            this.trapped = false;
+            if (this.trigger) {
+                const preventScroll = withoutFocusReturn || !checkKeyboardMode();
+                this.trigger.focus({ preventScroll });
+            }
+            TrapFocus.chain.removePreviousTill(this.chainId, (item) => document.body.contains(item.data.trigger));
+            (_a = this.mutationObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+            this.removeListeners();
+            this.screenReaderTrap.release();
+            const previousItem = TrapFocus.chain.tailId && TrapFocus.chain.get(TrapFocus.chain.tailId);
+            if (previousItem) {
+                const trapInstance = new TrapFocus(previousItem.data.root);
+                trapInstance.trap(previousItem.data.options);
+            }
+        };
+        this.root = root;
+        this.screenReaderTrap = new TrapScreenReader(root);
+    }
+}
+TrapFocus.chain = new Chain();
+export default TrapFocus;

package/utilities/a11y/TrapScreenReader.d.ts

@@ -0,0 +1,15 @@
+declare class TrapScreenReader {
+    root: HTMLElement;
+    /**
+     * Elements ignored by screen reader when trap is active
+     */
+    private hiddenElements;
+    constructor(root: HTMLElement);
+    /**
+     * Apply aria-hidden to all elements except the passed
+     */
+    hideSiblingsFromScreenReader: (el: HTMLElement) => void;
+    release: () => void;
+    trap: () => void;
+}
+export default TrapScreenReader;

package/utilities/a11y/TrapScreenReader.js

@@ -0,0 +1,39 @@
+class TrapScreenReader {
+    constructor(root) {
+        /**
+         * Elements ignored by screen reader when trap is active
+         */
+        this.hiddenElements = [];
+        /**
+         * Apply aria-hidden to all elements except the passed
+         */
+        this.hideSiblingsFromScreenReader = (el) => {
+            let sibling = el.parentNode && el.parentNode.firstChild;
+            while (sibling) {
+                const notCurrent = sibling !== el;
+                const isValid = sibling.nodeType === 1 && !sibling.hasAttribute("aria-hidden");
+                if (notCurrent && isValid) {
+                    sibling.setAttribute("aria-hidden", "true");
+                    this.hiddenElements.push(sibling);
+                }
+                sibling = sibling.nextSibling;
+            }
+        };
+        this.release = () => {
+            this.hiddenElements.forEach((el) => {
+                el.removeAttribute("aria-hidden");
+            });
+            this.hiddenElements = [];
+        };
+        this.trap = () => {
+            let currentEl = this.root;
+            this.release();
+            while (currentEl !== document.body) {
+                this.hideSiblingsFromScreenReader(currentEl);
+                currentEl = currentEl.parentElement;
+            }
+        };
+        this.root = root;
+    }
+}
+export default TrapScreenReader;

package/utilities/a11y/focus.d.ts

@@ -0,0 +1,24 @@
+import type { FocusableElement } from "./types";
+export declare const focusableSelector = "a,button,input:not([type=\"hidden\"]),textarea,select,details,[tabindex]:not([tabindex=\"-1\"])";
+export declare const getActiveElement: () => HTMLButtonElement;
+export declare const focusElement: (el: FocusableElement, options?: {
+    pseudoFocus?: boolean;
+}) => void;
+export declare const getFocusableElements: (rootEl: HTMLElement, options?: {
+    additionalElement?: FocusableElement | null;
+}) => FocusableElement[];
+export declare const getFocusData: (args: {
+    root: HTMLElement;
+    target: "next" | "prev" | "first" | "last";
+    options?: {
+        circular?: boolean;
+        additionalElement?: FocusableElement | null;
+    };
+}) => {
+    overflow: boolean;
+    el: FocusableElement;
+};
+export declare const focusNextElement: (root: HTMLElement) => void;
+export declare const focusPreviousElement: (root: HTMLElement) => void;
+export declare const focusFirstElement: (root: HTMLElement) => void;
+export declare const focusLastElement: (root: HTMLElement) => void;

package/utilities/a11y/focus.js

@@ -0,0 +1,90 @@
+const pseudoFocusAttribute = "data-rs-focus";
+export const focusableSelector = 'a,button,input:not([type="hidden"]),textarea,select,details,[tabindex]:not([tabindex="-1"])';
+export const getActiveElement = () => {
+    const pseudoFocusedEl = document.querySelector(`[${pseudoFocusAttribute}]`);
+    return (pseudoFocusedEl || document.activeElement);
+};
+export const focusElement = (el, options) => {
+    var _a;
+    (_a = document.querySelector(`[${pseudoFocusAttribute}]`)) === null || _a === void 0 ? void 0 : _a.removeAttribute(pseudoFocusAttribute);
+    if (options === null || options === void 0 ? void 0 : options.pseudoFocus) {
+        el.setAttribute(pseudoFocusAttribute, "true");
+    }
+    else {
+        el.focus();
+    }
+};
+export const getFocusableElements = (rootEl, options) => {
+    const focusableElements = Array.from(rootEl.querySelectorAll(focusableSelector));
+    const filteredElements = focusableElements.filter((el) => {
+        if (el.hasAttribute("disabled"))
+            return false;
+        if (el.clientHeight === 0)
+            return false;
+        if (el.type === "radio") {
+            let sameNameRadioEls;
+            if (el.form) {
+                const formInputs = el.form.elements.namedItem(el.name);
+                // Synthetic error handling for narrowing down types
+                // Radio element can't find itself in the form, so we don't need to include it in the array
+                if (!formInputs)
+                    return false;
+                const multipleElementsFound = "length" in formInputs;
+                if (!multipleElementsFound) {
+                    // Single element found is always an input radio since we're inside the condition
+                    sameNameRadioEls = [formInputs];
+                }
+                else {
+                    sameNameRadioEls = Array.from(formInputs).filter((el) => "type" in el && el.type === "radio");
+                }
+            }
+            else {
+                sameNameRadioEls = Array.from(rootEl.querySelectorAll(`[type="radio"][name="${el.name}"]`));
+            }
+            if (sameNameRadioEls === null || sameNameRadioEls === void 0 ? void 0 : sameNameRadioEls.length) {
+                const checkedEl = Array.from(sameNameRadioEls).find((el) => el.checked);
+                if (checkedEl && el !== checkedEl)
+                    return false;
+                if (!checkedEl && el !== sameNameRadioEls[0])
+                    return false;
+            }
+        }
+        return true;
+    });
+    if ((options === null || options === void 0 ? void 0 : options.additionalElement) && filteredElements.length) {
+        filteredElements.unshift(options.additionalElement);
+    }
+    return filteredElements;
+};
+export const getFocusData = (args) => {
+    const { root, target, options } = args;
+    const focusable = getFocusableElements(root, { additionalElement: options === null || options === void 0 ? void 0 : options.additionalElement });
+    const focusableLimit = focusable.length - 1;
+    const currentElement = getActiveElement();
+    const currentIndex = focusable.indexOf(currentElement);
+    const positions = {
+        next: currentIndex + 1,
+        prev: currentIndex - 1,
+        first: 0,
+        last: focusableLimit,
+    };
+    let nextIndex = positions[target];
+    const isOverflow = nextIndex > focusableLimit || nextIndex < 0;
+    if (isOverflow) {
+        if (options === null || options === void 0 ? void 0 : options.circular) {
+            nextIndex = target === "prev" ? positions.last : positions.first;
+        }
+        else {
+            nextIndex = target === "prev" ? positions.first : positions.last;
+        }
+    }
+    return { overflow: isOverflow, el: focusable[nextIndex] };
+};
+const focusTargetElement = (root, target) => {
+    const data = getFocusData({ root, target });
+    focusElement(data.el);
+};
+export const focusNextElement = (root) => focusTargetElement(root, "next");
+export const focusPreviousElement = (root) => focusTargetElement(root, "prev");
+export const focusFirstElement = (root) => focusTargetElement(root, "first");
+export const focusLastElement = (root) => focusTargetElement(root, "last");

package/utilities/a11y/keyboardMode.d.ts

@@ -0,0 +1,3 @@
+export declare const enableKeyboardMode: () => void;
+export declare const disableKeyboardMode: () => void;
+export declare const checkKeyboardMode: () => boolean;

package/utilities/a11y/keyboardMode.js

@@ -0,0 +1,10 @@
+const keyboardModeAttribute = "data-rs-keyboard";
+export const enableKeyboardMode = () => {
+    document.documentElement.setAttribute(keyboardModeAttribute, "true");
+};
+export const disableKeyboardMode = () => {
+    document.documentElement.removeAttribute(keyboardModeAttribute);
+};
+export const checkKeyboardMode = () => {
+    return document.documentElement.hasAttribute(keyboardModeAttribute);
+};

package/utilities/a11y/types.d.ts

@@ -0,0 +1,18 @@
+/**
+ * dialog: Completely trap the focus inside for tab navigation until content is closed
+ * example: Modal
+ *
+ * action-menu: Trap the arrow navigation, while tab moves the focus to
+ * the next element on the page after the trigger
+ * example: Dropdown Menu
+ *
+ * content-menu: Include dropdown content into the tab navigation flow and move the focus to
+ * the next element on the page after the trigger after navigation through the trapped content
+ * example: Header navigation dropdowns
+ *
+ * selection-menu: Keep the focus on the trigger and enable arrow key navigation with pseudo focusing with data-attributes
+ * without moving the focus away from the trigger
+ * example: Autocomplete
+ */
+export type TrapMode = "dialog" | "action-menu" | "content-menu" | "selection-menu";
+export type FocusableElement = HTMLButtonElement | HTMLInputElement;

package/utilities/a11y/types.js

@@ -0,0 +1 @@
+export {};

package/utilities/helpers.d.ts

@@ -10,7 +10,7 @@ export declare const classNames: (...args: G.ClassName[]) => string;
 export declare const responsiveClassNames: <V extends G.Responsive<Value>>(s: Record<string, string>, className: ClassNameResolver, value: V, options?: {
     excludeValueFromClassName?: boolean;
 }) => string[];
-export declare const responsiveVariables: <V extends Value = Value>(variableName: G.CSSVariable, value?: G.Responsive<V> | undefined) => Record<`--${string}`, V>;
+export declare const responsiveVariables: <V extends Value = Value>(variableName: G.CSSVariable, value?: G.Responsive<V>) => Record<G.CSSVariable, V>;
 export declare const responsivePropDependency: <Result, T>(prop: G.Responsive<T>, resolver: (value: T, key: G.Viewport) => Result) => Result;
 export declare const resolveViewportValue: <T>(viewport: G.Viewport, value: G.Responsive<T>) => T | undefined;
 export {};

package/constants/attributes.d.ts

@@ -1,2 +0,0 @@
-export declare const keyboardModeAttribute = "data-rs-keyboard";
-export declare const pseudoFocusAttribute = "data-rs-focus";

package/constants/attributes.js

@@ -1,2 +0,0 @@
-export const keyboardModeAttribute = "data-rs-keyboard";
-export const pseudoFocusAttribute = "data-rs-focus";

package/utilities/a11y.d.ts

@@ -1,36 +0,0 @@
-/**
- * dialog: Completely trap the focus inside for tab navigation until content is closed
- * example: Modal
- *
- * action-menu: Trap the arrow navigation, while tab moves the focus to
- * the next element on the page after the trigger
- * example: Dropdown Menu
- *
- * content-menu: Include dropdown content into the tab navigation flow and move the focus to
- * the next element on the page after the trigger after navigation through the trapped content
- * example: Header navigation dropdowns
- *
- * selection-menu: Keep the focus on the trigger and enable arrow key navigation with pseudo focusing with data-attributes
- * without moving the focus away from the trigger
- * example: Autocomplete
- */
-export type TrapMode = "dialog" | "action-menu" | "content-menu" | "selection-menu";
-type ReleaseOptions = {
-    withoutFocusReturn?: boolean;
-};
-type Release = (options?: ReleaseOptions) => void;
-type TrapOptions = {
-    onNavigateOutside?: () => void;
-    includeTrigger?: boolean;
-    mode?: TrapMode;
-};
-type Trap = Release | null;
-export declare const isKeyboardMode: () => boolean;
-export declare const focusableSelector = "a,button,input:not([type=\"hidden\"]),textarea,select,details,[tabindex]:not([tabindex=\"-1\"])";
-export declare const getActiveElement: () => HTMLButtonElement;
-export declare const focusNextElement: (root: HTMLElement) => void;
-export declare const focusPreviousElement: (root: HTMLElement) => void;
-export declare const focusFirstElement: (root: HTMLElement) => void;
-export declare const focusLastElement: (root: HTMLElement) => void;
-export declare const trapFocus: (root: HTMLElement, options?: TrapOptions) => Trap;
-export {};

package/utilities/a11y.js

@@ -1,220 +0,0 @@
-import { TAB, UP, DOWN } from "../constants/keys.js";
-import { keyboardModeAttribute, pseudoFocusAttribute } from "../constants/attributes.js";
-import Chain from "./Chain.js";
-export const isKeyboardMode = () => document.documentElement.hasAttribute(keyboardModeAttribute);
-export const focusableSelector = 'a,button,input:not([type="hidden"]),textarea,select,details,[tabindex]:not([tabindex="-1"])';
-export const getActiveElement = () => {
-    const pseudoFocusedEl = document.querySelector(`[${pseudoFocusAttribute}]`);
-    return (pseudoFocusedEl || document.activeElement);
-};
-const getFocusableElements = (rootEl, extraElement) => {
-    const focusableElements = Array.from(rootEl.querySelectorAll(focusableSelector));
-    const filteredElements = focusableElements.filter((el) => {
-        if (el.hasAttribute("disabled"))
-            return false;
-        if (el.clientHeight === 0)
-            return false;
-        if (el.type === "radio") {
-            let sameNameRadioEls;
-            if (el.form) {
-                const formInputs = el.form.elements.namedItem(el.name);
-                // Synthetic error handling for narrowing down types
-                // Radio element can't find itself in the form, so we don't need to include it in the array
-                if (!formInputs)
-                    return false;
-                const multipleElementsFound = "length" in formInputs;
-                if (!multipleElementsFound) {
-                    // Single element found is always an input radio since we're inside the condition
-                    sameNameRadioEls = [formInputs];
-                }
-                else {
-                    sameNameRadioEls = Array.from(formInputs).filter((el) => "type" in el && el.type === "radio");
-                }
-            }
-            else {
-                sameNameRadioEls = Array.from(rootEl.querySelectorAll(`[type="radio"][name="${el.name}"]`));
-            }
-            if (sameNameRadioEls === null || sameNameRadioEls === void 0 ? void 0 : sameNameRadioEls.length) {
-                const checkedEl = Array.from(sameNameRadioEls).find((el) => el.checked);
-                if (checkedEl && el !== checkedEl)
-                    return false;
-                if (!checkedEl && el !== sameNameRadioEls[0])
-                    return false;
-            }
-        }
-        return true;
-    });
-    if (extraElement && filteredElements.length)
-        filteredElements.unshift(extraElement);
-    return filteredElements;
-};
-const getFocusData = (args) => {
-    const { root, extraElement, target, mode } = args;
-    const focusable = getFocusableElements(root, extraElement);
-    const focusableLimit = focusable.length - 1;
-    const currentElement = getActiveElement();
-    const currentIndex = focusable.indexOf(currentElement);
-    const positions = {
-        next: currentIndex + 1,
-        prev: currentIndex - 1,
-        first: 0,
-        last: focusableLimit,
-    };
-    let nextIndex = positions[target];
-    const isOverflow = nextIndex > focusableLimit || nextIndex < 0;
-    if (isOverflow) {
-        // Disable circular navigation for action menus
-        if (mode === "action-menu") {
-            nextIndex = target === "prev" ? positions.first : positions.last;
-        }
-        else {
-            nextIndex = target === "prev" ? positions.last : positions.first;
-        }
-    }
-    return { overflow: isOverflow, el: focusable[nextIndex] };
-};
-const focusElement = (el, mode) => {
-    var _a;
-    (_a = document.querySelector(`[${pseudoFocusAttribute}]`)) === null || _a === void 0 ? void 0 : _a.removeAttribute(pseudoFocusAttribute);
-    if (mode === "selection-menu") {
-        el.setAttribute(pseudoFocusAttribute, "true");
-    }
-    else {
-        el.focus();
-    }
-};
-const focusTargetElement = (root, target) => {
-    const data = getFocusData({ root, target });
-    focusElement(data.el);
-};
-export const focusNextElement = (root) => focusTargetElement(root, "next");
-export const focusPreviousElement = (root) => focusTargetElement(root, "prev");
-export const focusFirstElement = (root) => focusTargetElement(root, "first");
-export const focusLastElement = (root) => focusTargetElement(root, "last");
-const trapScreenReader = (() => {
-    let affectedElements = [];
-    const applyHiddenToSiblings = (el) => {
-        let sibling = el.parentNode && el.parentNode.firstChild;
-        while (sibling) {
-            const notCurrent = sibling !== el;
-            const isValid = sibling.nodeType === 1 && !sibling.hasAttribute("aria-hidden");
-            if (notCurrent && isValid) {
-                sibling.setAttribute("aria-hidden", "true");
-                affectedElements.push(sibling);
-            }
-            sibling = sibling.nextSibling;
-        }
-    };
-    const release = () => {
-        affectedElements.forEach((el) => {
-            el.removeAttribute("aria-hidden");
-        });
-        affectedElements = [];
-    };
-    return (el) => {
-        let currentEl = el;
-        if (affectedElements.length)
-            release();
-        while (currentEl !== document.body) {
-            applyHiddenToSiblings(currentEl);
-            currentEl = currentEl.parentElement;
-        }
-        return { release };
-    };
-})();
-export const trapFocus = (() => {
-    let resetListeners = null;
-    let srTrap = null;
-    const chain = new Chain();
-    return (root, options = {}) => {
-        const { mode = "dialog", onNavigateOutside, includeTrigger } = options;
-        const triggerElement = getActiveElement();
-        const isDialog = mode === "dialog";
-        const isContentMenu = mode === "content-menu";
-        const isSelectionMenu = mode === "selection-menu";
-        const isTabMode = isDialog || isContentMenu;
-        const isArrowsMode = mode === "action-menu" || isSelectionMenu;
-        const focusable = getFocusableElements(root, includeTrigger ? triggerElement : undefined);
-        let chainId;
-        // Re-focus on the first element if content has changed
-        const observer = new MutationObserver(() => {
-            // Focus stayed inside the wrapper, no need to refocus
-            if (root.contains(document.activeElement))
-                return;
-            const focusable = getFocusableElements(root, includeTrigger ? triggerElement : undefined);
-            if (!focusable.length)
-                return;
-            focusElement(focusable[0], mode);
-        });
-        const release = (releaseOptions = {}) => {
-            const { withoutFocusReturn } = releaseOptions;
-            chain.removePreviousTill(chainId, (item) => document.body.contains(item.data.trigger));
-            observer.disconnect();
-            if (triggerElement) {
-                triggerElement.focus({ preventScroll: withoutFocusReturn || !isKeyboardMode() });
-            }
-            if (resetListeners) {
-                resetListeners();
-                if (srTrap)
-                    srTrap.release();
-                resetListeners = null;
-                srTrap = null;
-            }
-            const previousItem = chain.tailId && chain.get(chain.tailId);
-            if (previousItem) {
-                trapFocus(previousItem.data.root, previousItem.data.options);
-            }
-        };
-        const handleKeyDown = (event) => {
-            const key = event.key;
-            const isTab = key === TAB;
-            const isNextTab = isTab && !event.shiftKey;
-            const isBackTab = isTab && event.shiftKey;
-            const isUp = isArrowsMode && key === UP;
-            const isDown = isArrowsMode && key === DOWN;
-            const isPrev = (isBackTab && isTabMode) || isUp;
-            const isNext = (isNextTab && isTabMode) || isDown;
-            const isFocusedOnTrigger = getActiveElement() === triggerElement;
-            const focusData = getFocusData({
-                root,
-                target: isPrev ? "prev" : "next",
-                extraElement: includeTrigger ? triggerElement : undefined,
-                mode,
-            });
-            // Release the trap when tab is used in navigation modes that support arrows
-            const hasNavigatedOutside = (isTab && isArrowsMode) || (isContentMenu && isTab && focusData.overflow);
-            if (hasNavigatedOutside) {
-                // Prevent shift + tab event to avoid focus moving after the trap release
-                if (isBackTab && !isFocusedOnTrigger)
-                    event.preventDefault();
-                release();
-                onNavigateOutside === null || onNavigateOutside === void 0 ? void 0 : onNavigateOutside();
-                return;
-            }
-            // We return after the last condition because Tab can be used for releasing in arrows mode
-            if (!isPrev && !isNext)
-                return;
-            event.preventDefault();
-            if (!focusData.el)
-                return;
-            focusElement(focusData.el, mode);
-        };
-        // Reset event listeners if focus is trapped elsewhere
-        if (resetListeners)
-            resetListeners();
-        if (isDialog)
-            srTrap = trapScreenReader(root);
-        observer.observe(root, { childList: true, subtree: true });
-        if (!focusable.length)
-            return null;
-        document.addEventListener("keydown", handleKeyDown);
-        resetListeners = () => document.removeEventListener("keydown", handleKeyDown);
-        // Don't add back to the chain if we're traversing back
-        const tailItem = chain.tailId && chain.get(chain.tailId);
-        if (!tailItem || root !== tailItem.data.root) {
-            chainId = chain.add({ root, trigger: triggerElement, options });
-            focusElement(focusable[0], mode);
-        }
-        return release;
-    };
-})();