@react-aria/focus 3.4.0 → 3.5.2

package/dist/module.js

@@ -1,33 +1,38 @@
-import _babelRuntimeHelpersEsmObjectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-import _clsx from "clsx";
-import _babelRuntimeHelpersEsmExtends from "@babel/runtime/helpers/esm/extends";
-import _react, { useContext, useEffect, useRef, useState } from "react";
-import { getInteractionModality, isFocusVisible as _isFocusVisible, useFocus, useFocusVisibleListener, useFocusWithin, useKeyboard } from "@react-aria/interactions";
-import { focusWithoutScrolling, runAfterTransition, useLayoutEffect, mergeProps, useSyncRef } from "@react-aria/utils";
+import $6saFI$react, {useRef as $6saFI$useRef, useContext as $6saFI$useContext, useEffect as $6saFI$useEffect, useState as $6saFI$useState} from "react";
+import {useLayoutEffect as $6saFI$useLayoutEffect, runAfterTransition as $6saFI$runAfterTransition, focusWithoutScrolling as $6saFI$focusWithoutScrolling, mergeProps as $6saFI$mergeProps, useSyncRef as $6saFI$useSyncRef} from "@react-aria/utils";
+import {getInteractionModality as $6saFI$getInteractionModality, isFocusVisible as $6saFI$isFocusVisible, useFocusVisibleListener as $6saFI$useFocusVisibleListener, useFocus as $6saFI$useFocus, useFocusWithin as $6saFI$useFocusWithin, useKeyboard as $6saFI$useKeyboard} from "@react-aria/interactions";
+import $6saFI$clsx from "clsx";
 
-/**
- * A utility function that focuses an element while avoiding undesired side effects such
- * as page scrolling and screen reader issues with CSS transitions.
- */
-export function focusSafely(element) {
-  // If the user is interacting with a virtual cursor, e.g. screen reader, then
-  // wait until after any animated transitions that are currently occurring on
-  // the page before shifting focus. This avoids issues with VoiceOver on iOS
-  // causing the page to scroll when moving focus if the element is transitioning
-  // from off the screen.
-  if (getInteractionModality() === 'virtual') {
-    let lastFocusedElement = document.activeElement;
-    runAfterTransition(() => {
-      // If focus did not move and the element is still in the document, focus it.
-      if (document.activeElement === lastFocusedElement && document.contains(element)) {
-        focusWithoutScrolling(element);
-      }
-    });
-  } else {
-    focusWithoutScrolling(element);
-  }
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+var $14e5c84cbc2e6e2e$exports = {};
+
+$parcel$export($14e5c84cbc2e6e2e$exports, "FocusScope", () => $14e5c84cbc2e6e2e$export$20e40289641fbbb6);
+$parcel$export($14e5c84cbc2e6e2e$exports, "useFocusManager", () => $14e5c84cbc2e6e2e$export$10c5169755ce7bd7);
+$parcel$export($14e5c84cbc2e6e2e$exports, "getFocusableTreeWalker", () => $14e5c84cbc2e6e2e$export$2d6ec8fc375ceafa);
+$parcel$export($14e5c84cbc2e6e2e$exports, "createFocusManager", () => $14e5c84cbc2e6e2e$export$c5251b9e124bf29);
+var $1159c3b6ba210e4f$exports = {};
+
+$parcel$export($1159c3b6ba210e4f$exports, "focusSafely", () => $1159c3b6ba210e4f$export$80f3e147d781571c);
+
+
+function $1159c3b6ba210e4f$export$80f3e147d781571c(element) {
+    // If the user is interacting with a virtual cursor, e.g. screen reader, then
+    // wait until after any animated transitions that are currently occurring on
+    // the page before shifting focus. This avoids issues with VoiceOver on iOS
+    // causing the page to scroll when moving focus if the element is transitioning
+    // from off the screen.
+    if ($6saFI$getInteractionModality() === 'virtual') {
+        let lastFocusedElement = document.activeElement;
+        $6saFI$runAfterTransition(()=>{
+            // If focus did not move and the element is still in the document, focus it.
+            if (document.activeElement === lastFocusedElement && document.contains(element)) $6saFI$focusWithoutScrolling(element);
+        });
+    } else $6saFI$focusWithoutScrolling(element);
 }
 
+
 /*
  * Copyright 2021 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -38,665 +43,560 @@ export function focusSafely(element) {
  * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
  * OF ANY KIND, either express or implied. See the License for the specific language
  * governing permissions and limitations under the License.
- */
-function $ee5e90cbb4a22466973155c14222fa1$var$isStyleVisible(element) {
-  if (!(element instanceof HTMLElement) && !(element instanceof SVGElement)) {
-    return false;
-  }
-
-  let {
-    display,
-    visibility
-  } = element.style;
-  let isVisible = display !== 'none' && visibility !== 'hidden' && visibility !== 'collapse';
-
-  if (isVisible) {
-    const {
-      getComputedStyle
-    } = element.ownerDocument.defaultView;
-    let {
-      display: computedDisplay,
-      visibility: computedVisibility
-    } = getComputedStyle(element);
-    isVisible = computedDisplay !== 'none' && computedVisibility !== 'hidden' && computedVisibility !== 'collapse';
-  }
-
-  return isVisible;
+ */ function $985a2847ebcbb615$var$isStyleVisible(element) {
+    if (!(element instanceof HTMLElement) && !(element instanceof SVGElement)) return false;
+    let { display: display , visibility: visibility  } = element.style;
+    let isVisible = display !== 'none' && visibility !== 'hidden' && visibility !== 'collapse';
+    if (isVisible) {
+        const { getComputedStyle: getComputedStyle  } = element.ownerDocument.defaultView;
+        let { display: computedDisplay , visibility: computedVisibility  } = getComputedStyle(element);
+        isVisible = computedDisplay !== 'none' && computedVisibility !== 'hidden' && computedVisibility !== 'collapse';
+    }
+    return isVisible;
 }
-
-function $ee5e90cbb4a22466973155c14222fa1$var$isAttributeVisible(element, childElement) {
-  return !element.hasAttribute('hidden') && (element.nodeName === 'DETAILS' && childElement && childElement.nodeName !== 'SUMMARY' ? element.hasAttribute('open') : true);
+function $985a2847ebcbb615$var$isAttributeVisible(element, childElement) {
+    return !element.hasAttribute('hidden') && (element.nodeName === 'DETAILS' && childElement && childElement.nodeName !== 'SUMMARY' ? element.hasAttribute('open') : true);
 }
-/**
- * Adapted from https://github.com/testing-library/jest-dom and 
- * https://github.com/vuejs/vue-test-utils-next/.
- * Licensed under the MIT License.
- * @param element - Element to evaluate for display or visibility.
- */
-
-
-function $ee5e90cbb4a22466973155c14222fa1$export$isElementVisible(element, childElement) {
-  return element.nodeName !== '#comment' && $ee5e90cbb4a22466973155c14222fa1$var$isStyleVisible(element) && $ee5e90cbb4a22466973155c14222fa1$var$isAttributeVisible(element, childElement) && (!element.parentElement || $ee5e90cbb4a22466973155c14222fa1$export$isElementVisible(element.parentElement, element));
+function $985a2847ebcbb615$export$e989c0fffaa6b27a(element, childElement) {
+    return element.nodeName !== '#comment' && $985a2847ebcbb615$var$isStyleVisible(element) && $985a2847ebcbb615$var$isAttributeVisible(element, childElement) && (!element.parentElement || $985a2847ebcbb615$export$e989c0fffaa6b27a(element.parentElement, element));
 }
 
-const $c9e8f80f5bb1841844f54e4ad30b$var$FocusContext = /*#__PURE__*/_react.createContext(null);
 
-let $c9e8f80f5bb1841844f54e4ad30b$var$activeScope = null;
-let $c9e8f80f5bb1841844f54e4ad30b$var$scopes = new Set(); // This is a hacky DOM-based implementation of a FocusScope until this RFC lands in React:
-// https://github.com/reactjs/rfcs/pull/109
-// For now, it relies on the DOM tree order rather than the React tree order, and is probably
-// less optimized for performance.
 
-/**
- * A FocusScope manages focus for its descendants. It supports containing focus inside
- * the scope, restoring focus to the previously focused element on unmount, and auto
- * focusing children on mount. It also acts as a container for a programmatic focus
- * management interface that can be used to move focus forward and back in response
- * to user events.
- */
-
-export function FocusScope(props) {
-  let {
-    children,
-    contain,
-    restoreFocus,
-    autoFocus
-  } = props;
-  let startRef = useRef();
-  let endRef = useRef();
-  let scopeRef = useRef([]);
-  useLayoutEffect(() => {
-    // Find all rendered nodes between the sentinels and add them to the scope.
-    let node = startRef.current.nextSibling;
-    let nodes = [];
-
-    while (node && node !== endRef.current) {
-      nodes.push(node);
-      node = node.nextSibling;
-    }
 
-    scopeRef.current = nodes;
-    $c9e8f80f5bb1841844f54e4ad30b$var$scopes.add(scopeRef);
-    return () => {
-      $c9e8f80f5bb1841844f54e4ad30b$var$scopes.delete(scopeRef);
+const $14e5c84cbc2e6e2e$var$FocusContext = /*#__PURE__*/ $6saFI$react.createContext(null);
+let $14e5c84cbc2e6e2e$var$activeScope = null;
+let $14e5c84cbc2e6e2e$var$scopes = new Map();
+function $14e5c84cbc2e6e2e$export$20e40289641fbbb6(props) {
+    let { children: children , contain: contain , restoreFocus: restoreFocus , autoFocus: autoFocus  } = props;
+    let startRef = $6saFI$useRef();
+    let endRef = $6saFI$useRef();
+    let scopeRef = $6saFI$useRef([]);
+    let ctx = $6saFI$useContext($14e5c84cbc2e6e2e$var$FocusContext);
+    let parentScope = ctx === null || ctx === void 0 ? void 0 : ctx.scopeRef;
+    $6saFI$useLayoutEffect(()=>{
+        // Find all rendered nodes between the sentinels and add them to the scope.
+        let node = startRef.current.nextSibling;
+        let nodes = [];
+        while(node && node !== endRef.current){
+            nodes.push(node);
+            node = node.nextSibling;
+        }
+        scopeRef.current = nodes;
+    }, [
+        children,
+        parentScope
+    ]);
+    $6saFI$useLayoutEffect(()=>{
+        $14e5c84cbc2e6e2e$var$scopes.set(scopeRef, parentScope);
+        return ()=>{
+            // Restore the active scope on unmount if this scope or a descendant scope is active.
+            // Parent effect cleanups run before children, so we need to check if the
+            // parent scope actually still exists before restoring the active scope to it.
+            if ((scopeRef === $14e5c84cbc2e6e2e$var$activeScope || $14e5c84cbc2e6e2e$var$isAncestorScope(scopeRef, $14e5c84cbc2e6e2e$var$activeScope)) && (!parentScope || $14e5c84cbc2e6e2e$var$scopes.has(parentScope))) $14e5c84cbc2e6e2e$var$activeScope = parentScope;
+            $14e5c84cbc2e6e2e$var$scopes.delete(scopeRef);
+        };
+    }, [
+        scopeRef,
+        parentScope
+    ]);
+    $14e5c84cbc2e6e2e$var$useFocusContainment(scopeRef, contain);
+    $14e5c84cbc2e6e2e$var$useRestoreFocus(scopeRef, restoreFocus, contain);
+    $14e5c84cbc2e6e2e$var$useAutoFocus(scopeRef, autoFocus);
+    let focusManager = $14e5c84cbc2e6e2e$var$createFocusManagerForScope(scopeRef);
+    return(/*#__PURE__*/ $6saFI$react.createElement($14e5c84cbc2e6e2e$var$FocusContext.Provider, {
+        value: {
+            scopeRef: scopeRef,
+            focusManager: focusManager
+        }
+    }, /*#__PURE__*/ $6saFI$react.createElement("span", {
+        "data-focus-scope-start": true,
+        hidden: true,
+        ref: startRef
+    }), children, /*#__PURE__*/ $6saFI$react.createElement("span", {
+        "data-focus-scope-end": true,
+        hidden: true,
+        ref: endRef
+    })));
+}
+function $14e5c84cbc2e6e2e$export$10c5169755ce7bd7() {
+    var ref;
+    return (ref = $6saFI$useContext($14e5c84cbc2e6e2e$var$FocusContext)) === null || ref === void 0 ? void 0 : ref.focusManager;
+}
+function $14e5c84cbc2e6e2e$var$createFocusManagerForScope(scopeRef) {
+    return {
+        focusNext (opts = {
+        }) {
+            let scope = scopeRef.current;
+            let { from: from , tabbable: tabbable , wrap: wrap  } = opts;
+            let node = from || document.activeElement;
+            let sentinel = scope[0].previousElementSibling;
+            let walker = $14e5c84cbc2e6e2e$export$2d6ec8fc375ceafa($14e5c84cbc2e6e2e$var$getScopeRoot(scope), {
+                tabbable: tabbable
+            }, scope);
+            walker.currentNode = $14e5c84cbc2e6e2e$var$isElementInScope(node, scope) ? node : sentinel;
+            let nextNode = walker.nextNode();
+            if (!nextNode && wrap) {
+                walker.currentNode = sentinel;
+                nextNode = walker.nextNode();
+            }
+            if (nextNode) $14e5c84cbc2e6e2e$var$focusElement(nextNode, true);
+            return nextNode;
+        },
+        focusPrevious (opts = {
+        }) {
+            let scope = scopeRef.current;
+            let { from: from , tabbable: tabbable , wrap: wrap  } = opts;
+            let node = from || document.activeElement;
+            let sentinel = scope[scope.length - 1].nextElementSibling;
+            let walker = $14e5c84cbc2e6e2e$export$2d6ec8fc375ceafa($14e5c84cbc2e6e2e$var$getScopeRoot(scope), {
+                tabbable: tabbable
+            }, scope);
+            walker.currentNode = $14e5c84cbc2e6e2e$var$isElementInScope(node, scope) ? node : sentinel;
+            let previousNode = walker.previousNode();
+            if (!previousNode && wrap) {
+                walker.currentNode = sentinel;
+                previousNode = walker.previousNode();
+            }
+            if (previousNode) $14e5c84cbc2e6e2e$var$focusElement(previousNode, true);
+            return previousNode;
+        },
+        focusFirst (opts = {
+        }) {
+            let scope = scopeRef.current;
+            let { tabbable: tabbable  } = opts;
+            let walker = $14e5c84cbc2e6e2e$export$2d6ec8fc375ceafa($14e5c84cbc2e6e2e$var$getScopeRoot(scope), {
+                tabbable: tabbable
+            }, scope);
+            walker.currentNode = scope[0].previousElementSibling;
+            let nextNode = walker.nextNode();
+            if (nextNode) $14e5c84cbc2e6e2e$var$focusElement(nextNode, true);
+            return nextNode;
+        },
+        focusLast (opts = {
+        }) {
+            let scope = scopeRef.current;
+            let { tabbable: tabbable  } = opts;
+            let walker = $14e5c84cbc2e6e2e$export$2d6ec8fc375ceafa($14e5c84cbc2e6e2e$var$getScopeRoot(scope), {
+                tabbable: tabbable
+            }, scope);
+            walker.currentNode = scope[scope.length - 1].nextElementSibling;
+            let previousNode = walker.previousNode();
+            if (previousNode) $14e5c84cbc2e6e2e$var$focusElement(previousNode, true);
+            return previousNode;
+        }
     };
-  }, [children]);
-  $c9e8f80f5bb1841844f54e4ad30b$var$useFocusContainment(scopeRef, contain);
-  $c9e8f80f5bb1841844f54e4ad30b$var$useRestoreFocus(scopeRef, restoreFocus, contain);
-  $c9e8f80f5bb1841844f54e4ad30b$var$useAutoFocus(scopeRef, autoFocus);
-  let focusManager = $c9e8f80f5bb1841844f54e4ad30b$var$createFocusManagerForScope(scopeRef);
-  return /*#__PURE__*/_react.createElement($c9e8f80f5bb1841844f54e4ad30b$var$FocusContext.Provider, {
-    value: focusManager
-  }, /*#__PURE__*/_react.createElement("span", {
-    hidden: true,
-    ref: startRef
-  }), children, /*#__PURE__*/_react.createElement("span", {
-    hidden: true,
-    ref: endRef
-  }));
 }
-/**
- * Returns a FocusManager interface for the parent FocusScope.
- * A FocusManager can be used to programmatically move focus within
- * a FocusScope, e.g. in response to user events like keyboard navigation.
- */
-
-export function useFocusManager() {
-  return useContext($c9e8f80f5bb1841844f54e4ad30b$var$FocusContext);
+const $14e5c84cbc2e6e2e$var$focusableElements = [
+    'input:not([disabled]):not([type=hidden])',
+    'select:not([disabled])',
+    'textarea:not([disabled])',
+    'button:not([disabled])',
+    'a[href]',
+    'area[href]',
+    'summary',
+    'iframe',
+    'object',
+    'embed',
+    'audio[controls]',
+    'video[controls]',
+    '[contenteditable]'
+];
+const $14e5c84cbc2e6e2e$var$FOCUSABLE_ELEMENT_SELECTOR = $14e5c84cbc2e6e2e$var$focusableElements.join(':not([hidden]),') + ',[tabindex]:not([disabled]):not([hidden])';
+$14e5c84cbc2e6e2e$var$focusableElements.push('[tabindex]:not([tabindex="-1"]):not([disabled])');
+const $14e5c84cbc2e6e2e$var$TABBABLE_ELEMENT_SELECTOR = $14e5c84cbc2e6e2e$var$focusableElements.join(':not([hidden]):not([tabindex="-1"]),');
+function $14e5c84cbc2e6e2e$var$getScopeRoot(scope) {
+    return scope[0].parentElement;
 }
-
-function $c9e8f80f5bb1841844f54e4ad30b$var$createFocusManagerForScope(scopeRef) {
-  return {
-    focusNext(opts) {
-      if (opts === void 0) {
-        opts = {};
-      }
-
-      let scope = scopeRef.current;
-      let {
-        from,
-        tabbable,
-        wrap
-      } = opts;
-      let node = from || document.activeElement;
-      let sentinel = scope[0].previousElementSibling;
-      let walker = getFocusableTreeWalker($c9e8f80f5bb1841844f54e4ad30b$var$getScopeRoot(scope), {
-        tabbable
-      }, scope);
-      walker.currentNode = $c9e8f80f5bb1841844f54e4ad30b$var$isElementInScope(node, scope) ? node : sentinel;
-      let nextNode = walker.nextNode();
-
-      if (!nextNode && wrap) {
-        walker.currentNode = sentinel;
-        nextNode = walker.nextNode();
-      }
-
-      if (nextNode) {
-        $c9e8f80f5bb1841844f54e4ad30b$var$focusElement(nextNode, true);
-      }
-
-      return nextNode;
-    },
-
-    focusPrevious(opts) {
-      if (opts === void 0) {
-        opts = {};
-      }
-
-      let scope = scopeRef.current;
-      let {
-        from,
-        tabbable,
-        wrap
-      } = opts;
-      let node = from || document.activeElement;
-      let sentinel = scope[scope.length - 1].nextElementSibling;
-      let walker = getFocusableTreeWalker($c9e8f80f5bb1841844f54e4ad30b$var$getScopeRoot(scope), {
-        tabbable
-      }, scope);
-      walker.currentNode = $c9e8f80f5bb1841844f54e4ad30b$var$isElementInScope(node, scope) ? node : sentinel;
-      let previousNode = walker.previousNode();
-
-      if (!previousNode && wrap) {
-        walker.currentNode = sentinel;
-        previousNode = walker.previousNode();
-      }
-
-      if (previousNode) {
-        $c9e8f80f5bb1841844f54e4ad30b$var$focusElement(previousNode, true);
-      }
-
-      return previousNode;
-    }
-
-  };
+function $14e5c84cbc2e6e2e$var$useFocusContainment(scopeRef, contain) {
+    let focusedNode = $6saFI$useRef();
+    let raf = $6saFI$useRef(null);
+    $6saFI$useLayoutEffect(()=>{
+        let scope1 = scopeRef.current;
+        if (!contain) return;
+        // Handle the Tab key to contain focus within the scope
+        let onKeyDown = (e)=>{
+            if (e.key !== 'Tab' || e.altKey || e.ctrlKey || e.metaKey || scopeRef !== $14e5c84cbc2e6e2e$var$activeScope) return;
+            let focusedElement = document.activeElement;
+            let scope = scopeRef.current;
+            if (!$14e5c84cbc2e6e2e$var$isElementInScope(focusedElement, scope)) return;
+            let walker = $14e5c84cbc2e6e2e$export$2d6ec8fc375ceafa($14e5c84cbc2e6e2e$var$getScopeRoot(scope), {
+                tabbable: true
+            }, scope);
+            walker.currentNode = focusedElement;
+            let nextElement = e.shiftKey ? walker.previousNode() : walker.nextNode();
+            if (!nextElement) {
+                walker.currentNode = e.shiftKey ? scope[scope.length - 1].nextElementSibling : scope[0].previousElementSibling;
+                nextElement = e.shiftKey ? walker.previousNode() : walker.nextNode();
+            }
+            e.preventDefault();
+            if (nextElement) $14e5c84cbc2e6e2e$var$focusElement(nextElement, true);
+        };
+        let onFocus = (e)=>{
+            // If focusing an element in a child scope of the currently active scope, the child becomes active.
+            // Moving out of the active scope to an ancestor is not allowed.
+            if (!$14e5c84cbc2e6e2e$var$activeScope || $14e5c84cbc2e6e2e$var$isAncestorScope($14e5c84cbc2e6e2e$var$activeScope, scopeRef)) {
+                $14e5c84cbc2e6e2e$var$activeScope = scopeRef;
+                focusedNode.current = e.target;
+            } else if (scopeRef === $14e5c84cbc2e6e2e$var$activeScope && !$14e5c84cbc2e6e2e$var$isElementInChildScope(e.target, scopeRef)) {
+                // If a focus event occurs outside the active scope (e.g. user tabs from browser location bar),
+                // restore focus to the previously focused node or the first tabbable element in the active scope.
+                if (focusedNode.current) focusedNode.current.focus();
+                else if ($14e5c84cbc2e6e2e$var$activeScope) $14e5c84cbc2e6e2e$var$focusFirstInScope($14e5c84cbc2e6e2e$var$activeScope.current);
+            } else if (scopeRef === $14e5c84cbc2e6e2e$var$activeScope) focusedNode.current = e.target;
+        };
+        let onBlur = (e)=>{
+            // Firefox doesn't shift focus back to the Dialog properly without this
+            raf.current = requestAnimationFrame(()=>{
+                // Use document.activeElement instead of e.relatedTarget so we can tell if user clicked into iframe
+                if (scopeRef === $14e5c84cbc2e6e2e$var$activeScope && !$14e5c84cbc2e6e2e$var$isElementInChildScope(document.activeElement, scopeRef)) {
+                    $14e5c84cbc2e6e2e$var$activeScope = scopeRef;
+                    focusedNode.current = e.target;
+                    focusedNode.current.focus();
+                }
+            });
+        };
+        document.addEventListener('keydown', onKeyDown, false);
+        document.addEventListener('focusin', onFocus, false);
+        scope1.forEach((element)=>element.addEventListener('focusin', onFocus, false)
+        );
+        scope1.forEach((element)=>element.addEventListener('focusout', onBlur, false)
+        );
+        return ()=>{
+            document.removeEventListener('keydown', onKeyDown, false);
+            document.removeEventListener('focusin', onFocus, false);
+            scope1.forEach((element)=>element.removeEventListener('focusin', onFocus, false)
+            );
+            scope1.forEach((element)=>element.removeEventListener('focusout', onBlur, false)
+            );
+        };
+    }, [
+        scopeRef,
+        contain
+    ]);
+    // eslint-disable-next-line arrow-body-style
+    $6saFI$useEffect(()=>{
+        return ()=>cancelAnimationFrame(raf.current)
+        ;
+    }, [
+        raf
+    ]);
 }
-
-const $c9e8f80f5bb1841844f54e4ad30b$var$focusableElements = ['input:not([disabled]):not([type=hidden])', 'select:not([disabled])', 'textarea:not([disabled])', 'button:not([disabled])', 'a[href]', 'area[href]', 'summary', 'iframe', 'object', 'embed', 'audio[controls]', 'video[controls]', '[contenteditable]'];
-const $c9e8f80f5bb1841844f54e4ad30b$var$FOCUSABLE_ELEMENT_SELECTOR = $c9e8f80f5bb1841844f54e4ad30b$var$focusableElements.join(':not([hidden]),') + ',[tabindex]:not([disabled]):not([hidden])';
-$c9e8f80f5bb1841844f54e4ad30b$var$focusableElements.push('[tabindex]:not([tabindex="-1"]):not([disabled])');
-const $c9e8f80f5bb1841844f54e4ad30b$var$TABBABLE_ELEMENT_SELECTOR = $c9e8f80f5bb1841844f54e4ad30b$var$focusableElements.join(':not([hidden]):not([tabindex="-1"]),');
-
-function $c9e8f80f5bb1841844f54e4ad30b$var$getScopeRoot(scope) {
-  return scope[0].parentElement;
+function $14e5c84cbc2e6e2e$var$isElementInAnyScope(element) {
+    for (let scope of $14e5c84cbc2e6e2e$var$scopes.keys()){
+        if ($14e5c84cbc2e6e2e$var$isElementInScope(element, scope.current)) return true;
+    }
+    return false;
 }
-
-function $c9e8f80f5bb1841844f54e4ad30b$var$useFocusContainment(scopeRef, contain) {
-  let focusedNode = useRef();
-  let raf = useRef(null);
-  useEffect(() => {
-    let scope = scopeRef.current;
-
-    if (!contain) {
-      return;
-    } // Handle the Tab key to contain focus within the scope
-
-
-    let onKeyDown = e => {
-      if (e.key !== 'Tab' || e.altKey || e.ctrlKey || e.metaKey) {
-        return;
-      }
-
-      let focusedElement = document.activeElement;
-
-      if (!$c9e8f80f5bb1841844f54e4ad30b$var$isElementInScope(focusedElement, scope)) {
-        return;
-      }
-
-      let walker = getFocusableTreeWalker($c9e8f80f5bb1841844f54e4ad30b$var$getScopeRoot(scope), {
-        tabbable: true
-      }, scope);
-      walker.currentNode = focusedElement;
-      let nextElement = e.shiftKey ? walker.previousNode() : walker.nextNode();
-
-      if (!nextElement) {
-        walker.currentNode = e.shiftKey ? scope[scope.length - 1].nextElementSibling : scope[0].previousElementSibling;
-        nextElement = e.shiftKey ? walker.previousNode() : walker.nextNode();
-      }
-
-      e.preventDefault();
-
-      if (nextElement) {
-        $c9e8f80f5bb1841844f54e4ad30b$var$focusElement(nextElement, true);
-      }
-    };
-
-    let onFocus = e => {
-      // If a focus event occurs outside the active scope (e.g. user tabs from browser location bar),
-      // restore focus to the previously focused node or the first tabbable element in the active scope.
-      let isInAnyScope = $c9e8f80f5bb1841844f54e4ad30b$var$isElementInAnyScope(e.target, $c9e8f80f5bb1841844f54e4ad30b$var$scopes);
-
-      if (!isInAnyScope) {
-        if (focusedNode.current) {
-          focusedNode.current.focus();
-        } else if ($c9e8f80f5bb1841844f54e4ad30b$var$activeScope) {
-          $c9e8f80f5bb1841844f54e4ad30b$var$focusFirstInScope($c9e8f80f5bb1841844f54e4ad30b$var$activeScope.current);
-        }
-      } else {
-        $c9e8f80f5bb1841844f54e4ad30b$var$activeScope = scopeRef;
-        focusedNode.current = e.target;
-      }
-    };
-
-    let onBlur = e => {
-      // Firefox doesn't shift focus back to the Dialog properly without this
-      raf.current = requestAnimationFrame(() => {
-        // Use document.activeElement instead of e.relatedTarget so we can tell if user clicked into iframe
-        let isInAnyScope = $c9e8f80f5bb1841844f54e4ad30b$var$isElementInAnyScope(document.activeElement, $c9e8f80f5bb1841844f54e4ad30b$var$scopes);
-
-        if (!isInAnyScope) {
-          $c9e8f80f5bb1841844f54e4ad30b$var$activeScope = scopeRef;
-          focusedNode.current = e.target;
-          focusedNode.current.focus();
-        }
-      });
-    };
-
-    document.addEventListener('keydown', onKeyDown, false);
-    document.addEventListener('focusin', onFocus, false);
-    scope.forEach(element => element.addEventListener('focusin', onFocus, false));
-    scope.forEach(element => element.addEventListener('focusout', onBlur, false));
-    return () => {
-      document.removeEventListener('keydown', onKeyDown, false);
-      document.removeEventListener('focusin', onFocus, false);
-      scope.forEach(element => element.removeEventListener('focusin', onFocus, false));
-      scope.forEach(element => element.removeEventListener('focusout', onBlur, false));
-    };
-  }, [scopeRef, contain]); // eslint-disable-next-line arrow-body-style
-
-  useEffect(() => {
-    return () => cancelAnimationFrame(raf.current);
-  }, [raf]);
+function $14e5c84cbc2e6e2e$var$isElementInScope(element, scope) {
+    return scope.some((node)=>node.contains(element)
+    );
 }
-
-function $c9e8f80f5bb1841844f54e4ad30b$var$isElementInAnyScope(element, scopes) {
-  for (let scope of scopes.values()) {
-    if ($c9e8f80f5bb1841844f54e4ad30b$var$isElementInScope(element, scope.current)) {
-      return true;
+function $14e5c84cbc2e6e2e$var$isElementInChildScope(element, scope) {
+    // node.contains in isElementInScope covers child scopes that are also DOM children,
+    // but does not cover child scopes in portals.
+    for (let s of $14e5c84cbc2e6e2e$var$scopes.keys()){
+        if ((s === scope || $14e5c84cbc2e6e2e$var$isAncestorScope(scope, s)) && $14e5c84cbc2e6e2e$var$isElementInScope(element, s.current)) return true;
     }
-  }
-
-  return false;
+    return false;
 }
-
-function $c9e8f80f5bb1841844f54e4ad30b$var$isElementInScope(element, scope) {
-  return scope.some(node => node.contains(element));
+function $14e5c84cbc2e6e2e$var$isAncestorScope(ancestor, scope) {
+    let parent = $14e5c84cbc2e6e2e$var$scopes.get(scope);
+    if (!parent) return false;
+    if (parent === ancestor) return true;
+    return $14e5c84cbc2e6e2e$var$isAncestorScope(ancestor, parent);
 }
-
-function $c9e8f80f5bb1841844f54e4ad30b$var$focusElement(element, scroll) {
-  if (scroll === void 0) {
-    scroll = false;
-  }
-
-  if (element != null && !scroll) {
-    try {
-      focusSafely(element);
-    } catch (err) {// ignore
+function $14e5c84cbc2e6e2e$var$focusElement(element, scroll = false) {
+    if (element != null && !scroll) try {
+        $1159c3b6ba210e4f$export$80f3e147d781571c(element);
+    } catch (err) {
+    // ignore
     }
-  } else if (element != null) {
-    try {
-      element.focus();
-    } catch (err) {// ignore
+    else if (element != null) try {
+        element.focus();
+    } catch (err1) {
+    // ignore
     }
-  }
 }
-
-function $c9e8f80f5bb1841844f54e4ad30b$var$focusFirstInScope(scope) {
-  let sentinel = scope[0].previousElementSibling;
-  let walker = getFocusableTreeWalker($c9e8f80f5bb1841844f54e4ad30b$var$getScopeRoot(scope), {
-    tabbable: true
-  }, scope);
-  walker.currentNode = sentinel;
-  $c9e8f80f5bb1841844f54e4ad30b$var$focusElement(walker.nextNode());
+function $14e5c84cbc2e6e2e$var$focusFirstInScope(scope) {
+    let sentinel = scope[0].previousElementSibling;
+    let walker = $14e5c84cbc2e6e2e$export$2d6ec8fc375ceafa($14e5c84cbc2e6e2e$var$getScopeRoot(scope), {
+        tabbable: true
+    }, scope);
+    walker.currentNode = sentinel;
+    $14e5c84cbc2e6e2e$var$focusElement(walker.nextNode());
 }
-
-function $c9e8f80f5bb1841844f54e4ad30b$var$useAutoFocus(scopeRef, autoFocus) {
-  useEffect(() => {
-    if (autoFocus) {
-      $c9e8f80f5bb1841844f54e4ad30b$var$activeScope = scopeRef;
-
-      if (!$c9e8f80f5bb1841844f54e4ad30b$var$isElementInScope(document.activeElement, $c9e8f80f5bb1841844f54e4ad30b$var$activeScope.current)) {
-        $c9e8f80f5bb1841844f54e4ad30b$var$focusFirstInScope(scopeRef.current);
-      }
-    }
-  }, [scopeRef, autoFocus]);
+function $14e5c84cbc2e6e2e$var$useAutoFocus(scopeRef, autoFocus) {
+    const autoFocusRef = $6saFI$react.useRef(autoFocus);
+    $6saFI$useEffect(()=>{
+        if (autoFocusRef.current) {
+            $14e5c84cbc2e6e2e$var$activeScope = scopeRef;
+            if (!$14e5c84cbc2e6e2e$var$isElementInScope(document.activeElement, $14e5c84cbc2e6e2e$var$activeScope.current)) $14e5c84cbc2e6e2e$var$focusFirstInScope(scopeRef.current);
+        }
+        autoFocusRef.current = false;
+    }, []);
+}
+function $14e5c84cbc2e6e2e$var$useRestoreFocus(scopeRef, restoreFocus, contain) {
+    // create a ref during render instead of useLayoutEffect so the active element is saved before a child with autoFocus=true mounts.
+    const nodeToRestoreRef = $6saFI$useRef(typeof document !== 'undefined' ? document.activeElement : null);
+    // useLayoutEffect instead of useEffect so the active element is saved synchronously instead of asynchronously.
+    $6saFI$useLayoutEffect(()=>{
+        let nodeToRestore = nodeToRestoreRef.current;
+        if (!restoreFocus) return;
+        // Handle the Tab key so that tabbing out of the scope goes to the next element
+        // after the node that had focus when the scope mounted. This is important when
+        // using portals for overlays, so that focus goes to the expected element when
+        // tabbing out of the overlay.
+        let onKeyDown = (e)=>{
+            if (e.key !== 'Tab' || e.altKey || e.ctrlKey || e.metaKey) return;
+            let focusedElement = document.activeElement;
+            if (!$14e5c84cbc2e6e2e$var$isElementInScope(focusedElement, scopeRef.current)) return;
+            // Create a DOM tree walker that matches all tabbable elements
+            let walker = $14e5c84cbc2e6e2e$export$2d6ec8fc375ceafa(document.body, {
+                tabbable: true
+            });
+            // Find the next tabbable element after the currently focused element
+            walker.currentNode = focusedElement;
+            let nextElement = e.shiftKey ? walker.previousNode() : walker.nextNode();
+            if (!document.body.contains(nodeToRestore) || nodeToRestore === document.body) nodeToRestore = null;
+            // If there is no next element, or it is outside the current scope, move focus to the
+            // next element after the node to restore to instead.
+            if ((!nextElement || !$14e5c84cbc2e6e2e$var$isElementInScope(nextElement, scopeRef.current)) && nodeToRestore) {
+                walker.currentNode = nodeToRestore;
+                // Skip over elements within the scope, in case the scope immediately follows the node to restore.
+                do nextElement = e.shiftKey ? walker.previousNode() : walker.nextNode();
+                while ($14e5c84cbc2e6e2e$var$isElementInScope(nextElement, scopeRef.current))
+                e.preventDefault();
+                e.stopPropagation();
+                if (nextElement) $14e5c84cbc2e6e2e$var$focusElement(nextElement, true);
+                else // If there is no next element and the nodeToRestore isn't within a FocusScope (i.e. we are leaving the top level focus scope)
+                // then move focus to the body.
+                // Otherwise restore focus to the nodeToRestore (e.g menu within a popover -> tabbing to close the menu should move focus to menu trigger)
+                if (!$14e5c84cbc2e6e2e$var$isElementInAnyScope(nodeToRestore)) focusedElement.blur();
+                else $14e5c84cbc2e6e2e$var$focusElement(nodeToRestore, true);
+            }
+        };
+        if (!contain) document.addEventListener('keydown', onKeyDown, true);
+        return ()=>{
+            if (!contain) document.removeEventListener('keydown', onKeyDown, true);
+            if (restoreFocus && nodeToRestore && $14e5c84cbc2e6e2e$var$isElementInScope(document.activeElement, scopeRef.current)) requestAnimationFrame(()=>{
+                if (document.body.contains(nodeToRestore)) $14e5c84cbc2e6e2e$var$focusElement(nodeToRestore);
+            });
+        };
+    }, [
+        scopeRef,
+        restoreFocus,
+        contain
+    ]);
+}
+function $14e5c84cbc2e6e2e$export$2d6ec8fc375ceafa(root, opts, scope) {
+    let selector = (opts === null || opts === void 0 ? void 0 : opts.tabbable) ? $14e5c84cbc2e6e2e$var$TABBABLE_ELEMENT_SELECTOR : $14e5c84cbc2e6e2e$var$FOCUSABLE_ELEMENT_SELECTOR;
+    let walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {
+        acceptNode (node) {
+            var ref;
+            // Skip nodes inside the starting node.
+            if (opts === null || opts === void 0 ? void 0 : (ref = opts.from) === null || ref === void 0 ? void 0 : ref.contains(node)) return NodeFilter.FILTER_REJECT;
+            if (node.matches(selector) && $985a2847ebcbb615$export$e989c0fffaa6b27a(node) && (!scope || $14e5c84cbc2e6e2e$var$isElementInScope(node, scope))) return NodeFilter.FILTER_ACCEPT;
+            return NodeFilter.FILTER_SKIP;
+        }
+    });
+    if (opts === null || opts === void 0 ? void 0 : opts.from) walker.currentNode = opts.from;
+    return walker;
+}
+function $14e5c84cbc2e6e2e$export$c5251b9e124bf29(ref) {
+    return {
+        focusNext (opts = {
+        }) {
+            let root = ref.current;
+            let { from: from , tabbable: tabbable , wrap: wrap  } = opts;
+            let node = from || document.activeElement;
+            let walker = $14e5c84cbc2e6e2e$export$2d6ec8fc375ceafa(root, {
+                tabbable: tabbable
+            });
+            if (root.contains(node)) walker.currentNode = node;
+            let nextNode = walker.nextNode();
+            if (!nextNode && wrap) {
+                walker.currentNode = root;
+                nextNode = walker.nextNode();
+            }
+            if (nextNode) $14e5c84cbc2e6e2e$var$focusElement(nextNode, true);
+            return nextNode;
+        },
+        focusPrevious (opts = {
+        }) {
+            let root = ref.current;
+            let { from: from , tabbable: tabbable , wrap: wrap  } = opts;
+            let node = from || document.activeElement;
+            let walker = $14e5c84cbc2e6e2e$export$2d6ec8fc375ceafa(root, {
+                tabbable: tabbable
+            });
+            if (root.contains(node)) walker.currentNode = node;
+            else {
+                let next = $14e5c84cbc2e6e2e$var$last(walker);
+                if (next) $14e5c84cbc2e6e2e$var$focusElement(next, true);
+                return next;
+            }
+            let previousNode = walker.previousNode();
+            if (!previousNode && wrap) {
+                walker.currentNode = root;
+                previousNode = $14e5c84cbc2e6e2e$var$last(walker);
+            }
+            if (previousNode) $14e5c84cbc2e6e2e$var$focusElement(previousNode, true);
+            return previousNode;
+        },
+        focusFirst (opts = {
+        }) {
+            let root = ref.current;
+            let { tabbable: tabbable  } = opts;
+            let walker = $14e5c84cbc2e6e2e$export$2d6ec8fc375ceafa(root, {
+                tabbable: tabbable
+            });
+            let nextNode = walker.nextNode();
+            if (nextNode) $14e5c84cbc2e6e2e$var$focusElement(nextNode, true);
+            return nextNode;
+        },
+        focusLast (opts = {
+        }) {
+            let root = ref.current;
+            let { tabbable: tabbable  } = opts;
+            let walker = $14e5c84cbc2e6e2e$export$2d6ec8fc375ceafa(root, {
+                tabbable: tabbable
+            });
+            let next = $14e5c84cbc2e6e2e$var$last(walker);
+            if (next) $14e5c84cbc2e6e2e$var$focusElement(next, true);
+            return next;
+        }
+    };
+}
+function $14e5c84cbc2e6e2e$var$last(walker) {
+    let next;
+    let last;
+    do {
+        last = walker.lastChild();
+        if (last) next = last;
+    }while (last)
+    return next;
 }
 
-function $c9e8f80f5bb1841844f54e4ad30b$var$useRestoreFocus(scopeRef, restoreFocus, contain) {
-  // useLayoutEffect instead of useEffect so the active element is saved synchronously instead of asynchronously.
-  useLayoutEffect(() => {
-    let scope = scopeRef.current;
-    let nodeToRestore = document.activeElement; // Handle the Tab key so that tabbing out of the scope goes to the next element
-    // after the node that had focus when the scope mounted. This is important when
-    // using portals for overlays, so that focus goes to the expected element when
-    // tabbing out of the overlay.
-
-    let onKeyDown = e => {
-      if (e.key !== 'Tab' || e.altKey || e.ctrlKey || e.metaKey) {
-        return;
-      }
-
-      let focusedElement = document.activeElement;
 
-      if (!$c9e8f80f5bb1841844f54e4ad30b$var$isElementInScope(focusedElement, scope)) {
-        return;
-      } // Create a DOM tree walker that matches all tabbable elements
+var $503734efc0922182$exports = {};
 
+$parcel$export($503734efc0922182$exports, "FocusRing", () => $503734efc0922182$export$1a38b4ad7f578e1d);
 
-      let walker = getFocusableTreeWalker(document.body, {
-        tabbable: true
-      }); // Find the next tabbable element after the currently focused element
 
-      walker.currentNode = focusedElement;
-      let nextElement = e.shiftKey ? walker.previousNode() : walker.nextNode();
 
-      if (!document.body.contains(nodeToRestore) || nodeToRestore === document.body) {
-        nodeToRestore = null;
-      } // If there is no next element, or it is outside the current scope, move focus to the
-      // next element after the node to restore to instead.
+var $e63d024ca16f2165$exports = {};
 
+$parcel$export($e63d024ca16f2165$exports, "useFocusRing", () => $e63d024ca16f2165$export$4e328f61c538687f);
 
-      if ((!nextElement || !$c9e8f80f5bb1841844f54e4ad30b$var$isElementInScope(nextElement, scope)) && nodeToRestore) {
-        walker.currentNode = nodeToRestore; // Skip over elements within the scope, in case the scope immediately follows the node to restore.
 
-        do {
-          nextElement = e.shiftKey ? walker.previousNode() : walker.nextNode();
-        } while ($c9e8f80f5bb1841844f54e4ad30b$var$isElementInScope(nextElement, scope));
 
-        e.preventDefault();
-        e.stopPropagation();
-
-        if (nextElement) {
-          $c9e8f80f5bb1841844f54e4ad30b$var$focusElement(nextElement, true);
-        } else {
-          // If there is no next element, blur the focused element to move focus to the body.
-          focusedElement.blur();
-        }
-      }
+function $e63d024ca16f2165$export$4e328f61c538687f(props = {
+}) {
+    let { autoFocus: autoFocus = false , isTextInput: isTextInput , within: within  } = props;
+    let state = $6saFI$useRef({
+        isFocused: false,
+        isFocusVisible: autoFocus || $6saFI$isFocusVisible()
+    }).current;
+    let [isFocused1, setFocused] = $6saFI$useState(false);
+    let [isFocusVisibleState, setFocusVisible] = $6saFI$useState(()=>state.isFocused && state.isFocusVisible
+    );
+    let updateState = ()=>setFocusVisible(state.isFocused && state.isFocusVisible)
+    ;
+    let onFocusChange = (isFocused)=>{
+        state.isFocused = isFocused;
+        setFocused(isFocused);
+        updateState();
     };
-
-    if (!contain) {
-      document.addEventListener('keydown', onKeyDown, true);
-    }
-
-    return () => {
-      if (!contain) {
-        document.removeEventListener('keydown', onKeyDown, true);
-      }
-
-      if (restoreFocus && nodeToRestore && $c9e8f80f5bb1841844f54e4ad30b$var$isElementInScope(document.activeElement, scope)) {
-        requestAnimationFrame(() => {
-          if (document.body.contains(nodeToRestore)) {
-            $c9e8f80f5bb1841844f54e4ad30b$var$focusElement(nodeToRestore);
-          }
-        });
-      }
+    $6saFI$useFocusVisibleListener((isFocusVisible)=>{
+        state.isFocusVisible = isFocusVisible;
+        updateState();
+    }, [], {
+        isTextInput: isTextInput
+    });
+    let { focusProps: focusProps  } = $6saFI$useFocus({
+        isDisabled: within,
+        onFocusChange: onFocusChange
+    });
+    let { focusWithinProps: focusWithinProps  } = $6saFI$useFocusWithin({
+        isDisabled: !within,
+        onFocusWithinChange: onFocusChange
+    });
+    return {
+        isFocused: isFocused1,
+        isFocusVisible: state.isFocused && isFocusVisibleState,
+        focusProps: within ? focusWithinProps : focusProps
     };
-  }, [scopeRef, restoreFocus, contain]);
 }
-/**
- * Create a [TreeWalker]{@link https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker}
- * that matches all focusable/tabbable elements.
- */
-
-
-export function getFocusableTreeWalker(root, opts, scope) {
-  let selector = opts != null && opts.tabbable ? $c9e8f80f5bb1841844f54e4ad30b$var$TABBABLE_ELEMENT_SELECTOR : $c9e8f80f5bb1841844f54e4ad30b$var$FOCUSABLE_ELEMENT_SELECTOR;
-  let walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {
-    acceptNode(node) {
-      var _opts$from;
-
-      // Skip nodes inside the starting node.
-      if (opts != null && (_opts$from = opts.from) != null && _opts$from.contains(node)) {
-        return NodeFilter.FILTER_REJECT;
-      }
 
-      if (node.matches(selector) && $ee5e90cbb4a22466973155c14222fa1$export$isElementVisible(node) && (!scope || $c9e8f80f5bb1841844f54e4ad30b$var$isElementInScope(node, scope))) {
-        return NodeFilter.FILTER_ACCEPT;
-      }
 
-      return NodeFilter.FILTER_SKIP;
-    }
-
-  });
-
-  if (opts != null && opts.from) {
-    walker.currentNode = opts.from;
-  }
-
-  return walker;
+function $503734efc0922182$export$1a38b4ad7f578e1d(props) {
+    let { children: children , focusClass: focusClass , focusRingClass: focusRingClass  } = props;
+    let { isFocused: isFocused , isFocusVisible: isFocusVisible , focusProps: focusProps  } = $e63d024ca16f2165$export$4e328f61c538687f(props);
+    let child = $6saFI$react.Children.only(children);
+    return(/*#__PURE__*/ $6saFI$react.cloneElement(child, $6saFI$mergeProps(child.props, {
+        ...focusProps,
+        className: $6saFI$clsx({
+            [focusClass || '']: isFocused,
+            [focusRingClass || '']: isFocusVisible
+        })
+    })));
 }
-/**
- * Creates a FocusManager object that can be used to move focus within an element.
- */
-
-export function createFocusManager(ref) {
-  return {
-    focusNext(opts) {
-      if (opts === void 0) {
-        opts = {};
-      }
-
-      let root = ref.current;
-      let {
-        from,
-        tabbable,
-        wrap
-      } = opts;
-      let node = from || document.activeElement;
-      let walker = getFocusableTreeWalker(root, {
-        tabbable
-      });
-
-      if (root.contains(node)) {
-        walker.currentNode = node;
-      }
-
-      let nextNode = walker.nextNode();
-
-      if (!nextNode && wrap) {
-        walker.currentNode = root;
-        nextNode = walker.nextNode();
-      }
-
-      if (nextNode) {
-        $c9e8f80f5bb1841844f54e4ad30b$var$focusElement(nextNode, true);
-      }
-
-      return nextNode;
-    },
-
-    focusPrevious(opts) {
-      if (opts === void 0) {
-        opts = {};
-      }
-
-      let root = ref.current;
-      let {
-        from,
-        tabbable,
-        wrap
-      } = opts;
-      let node = from || document.activeElement;
-      let walker = getFocusableTreeWalker(root, {
-        tabbable
-      });
-
-      if (root.contains(node)) {
-        walker.currentNode = node;
-      } else {
-        let next = $c9e8f80f5bb1841844f54e4ad30b$var$last(walker);
-
-        if (next) {
-          $c9e8f80f5bb1841844f54e4ad30b$var$focusElement(next, true);
-        }
 
-        return next;
-      }
 
-      let previousNode = walker.previousNode();
+var $391c6482f25a1991$exports = {};
 
-      if (!previousNode && wrap) {
-        walker.currentNode = root;
-        previousNode = $c9e8f80f5bb1841844f54e4ad30b$var$last(walker);
-      }
+$parcel$export($391c6482f25a1991$exports, "FocusableProvider", () => $391c6482f25a1991$export$13f3202a3e5ddd5);
+$parcel$export($391c6482f25a1991$exports, "useFocusable", () => $391c6482f25a1991$export$4c014de7c8940b4c);
 
-      if (previousNode) {
-        $c9e8f80f5bb1841844f54e4ad30b$var$focusElement(previousNode, true);
-      }
-
-      return previousNode;
-    }
 
-  };
-}
-
-function $c9e8f80f5bb1841844f54e4ad30b$var$last(walker) {
-  let next;
-  let last;
-
-  do {
-    last = walker.lastChild();
-
-    if (last) {
-      next = last;
-    }
-  } while (last);
-
-  return next;
-}
 
-/**
- * Determines whether a focus ring should be shown to indicate keyboard focus.
- * Focus rings are visible only when the user is interacting with a keyboard,
- * not with a mouse, touch, or other input methods.
- */
-export function useFocusRing(props) {
-  if (props === void 0) {
-    props = {};
-  }
-
-  let {
-    autoFocus = false,
-    isTextInput,
-    within
-  } = props;
-  let state = useRef({
-    isFocused: false,
-    isFocusVisible: autoFocus || _isFocusVisible()
-  }).current;
-  let [isFocusVisibleState, setFocusVisible] = useState(() => state.isFocused && state.isFocusVisible);
-
-  let updateState = () => setFocusVisible(state.isFocused && state.isFocusVisible);
-
-  let onFocusChange = isFocused => {
-    state.isFocused = isFocused;
-    updateState();
-  };
-
-  useFocusVisibleListener(isFocusVisible => {
-    state.isFocusVisible = isFocusVisible;
-    updateState();
-  }, [], {
-    isTextInput
-  });
-  let {
-    focusProps
-  } = useFocus({
-    isDisabled: within,
-    onFocusChange
-  });
-  let {
-    focusWithinProps
-  } = useFocusWithin({
-    isDisabled: !within,
-    onFocusWithinChange: onFocusChange
-  });
-  return {
-    isFocused: state.isFocused,
-    isFocusVisible: state.isFocused && isFocusVisibleState,
-    focusProps: within ? focusWithinProps : focusProps
-  };
+let $391c6482f25a1991$var$FocusableContext = /*#__PURE__*/ $6saFI$react.createContext(null);
+function $391c6482f25a1991$var$useFocusableContext(ref) {
+    let context = $6saFI$useContext($391c6482f25a1991$var$FocusableContext) || {
+    };
+    $6saFI$useSyncRef(context, ref);
+    // eslint-disable-next-line
+    let { ref: _ , ...otherProps } = context;
+    return otherProps;
 }
-
 /**
- * A utility component that applies a CSS class when an element has keyboard focus.
- * Focus rings are visible only when the user is interacting with a keyboard,
- * not with a mouse, touch, or other input methods.
- */
-export function FocusRing(props) {
-  let {
-    children,
-    focusClass,
-    focusRingClass
-  } = props;
-  let {
-    isFocused,
-    isFocusVisible,
-    focusProps
-  } = useFocusRing(props);
-
-  let child = _react.Children.only(children);
-
-  return /*#__PURE__*/_react.cloneElement(child, mergeProps(child.props, _babelRuntimeHelpersEsmExtends({}, focusProps, {
-    className: _clsx({
-      [focusClass || '']: isFocused,
-      [focusRingClass || '']: isFocusVisible
-    })
-  })));
+ * Provides DOM props to the nearest focusable child.
+ */ function $391c6482f25a1991$var$FocusableProvider(props, ref) {
+    let { children: children , ...otherProps } = props;
+    let context = {
+        ...otherProps,
+        ref: ref
+    };
+    return(/*#__PURE__*/ $6saFI$react.createElement($391c6482f25a1991$var$FocusableContext.Provider, {
+        value: context
+    }, children));
 }
-
-let $e11539c8317b2d21639df611cb5658f$var$FocusableContext = /*#__PURE__*/_react.createContext(null);
-
-function $e11539c8317b2d21639df611cb5658f$var$useFocusableContext(ref) {
-  let context = useContext($e11539c8317b2d21639df611cb5658f$var$FocusableContext) || {};
-  useSyncRef(context, ref);
-  return context;
+let $391c6482f25a1991$export$13f3202a3e5ddd5 = /*#__PURE__*/ $6saFI$react.forwardRef($391c6482f25a1991$var$FocusableProvider);
+function $391c6482f25a1991$export$4c014de7c8940b4c(props, domRef) {
+    let { focusProps: focusProps  } = $6saFI$useFocus(props);
+    let { keyboardProps: keyboardProps  } = $6saFI$useKeyboard(props);
+    let interactions = $6saFI$mergeProps(focusProps, keyboardProps);
+    let domProps = $391c6482f25a1991$var$useFocusableContext(domRef);
+    let interactionProps = props.isDisabled ? {
+    } : domProps;
+    let autoFocusRef = $6saFI$useRef(props.autoFocus);
+    $6saFI$useEffect(()=>{
+        if (autoFocusRef.current && domRef.current) domRef.current.focus();
+        autoFocusRef.current = false;
+    }, []);
+    return {
+        focusableProps: $6saFI$mergeProps({
+            ...interactions,
+            tabIndex: props.excludeFromTabOrder && !props.isDisabled ? -1 : undefined
+        }, interactionProps)
+    };
 }
-/**
- * Provides DOM props to the nearest focusable child.
- */
 
 
-function $e11539c8317b2d21639df611cb5658f$var$FocusableProvider(props, ref) {
-  let {
-    children
-  } = props,
-      otherProps = _babelRuntimeHelpersEsmObjectWithoutPropertiesLoose(props, ["children"]);
 
-  let context = _babelRuntimeHelpersEsmExtends({}, otherProps, {
-    ref
-  });
 
-  return /*#__PURE__*/_react.createElement($e11539c8317b2d21639df611cb5658f$var$FocusableContext.Provider, {
-    value: context
-  }, children);
-}
 
-export let FocusableProvider = /*#__PURE__*/_react.forwardRef($e11539c8317b2d21639df611cb5658f$var$FocusableProvider);
 
-/**
- * Used to make an element focusable and capable of auto focus.
- */
-export function useFocusable(props, domRef) {
-  let {
-    focusProps
-  } = useFocus(props);
-  let {
-    keyboardProps
-  } = useKeyboard(props);
-  let interactions = mergeProps(focusProps, keyboardProps);
-  let domProps = $e11539c8317b2d21639df611cb5658f$var$useFocusableContext(domRef);
-  let interactionProps = props.isDisabled ? {} : domProps;
-  useEffect(() => {
-    if (props.autoFocus && domRef.current) {
-      domRef.current.focus();
-    }
-  }, [props.autoFocus, domRef]);
-  return {
-    focusableProps: mergeProps(_babelRuntimeHelpersEsmExtends({}, interactions, {
-      tabIndex: props.excludeFromTabOrder && !props.isDisabled ? -1 : undefined
-    }), interactionProps)
-  };
-}
+export {$14e5c84cbc2e6e2e$export$20e40289641fbbb6 as FocusScope, $14e5c84cbc2e6e2e$export$10c5169755ce7bd7 as useFocusManager, $14e5c84cbc2e6e2e$export$2d6ec8fc375ceafa as getFocusableTreeWalker, $14e5c84cbc2e6e2e$export$c5251b9e124bf29 as createFocusManager, $503734efc0922182$export$1a38b4ad7f578e1d as FocusRing, $391c6482f25a1991$export$13f3202a3e5ddd5 as FocusableProvider, $391c6482f25a1991$export$4c014de7c8940b4c as useFocusable, $e63d024ca16f2165$export$4e328f61c538687f as useFocusRing, $1159c3b6ba210e4f$export$80f3e147d781571c as focusSafely};
 //# sourceMappingURL=module.js.map