@react-aria/focus 3.5.0 → 3.5.3

package/dist/main.js

@@ -1,65 +1,56 @@
-var _babelRuntimeHelpersObjectWithoutPropertiesLoose = $parcel$interopDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
-
-var _clsx = $parcel$interopDefault(require("clsx"));
-
-var _babelRuntimeHelpersExtends = $parcel$interopDefault(require("@babel/runtime/helpers/extends"));
-
-var _react2 = require("react");
-
-var _react = $parcel$interopDefault(_react2);
-
-var {
-  useContext,
-  useEffect,
-  useRef,
-  useState
-} = _react2;
-
-var {
-  getInteractionModality,
-  isFocusVisible: _isFocusVisible,
-  useFocus,
-  useFocusVisibleListener,
-  useFocusWithin,
-  useKeyboard
-} = require("@react-aria/interactions");
+var $aB6Cp$react = require("react");
+var $aB6Cp$reactariautils = require("@react-aria/utils");
+var $aB6Cp$reactariainteractions = require("@react-aria/interactions");
+var $aB6Cp$clsx = require("clsx");
+
+function $parcel$exportWildcard(dest, source) {
+  Object.keys(source).forEach(function(key) {
+    if (key === 'default' || key === '__esModule' || dest.hasOwnProperty(key)) {
+      return;
+    }
 
-var {
-  focusWithoutScrolling,
-  runAfterTransition,
-  useLayoutEffect,
-  mergeProps,
-  useSyncRef
-} = require("@react-aria/utils");
+    Object.defineProperty(dest, key, {
+      enumerable: true,
+      get: function get() {
+        return source[key];
+      }
+    });
+  });
 
+  return dest;
+}
 function $parcel$interopDefault(a) {
   return a && a.__esModule ? a.default : a;
 }
-
-/**
- * A utility function that focuses an element while avoiding undesired side effects such
- * as page scrolling and screen reader issues with CSS transitions.
- */
-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 $a7a032acae3ddda9$exports = {};
+
+$parcel$export($a7a032acae3ddda9$exports, "FocusScope", () => $a7a032acae3ddda9$export$20e40289641fbbb6);
+$parcel$export($a7a032acae3ddda9$exports, "useFocusManager", () => $a7a032acae3ddda9$export$10c5169755ce7bd7);
+$parcel$export($a7a032acae3ddda9$exports, "getFocusableTreeWalker", () => $a7a032acae3ddda9$export$2d6ec8fc375ceafa);
+$parcel$export($a7a032acae3ddda9$exports, "createFocusManager", () => $a7a032acae3ddda9$export$c5251b9e124bf29);
+var $1c7f9157d722357d$exports = {};
+
+$parcel$export($1c7f9157d722357d$exports, "focusSafely", () => $1c7f9157d722357d$export$80f3e147d781571c);
+
+
+function $1c7f9157d722357d$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 ($aB6Cp$reactariainteractions.getInteractionModality() === 'virtual') {
+        let lastFocusedElement = document.activeElement;
+        $aB6Cp$reactariautils.runAfterTransition(()=>{
+            // If focus did not move and the element is still in the document, focus it.
+            if (document.activeElement === lastFocusedElement && document.contains(element)) $aB6Cp$reactariautils.focusWithoutScrolling(element);
+        });
+    } else $aB6Cp$reactariautils.focusWithoutScrolling(element);
 }
 
-exports.focusSafely = focusSafely;
 
 /*
  * Copyright 2021 Adobe. All rights reserved.
@@ -71,836 +62,564 @@ exports.focusSafely = focusSafely;
  * 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 $f5b8109741a107bfe8bf4093e29$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 $f5b8109741a107bfe8bf4093e29$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 $f5b8109741a107bfe8bf4093e29$export$isElementVisible(element, childElement) {
-  return element.nodeName !== '#comment' && $f5b8109741a107bfe8bf4093e29$var$isStyleVisible(element) && $f5b8109741a107bfe8bf4093e29$var$isAttributeVisible(element, childElement) && (!element.parentElement || $f5b8109741a107bfe8bf4093e29$export$isElementVisible(element.parentElement, element));
-}
-
-const $bdceb2956edbee43435a9382ef97283f$var$FocusContext = /*#__PURE__*/_react.createContext(null);
-
-let $bdceb2956edbee43435a9382ef97283f$var$activeScope = null;
-let $bdceb2956edbee43435a9382ef97283f$var$scopes = new Map(); // 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.
- */
-
-function FocusScope(props) {
-  let {
-    children,
-    contain,
-    restoreFocus,
-    autoFocus
-  } = props;
-  let startRef = useRef();
-  let endRef = useRef();
-  let scopeRef = useRef([]);
-  let ctx = useContext($bdceb2956edbee43435a9382ef97283f$var$FocusContext);
-  let parentScope = ctx == null ? void 0 : ctx.scopeRef;
-  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]);
-  useLayoutEffect(() => {
-    $bdceb2956edbee43435a9382ef97283f$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 === $bdceb2956edbee43435a9382ef97283f$var$activeScope || $bdceb2956edbee43435a9382ef97283f$var$isAncestorScope(scopeRef, $bdceb2956edbee43435a9382ef97283f$var$activeScope)) && (!parentScope || $bdceb2956edbee43435a9382ef97283f$var$scopes.has(parentScope))) {
-        $bdceb2956edbee43435a9382ef97283f$var$activeScope = parentScope;
-      }
-
-      $bdceb2956edbee43435a9382ef97283f$var$scopes.delete(scopeRef);
-    };
-  }, [scopeRef, parentScope]);
-  $bdceb2956edbee43435a9382ef97283f$var$useFocusContainment(scopeRef, contain);
-  $bdceb2956edbee43435a9382ef97283f$var$useRestoreFocus(scopeRef, restoreFocus, contain);
-  $bdceb2956edbee43435a9382ef97283f$var$useAutoFocus(scopeRef, autoFocus);
-  let focusManager = $bdceb2956edbee43435a9382ef97283f$var$createFocusManagerForScope(scopeRef);
-  return /*#__PURE__*/_react.createElement($bdceb2956edbee43435a9382ef97283f$var$FocusContext.Provider, {
-    value: {
-      scopeRef,
-      focusManager
+ */ function $d5156037ad898a4d$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';
     }
-  }, /*#__PURE__*/_react.createElement("span", {
-    "data-focus-scope-start": true,
-    hidden: true,
-    ref: startRef
-  }), children, /*#__PURE__*/_react.createElement("span", {
-    "data-focus-scope-end": true,
-    hidden: true,
-    ref: endRef
-  }));
+    return isVisible;
 }
-/**
- * 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.
- */
-
-
-exports.FocusScope = FocusScope;
-
-function useFocusManager() {
-  var _useContext;
-
-  return (_useContext = useContext($bdceb2956edbee43435a9382ef97283f$var$FocusContext)) == null ? void 0 : _useContext.focusManager;
+function $d5156037ad898a4d$var$isAttributeVisible(element, childElement) {
+    return !element.hasAttribute('hidden') && (element.nodeName === 'DETAILS' && childElement && childElement.nodeName !== 'SUMMARY' ? element.hasAttribute('open') : true);
 }
-
-exports.useFocusManager = useFocusManager;
-
-function $bdceb2956edbee43435a9382ef97283f$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($bdceb2956edbee43435a9382ef97283f$var$getScopeRoot(scope), {
-        tabbable
-      }, scope);
-      walker.currentNode = $bdceb2956edbee43435a9382ef97283f$var$isElementInScope(node, scope) ? node : sentinel;
-      let nextNode = walker.nextNode();
-
-      if (!nextNode && wrap) {
-        walker.currentNode = sentinel;
-        nextNode = walker.nextNode();
-      }
-
-      if (nextNode) {
-        $bdceb2956edbee43435a9382ef97283f$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($bdceb2956edbee43435a9382ef97283f$var$getScopeRoot(scope), {
-        tabbable
-      }, scope);
-      walker.currentNode = $bdceb2956edbee43435a9382ef97283f$var$isElementInScope(node, scope) ? node : sentinel;
-      let previousNode = walker.previousNode();
-
-      if (!previousNode && wrap) {
-        walker.currentNode = sentinel;
-        previousNode = walker.previousNode();
-      }
-
-      if (previousNode) {
-        $bdceb2956edbee43435a9382ef97283f$var$focusElement(previousNode, true);
-      }
-
-      return previousNode;
-    },
-
-    focusFirst(opts) {
-      if (opts === void 0) {
-        opts = {};
-      }
-
-      let scope = scopeRef.current;
-      let {
-        tabbable
-      } = opts;
-      let walker = getFocusableTreeWalker($bdceb2956edbee43435a9382ef97283f$var$getScopeRoot(scope), {
-        tabbable
-      }, scope);
-      walker.currentNode = scope[0].previousElementSibling;
-      let nextNode = walker.nextNode();
-
-      if (nextNode) {
-        $bdceb2956edbee43435a9382ef97283f$var$focusElement(nextNode, true);
-      }
-
-      return nextNode;
-    },
-
-    focusLast(opts) {
-      if (opts === void 0) {
-        opts = {};
-      }
-
-      let scope = scopeRef.current;
-      let {
-        tabbable
-      } = opts;
-      let walker = getFocusableTreeWalker($bdceb2956edbee43435a9382ef97283f$var$getScopeRoot(scope), {
-        tabbable
-      }, scope);
-      walker.currentNode = scope[scope.length - 1].nextElementSibling;
-      let previousNode = walker.previousNode();
-
-      if (previousNode) {
-        $bdceb2956edbee43435a9382ef97283f$var$focusElement(previousNode, true);
-      }
-
-      return previousNode;
-    }
-
-  };
+function $d5156037ad898a4d$export$e989c0fffaa6b27a(element, childElement) {
+    return element.nodeName !== '#comment' && $d5156037ad898a4d$var$isStyleVisible(element) && $d5156037ad898a4d$var$isAttributeVisible(element, childElement) && (!element.parentElement || $d5156037ad898a4d$export$e989c0fffaa6b27a(element.parentElement, element));
 }
 
-const $bdceb2956edbee43435a9382ef97283f$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 $bdceb2956edbee43435a9382ef97283f$var$FOCUSABLE_ELEMENT_SELECTOR = $bdceb2956edbee43435a9382ef97283f$var$focusableElements.join(':not([hidden]),') + ',[tabindex]:not([disabled]):not([hidden])';
-$bdceb2956edbee43435a9382ef97283f$var$focusableElements.push('[tabindex]:not([tabindex="-1"]):not([disabled])');
-const $bdceb2956edbee43435a9382ef97283f$var$TABBABLE_ELEMENT_SELECTOR = $bdceb2956edbee43435a9382ef97283f$var$focusableElements.join(':not([hidden]):not([tabindex="-1"]),');
 
-function $bdceb2956edbee43435a9382ef97283f$var$getScopeRoot(scope) {
-  return scope[0].parentElement;
-}
-
-function $bdceb2956edbee43435a9382ef97283f$var$useFocusContainment(scopeRef, contain) {
-  let focusedNode = useRef();
-  let raf = useRef(null);
-  useLayoutEffect(() => {
-    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 || scopeRef !== $bdceb2956edbee43435a9382ef97283f$var$activeScope) {
-        return;
-      }
-
-      let focusedElement = document.activeElement;
-      let scope = scopeRef.current;
-
-      if (!$bdceb2956edbee43435a9382ef97283f$var$isElementInScope(focusedElement, scope)) {
-        return;
-      }
-
-      let walker = getFocusableTreeWalker($bdceb2956edbee43435a9382ef97283f$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) {
-        $bdceb2956edbee43435a9382ef97283f$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 (!$bdceb2956edbee43435a9382ef97283f$var$activeScope || $bdceb2956edbee43435a9382ef97283f$var$isAncestorScope($bdceb2956edbee43435a9382ef97283f$var$activeScope, scopeRef)) {
-        $bdceb2956edbee43435a9382ef97283f$var$activeScope = scopeRef;
-        focusedNode.current = e.target;
-      } else if (scopeRef === $bdceb2956edbee43435a9382ef97283f$var$activeScope && !$bdceb2956edbee43435a9382ef97283f$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 ($bdceb2956edbee43435a9382ef97283f$var$activeScope) {
-          $bdceb2956edbee43435a9382ef97283f$var$focusFirstInScope($bdceb2956edbee43435a9382ef97283f$var$activeScope.current);
+const $a7a032acae3ddda9$var$FocusContext = /*#__PURE__*/ ($parcel$interopDefault($aB6Cp$react)).createContext(null);
+let $a7a032acae3ddda9$var$activeScope = null;
+let $a7a032acae3ddda9$var$scopes = new Map();
+function $a7a032acae3ddda9$export$20e40289641fbbb6(props) {
+    let { children: children , contain: contain , restoreFocus: restoreFocus , autoFocus: autoFocus  } = props;
+    let startRef = $aB6Cp$react.useRef();
+    let endRef = $aB6Cp$react.useRef();
+    let scopeRef = $aB6Cp$react.useRef([]);
+    let ctx = $aB6Cp$react.useContext($a7a032acae3ddda9$var$FocusContext);
+    let parentScope = ctx === null || ctx === void 0 ? void 0 : ctx.scopeRef;
+    $aB6Cp$reactariautils.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;
         }
-      } else if (scopeRef === $bdceb2956edbee43435a9382ef97283f$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 === $bdceb2956edbee43435a9382ef97283f$var$activeScope && !$bdceb2956edbee43435a9382ef97283f$var$isElementInChildScope(document.activeElement, scopeRef)) {
-          $bdceb2956edbee43435a9382ef97283f$var$activeScope = scopeRef;
-          focusedNode.current = e.target;
-          focusedNode.current.focus();
+        scopeRef.current = nodes;
+    }, [
+        children,
+        parentScope
+    ]);
+    $aB6Cp$reactariautils.useLayoutEffect(()=>{
+        $a7a032acae3ddda9$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 === $a7a032acae3ddda9$var$activeScope || $a7a032acae3ddda9$var$isAncestorScope(scopeRef, $a7a032acae3ddda9$var$activeScope)) && (!parentScope || $a7a032acae3ddda9$var$scopes.has(parentScope))) $a7a032acae3ddda9$var$activeScope = parentScope;
+            $a7a032acae3ddda9$var$scopes.delete(scopeRef);
+        };
+    }, [
+        scopeRef,
+        parentScope
+    ]);
+    $a7a032acae3ddda9$var$useFocusContainment(scopeRef, contain);
+    $a7a032acae3ddda9$var$useRestoreFocus(scopeRef, restoreFocus, contain);
+    $a7a032acae3ddda9$var$useAutoFocus(scopeRef, autoFocus);
+    let focusManager = $a7a032acae3ddda9$var$createFocusManagerForScope(scopeRef);
+    return(/*#__PURE__*/ ($parcel$interopDefault($aB6Cp$react)).createElement($a7a032acae3ddda9$var$FocusContext.Provider, {
+        value: {
+            scopeRef: scopeRef,
+            focusManager: focusManager
+        }
+    }, /*#__PURE__*/ ($parcel$interopDefault($aB6Cp$react)).createElement("span", {
+        "data-focus-scope-start": true,
+        hidden: true,
+        ref: startRef
+    }), children, /*#__PURE__*/ ($parcel$interopDefault($aB6Cp$react)).createElement("span", {
+        "data-focus-scope-end": true,
+        hidden: true,
+        ref: endRef
+    })));
+}
+function $a7a032acae3ddda9$export$10c5169755ce7bd7() {
+    var ref;
+    return (ref = $aB6Cp$react.useContext($a7a032acae3ddda9$var$FocusContext)) === null || ref === void 0 ? void 0 : ref.focusManager;
+}
+function $a7a032acae3ddda9$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 = $a7a032acae3ddda9$export$2d6ec8fc375ceafa($a7a032acae3ddda9$var$getScopeRoot(scope), {
+                tabbable: tabbable
+            }, scope);
+            walker.currentNode = $a7a032acae3ddda9$var$isElementInScope(node, scope) ? node : sentinel;
+            let nextNode = walker.nextNode();
+            if (!nextNode && wrap) {
+                walker.currentNode = sentinel;
+                nextNode = walker.nextNode();
+            }
+            if (nextNode) $a7a032acae3ddda9$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 = $a7a032acae3ddda9$export$2d6ec8fc375ceafa($a7a032acae3ddda9$var$getScopeRoot(scope), {
+                tabbable: tabbable
+            }, scope);
+            walker.currentNode = $a7a032acae3ddda9$var$isElementInScope(node, scope) ? node : sentinel;
+            let previousNode = walker.previousNode();
+            if (!previousNode && wrap) {
+                walker.currentNode = sentinel;
+                previousNode = walker.previousNode();
+            }
+            if (previousNode) $a7a032acae3ddda9$var$focusElement(previousNode, true);
+            return previousNode;
+        },
+        focusFirst (opts = {
+        }) {
+            let scope = scopeRef.current;
+            let { tabbable: tabbable  } = opts;
+            let walker = $a7a032acae3ddda9$export$2d6ec8fc375ceafa($a7a032acae3ddda9$var$getScopeRoot(scope), {
+                tabbable: tabbable
+            }, scope);
+            walker.currentNode = scope[0].previousElementSibling;
+            let nextNode = walker.nextNode();
+            if (nextNode) $a7a032acae3ddda9$var$focusElement(nextNode, true);
+            return nextNode;
+        },
+        focusLast (opts = {
+        }) {
+            let scope = scopeRef.current;
+            let { tabbable: tabbable  } = opts;
+            let walker = $a7a032acae3ddda9$export$2d6ec8fc375ceafa($a7a032acae3ddda9$var$getScopeRoot(scope), {
+                tabbable: tabbable
+            }, scope);
+            walker.currentNode = scope[scope.length - 1].nextElementSibling;
+            let previousNode = walker.previousNode();
+            if (previousNode) $a7a032acae3ddda9$var$focusElement(previousNode, true);
+            return previousNode;
         }
-      });
-    };
-
-    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 $bdceb2956edbee43435a9382ef97283f$var$isElementInAnyScope(element) {
-  for (let scope of $bdceb2956edbee43435a9382ef97283f$var$scopes.keys()) {
-    if ($bdceb2956edbee43435a9382ef97283f$var$isElementInScope(element, scope.current)) {
-      return true;
-    }
-  }
-
-  return false;
+const $a7a032acae3ddda9$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 $a7a032acae3ddda9$var$FOCUSABLE_ELEMENT_SELECTOR = $a7a032acae3ddda9$var$focusableElements.join(':not([hidden]),') + ',[tabindex]:not([disabled]):not([hidden])';
+$a7a032acae3ddda9$var$focusableElements.push('[tabindex]:not([tabindex="-1"]):not([disabled])');
+const $a7a032acae3ddda9$var$TABBABLE_ELEMENT_SELECTOR = $a7a032acae3ddda9$var$focusableElements.join(':not([hidden]):not([tabindex="-1"]),');
+function $a7a032acae3ddda9$var$getScopeRoot(scope) {
+    return scope[0].parentElement;
 }
-
-function $bdceb2956edbee43435a9382ef97283f$var$isElementInScope(element, scope) {
-  return scope.some(node => node.contains(element));
+function $a7a032acae3ddda9$var$useFocusContainment(scopeRef, contain) {
+    let focusedNode = $aB6Cp$react.useRef();
+    let raf = $aB6Cp$react.useRef(null);
+    $aB6Cp$reactariautils.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 !== $a7a032acae3ddda9$var$activeScope) return;
+            let focusedElement = document.activeElement;
+            let scope = scopeRef.current;
+            if (!$a7a032acae3ddda9$var$isElementInScope(focusedElement, scope)) return;
+            let walker = $a7a032acae3ddda9$export$2d6ec8fc375ceafa($a7a032acae3ddda9$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) $a7a032acae3ddda9$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 (!$a7a032acae3ddda9$var$activeScope || $a7a032acae3ddda9$var$isAncestorScope($a7a032acae3ddda9$var$activeScope, scopeRef)) {
+                $a7a032acae3ddda9$var$activeScope = scopeRef;
+                focusedNode.current = e.target;
+            } else if (scopeRef === $a7a032acae3ddda9$var$activeScope && !$a7a032acae3ddda9$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 ($a7a032acae3ddda9$var$activeScope) $a7a032acae3ddda9$var$focusFirstInScope($a7a032acae3ddda9$var$activeScope.current);
+            } else if (scopeRef === $a7a032acae3ddda9$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 === $a7a032acae3ddda9$var$activeScope && !$a7a032acae3ddda9$var$isElementInChildScope(document.activeElement, scopeRef)) {
+                    $a7a032acae3ddda9$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
+    $aB6Cp$react.useEffect(()=>{
+        return ()=>cancelAnimationFrame(raf.current)
+        ;
+    }, [
+        raf
+    ]);
 }
-
-function $bdceb2956edbee43435a9382ef97283f$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 $bdceb2956edbee43435a9382ef97283f$var$scopes.keys()) {
-    if ((s === scope || $bdceb2956edbee43435a9382ef97283f$var$isAncestorScope(scope, s)) && $bdceb2956edbee43435a9382ef97283f$var$isElementInScope(element, s.current)) {
-      return true;
+function $a7a032acae3ddda9$var$isElementInAnyScope(element) {
+    for (let scope of $a7a032acae3ddda9$var$scopes.keys()){
+        if ($a7a032acae3ddda9$var$isElementInScope(element, scope.current)) return true;
     }
-  }
-
-  return false;
-}
-
-function $bdceb2956edbee43435a9382ef97283f$var$isAncestorScope(ancestor, scope) {
-  let parent = $bdceb2956edbee43435a9382ef97283f$var$scopes.get(scope);
-
-  if (!parent) {
     return false;
-  }
-
-  if (parent === ancestor) {
-    return true;
-  }
-
-  return $bdceb2956edbee43435a9382ef97283f$var$isAncestorScope(ancestor, parent);
 }
-
-function $bdceb2956edbee43435a9382ef97283f$var$focusElement(element, scroll) {
-  if (scroll === void 0) {
-    scroll = false;
-  }
-
-  if (element != null && !scroll) {
-    try {
-      focusSafely(element);
-    } catch (err) {// ignore
-    }
-  } else if (element != null) {
-    try {
-      element.focus();
-    } catch (err) {// ignore
+function $a7a032acae3ddda9$var$isElementInScope(element, scope) {
+    return scope.some((node)=>node.contains(element)
+    );
+}
+function $a7a032acae3ddda9$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 $a7a032acae3ddda9$var$scopes.keys()){
+        if ((s === scope || $a7a032acae3ddda9$var$isAncestorScope(scope, s)) && $a7a032acae3ddda9$var$isElementInScope(element, s.current)) return true;
     }
-  }
+    return false;
 }
-
-function $bdceb2956edbee43435a9382ef97283f$var$focusFirstInScope(scope) {
-  let sentinel = scope[0].previousElementSibling;
-  let walker = getFocusableTreeWalker($bdceb2956edbee43435a9382ef97283f$var$getScopeRoot(scope), {
-    tabbable: true
-  }, scope);
-  walker.currentNode = sentinel;
-  $bdceb2956edbee43435a9382ef97283f$var$focusElement(walker.nextNode());
+function $a7a032acae3ddda9$var$isAncestorScope(ancestor, scope) {
+    let parent = $a7a032acae3ddda9$var$scopes.get(scope);
+    if (!parent) return false;
+    if (parent === ancestor) return true;
+    return $a7a032acae3ddda9$var$isAncestorScope(ancestor, parent);
 }
-
-function $bdceb2956edbee43435a9382ef97283f$var$useAutoFocus(scopeRef, autoFocus) {
-  const autoFocusRef = _react.useRef(autoFocus);
-
-  useEffect(() => {
-    if (autoFocusRef.current) {
-      $bdceb2956edbee43435a9382ef97283f$var$activeScope = scopeRef;
-
-      if (!$bdceb2956edbee43435a9382ef97283f$var$isElementInScope(document.activeElement, $bdceb2956edbee43435a9382ef97283f$var$activeScope.current)) {
-        $bdceb2956edbee43435a9382ef97283f$var$focusFirstInScope(scopeRef.current);
-      }
+function $a7a032acae3ddda9$var$focusElement(element, scroll = false) {
+    if (element != null && !scroll) try {
+        $1c7f9157d722357d$export$80f3e147d781571c(element);
+    } catch (err) {
+    // ignore
     }
-
-    autoFocusRef.current = false;
-  }, []);
-}
-
-function $bdceb2956edbee43435a9382ef97283f$var$useRestoreFocus(scopeRef, restoreFocus, contain) {
-  // useLayoutEffect instead of useEffect so the active element is saved synchronously instead of asynchronously.
-  useLayoutEffect(() => {
-    if (!restoreFocus) {
-      return;
+    else if (element != null) try {
+        element.focus();
+    } catch (err1) {
+    // ignore
     }
-
-    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 (!$bdceb2956edbee43435a9382ef97283f$var$isElementInScope(focusedElement, scope)) {
-        return;
-      } // Create a DOM tree walker that matches all tabbable elements
-
-
-      let walker = getFocusableTreeWalker(document.body, {
+}
+function $a7a032acae3ddda9$var$focusFirstInScope(scope) {
+    let sentinel = scope[0].previousElementSibling;
+    let walker = $a7a032acae3ddda9$export$2d6ec8fc375ceafa($a7a032acae3ddda9$var$getScopeRoot(scope), {
         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 || !$bdceb2956edbee43435a9382ef97283f$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 ($bdceb2956edbee43435a9382ef97283f$var$isElementInScope(nextElement, scope));
-
-        e.preventDefault();
-        e.stopPropagation();
-
-        if (nextElement) {
-          $bdceb2956edbee43435a9382ef97283f$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 (!$bdceb2956edbee43435a9382ef97283f$var$isElementInAnyScope(nodeToRestore)) {
-            focusedElement.blur();
-          } else {
-            $bdceb2956edbee43435a9382ef97283f$var$focusElement(nodeToRestore, true);
-          }
+    }, scope);
+    walker.currentNode = sentinel;
+    $a7a032acae3ddda9$var$focusElement(walker.nextNode());
+}
+function $a7a032acae3ddda9$var$useAutoFocus(scopeRef, autoFocus) {
+    const autoFocusRef = ($parcel$interopDefault($aB6Cp$react)).useRef(autoFocus);
+    $aB6Cp$react.useEffect(()=>{
+        if (autoFocusRef.current) {
+            $a7a032acae3ddda9$var$activeScope = scopeRef;
+            if (!$a7a032acae3ddda9$var$isElementInScope(document.activeElement, $a7a032acae3ddda9$var$activeScope.current)) $a7a032acae3ddda9$var$focusFirstInScope(scopeRef.current);
         }
-      }
-    };
-
-    if (!contain) {
-      document.addEventListener('keydown', onKeyDown, true);
-    }
-
-    return () => {
-      if (!contain) {
-        document.removeEventListener('keydown', onKeyDown, true);
-      }
-
-      if (restoreFocus && nodeToRestore && $bdceb2956edbee43435a9382ef97283f$var$isElementInScope(document.activeElement, scope)) {
-        requestAnimationFrame(() => {
-          if (document.body.contains(nodeToRestore)) {
-            $bdceb2956edbee43435a9382ef97283f$var$focusElement(nodeToRestore);
-          }
-        });
-      }
-    };
-  }, [scopeRef, restoreFocus, contain]);
+        autoFocusRef.current = false;
+    }, []);
 }
-/**
- * Create a [TreeWalker]{@link https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker}
- * that matches all focusable/tabbable elements.
- */
-
-
-function getFocusableTreeWalker(root, opts, scope) {
-  let selector = opts != null && opts.tabbable ? $bdceb2956edbee43435a9382ef97283f$var$TABBABLE_ELEMENT_SELECTOR : $bdceb2956edbee43435a9382ef97283f$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) && $f5b8109741a107bfe8bf4093e29$export$isElementVisible(node) && (!scope || $bdceb2956edbee43435a9382ef97283f$var$isElementInScope(node, scope))) {
-        return NodeFilter.FILTER_ACCEPT;
-      }
-
-      return NodeFilter.FILTER_SKIP;
-    }
-
-  });
-
-  if (opts != null && opts.from) {
-    walker.currentNode = opts.from;
-  }
-
-  return walker;
+function $a7a032acae3ddda9$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 = $aB6Cp$react.useRef(typeof document !== 'undefined' ? document.activeElement : null);
+    // useLayoutEffect instead of useEffect so the active element is saved synchronously instead of asynchronously.
+    $aB6Cp$reactariautils.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 (!$a7a032acae3ddda9$var$isElementInScope(focusedElement, scopeRef.current)) return;
+            // Create a DOM tree walker that matches all tabbable elements
+            let walker = $a7a032acae3ddda9$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 || !$a7a032acae3ddda9$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 ($a7a032acae3ddda9$var$isElementInScope(nextElement, scopeRef.current))
+                e.preventDefault();
+                e.stopPropagation();
+                if (nextElement) $a7a032acae3ddda9$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 (!$a7a032acae3ddda9$var$isElementInAnyScope(nodeToRestore)) focusedElement.blur();
+                else $a7a032acae3ddda9$var$focusElement(nodeToRestore, true);
+            }
+        };
+        if (!contain) document.addEventListener('keydown', onKeyDown, true);
+        return ()=>{
+            if (!contain) document.removeEventListener('keydown', onKeyDown, true);
+            if (restoreFocus && nodeToRestore && $a7a032acae3ddda9$var$isElementInScope(document.activeElement, scopeRef.current)) requestAnimationFrame(()=>{
+                if (document.body.contains(nodeToRestore)) $a7a032acae3ddda9$var$focusElement(nodeToRestore);
+            });
+        };
+    }, [
+        scopeRef,
+        restoreFocus,
+        contain
+    ]);
 }
-/**
- * Creates a FocusManager object that can be used to move focus within an element.
- */
-
-
-exports.getFocusableTreeWalker = getFocusableTreeWalker;
-
-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) {
-        $bdceb2956edbee43435a9382ef97283f$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 = $bdceb2956edbee43435a9382ef97283f$var$last(walker);
-
-        if (next) {
-          $bdceb2956edbee43435a9382ef97283f$var$focusElement(next, true);
+function $a7a032acae3ddda9$export$2d6ec8fc375ceafa(root, opts, scope) {
+    let selector = (opts === null || opts === void 0 ? void 0 : opts.tabbable) ? $a7a032acae3ddda9$var$TABBABLE_ELEMENT_SELECTOR : $a7a032acae3ddda9$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) && $d5156037ad898a4d$export$e989c0fffaa6b27a(node) && (!scope || $a7a032acae3ddda9$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 $a7a032acae3ddda9$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 = $a7a032acae3ddda9$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) $a7a032acae3ddda9$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 = $a7a032acae3ddda9$export$2d6ec8fc375ceafa(root, {
+                tabbable: tabbable
+            });
+            if (root.contains(node)) walker.currentNode = node;
+            else {
+                let next = $a7a032acae3ddda9$var$last(walker);
+                if (next) $a7a032acae3ddda9$var$focusElement(next, true);
+                return next;
+            }
+            let previousNode = walker.previousNode();
+            if (!previousNode && wrap) {
+                walker.currentNode = root;
+                previousNode = $a7a032acae3ddda9$var$last(walker);
+            }
+            if (previousNode) $a7a032acae3ddda9$var$focusElement(previousNode, true);
+            return previousNode;
+        },
+        focusFirst (opts = {
+        }) {
+            let root = ref.current;
+            let { tabbable: tabbable  } = opts;
+            let walker = $a7a032acae3ddda9$export$2d6ec8fc375ceafa(root, {
+                tabbable: tabbable
+            });
+            let nextNode = walker.nextNode();
+            if (nextNode) $a7a032acae3ddda9$var$focusElement(nextNode, true);
+            return nextNode;
+        },
+        focusLast (opts = {
+        }) {
+            let root = ref.current;
+            let { tabbable: tabbable  } = opts;
+            let walker = $a7a032acae3ddda9$export$2d6ec8fc375ceafa(root, {
+                tabbable: tabbable
+            });
+            let next = $a7a032acae3ddda9$var$last(walker);
+            if (next) $a7a032acae3ddda9$var$focusElement(next, true);
+            return next;
+        }
+    };
+}
+function $a7a032acae3ddda9$var$last(walker) {
+    let next;
+    let last;
+    do {
+        last = walker.lastChild();
+        if (last) next = last;
+    }while (last)
+    return next;
+}
 
-        return next;
-      }
-
-      let previousNode = walker.previousNode();
-
-      if (!previousNode && wrap) {
-        walker.currentNode = root;
-        previousNode = $bdceb2956edbee43435a9382ef97283f$var$last(walker);
-      }
 
-      if (previousNode) {
-        $bdceb2956edbee43435a9382ef97283f$var$focusElement(previousNode, true);
-      }
+var $dfd8c70b928eb1b3$exports = {};
 
-      return previousNode;
-    },
+$parcel$export($dfd8c70b928eb1b3$exports, "FocusRing", () => $dfd8c70b928eb1b3$export$1a38b4ad7f578e1d);
 
-    focusFirst(opts) {
-      if (opts === void 0) {
-        opts = {};
-      }
 
-      let root = ref.current;
-      let {
-        tabbable
-      } = opts;
-      let walker = getFocusableTreeWalker(root, {
-        tabbable
-      });
-      let nextNode = walker.nextNode();
-
-      if (nextNode) {
-        $bdceb2956edbee43435a9382ef97283f$var$focusElement(nextNode, true);
-      }
 
-      return nextNode;
-    },
+var $581a96d6eb128c1b$exports = {};
 
-    focusLast(opts) {
-      if (opts === void 0) {
-        opts = {};
-      }
+$parcel$export($581a96d6eb128c1b$exports, "useFocusRing", () => $581a96d6eb128c1b$export$4e328f61c538687f);
 
-      let root = ref.current;
-      let {
-        tabbable
-      } = opts;
-      let walker = getFocusableTreeWalker(root, {
-        tabbable
-      });
-      let next = $bdceb2956edbee43435a9382ef97283f$var$last(walker);
-
-      if (next) {
-        $bdceb2956edbee43435a9382ef97283f$var$focusElement(next, true);
-      }
 
-      return next;
-    }
 
-  };
+function $581a96d6eb128c1b$export$4e328f61c538687f(props = {
+}) {
+    let { autoFocus: autoFocus = false , isTextInput: isTextInput , within: within  } = props;
+    let state = $aB6Cp$react.useRef({
+        isFocused: false,
+        isFocusVisible: autoFocus || $aB6Cp$reactariainteractions.isFocusVisible()
+    }).current;
+    let [isFocused1, setFocused] = $aB6Cp$react.useState(false);
+    let [isFocusVisibleState, setFocusVisible] = $aB6Cp$react.useState(()=>state.isFocused && state.isFocusVisible
+    );
+    let updateState = ()=>setFocusVisible(state.isFocused && state.isFocusVisible)
+    ;
+    let onFocusChange = (isFocused)=>{
+        state.isFocused = isFocused;
+        setFocused(isFocused);
+        updateState();
+    };
+    $aB6Cp$reactariainteractions.useFocusVisibleListener((isFocusVisible)=>{
+        state.isFocusVisible = isFocusVisible;
+        updateState();
+    }, [], {
+        isTextInput: isTextInput
+    });
+    let { focusProps: focusProps  } = $aB6Cp$reactariainteractions.useFocus({
+        isDisabled: within,
+        onFocusChange: onFocusChange
+    });
+    let { focusWithinProps: focusWithinProps  } = $aB6Cp$reactariainteractions.useFocusWithin({
+        isDisabled: !within,
+        onFocusWithinChange: onFocusChange
+    });
+    return {
+        isFocused: isFocused1,
+        isFocusVisible: state.isFocused && isFocusVisibleState,
+        focusProps: within ? focusWithinProps : focusProps
+    };
 }
 
-exports.createFocusManager = createFocusManager;
 
-function $bdceb2956edbee43435a9382ef97283f$var$last(walker) {
-  let next;
-  let last;
-
-  do {
-    last = walker.lastChild();
-
-    if (last) {
-      next = last;
-    }
-  } while (last);
-
-  return next;
+function $dfd8c70b928eb1b3$export$1a38b4ad7f578e1d(props) {
+    let { children: children , focusClass: focusClass , focusRingClass: focusRingClass  } = props;
+    let { isFocused: isFocused , isFocusVisible: isFocusVisible , focusProps: focusProps  } = $581a96d6eb128c1b$export$4e328f61c538687f(props);
+    let child = ($parcel$interopDefault($aB6Cp$react)).Children.only(children);
+    return(/*#__PURE__*/ ($parcel$interopDefault($aB6Cp$react)).cloneElement(child, $aB6Cp$reactariautils.mergeProps(child.props, {
+        ...focusProps,
+        className: ($parcel$interopDefault($aB6Cp$clsx))({
+            [focusClass || '']: isFocused,
+            [focusRingClass || '']: isFocusVisible
+        })
+    })));
 }
 
-/**
- * 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.
- */
-function useFocusRing(props) {
-  if (props === void 0) {
-    props = {};
-  }
-
-  let {
-    autoFocus = false,
-    isTextInput,
-    within
-  } = props;
-  let state = useRef({
-    isFocused: false,
-    isFocusVisible: autoFocus || _isFocusVisible()
-  }).current;
-  let [isFocused, setFocused] = useState(false);
-  let [isFocusVisibleState, setFocusVisible] = useState(() => state.isFocused && state.isFocusVisible);
-
-  let updateState = () => setFocusVisible(state.isFocused && state.isFocusVisible);
-
-  let onFocusChange = isFocused => {
-    state.isFocused = isFocused;
-    setFocused(isFocused);
-    updateState();
-  };
-
-  useFocusVisibleListener(isFocusVisible => {
-    state.isFocusVisible = isFocusVisible;
-    updateState();
-  }, [], {
-    isTextInput
-  });
-  let {
-    focusProps
-  } = useFocus({
-    isDisabled: within,
-    onFocusChange
-  });
-  let {
-    focusWithinProps
-  } = useFocusWithin({
-    isDisabled: !within,
-    onFocusWithinChange: onFocusChange
-  });
-  return {
-    isFocused,
-    isFocusVisible: state.isFocused && isFocusVisibleState,
-    focusProps: within ? focusWithinProps : focusProps
-  };
-}
-
-exports.useFocusRing = useFocusRing;
-
-/**
- * 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.
- */
-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, _babelRuntimeHelpersExtends({}, focusProps, {
-    className: _clsx({
-      [focusClass || '']: isFocused,
-      [focusRingClass || '']: isFocusVisible
-    })
-  })));
-}
 
-exports.FocusRing = FocusRing;
+var $fb504d83237fd6ac$exports = {};
 
-let $f284cbc8bcdf616ffabe3d006e2c9db$var$FocusableContext = /*#__PURE__*/_react.createContext(null);
+$parcel$export($fb504d83237fd6ac$exports, "FocusableProvider", () => $fb504d83237fd6ac$export$13f3202a3e5ddd5);
+$parcel$export($fb504d83237fd6ac$exports, "useFocusable", () => $fb504d83237fd6ac$export$4c014de7c8940b4c);
 
-function $f284cbc8bcdf616ffabe3d006e2c9db$var$useFocusableContext(ref) {
-  let context = useContext($f284cbc8bcdf616ffabe3d006e2c9db$var$FocusableContext) || {};
-  useSyncRef(context, ref); // eslint-disable-next-line
 
-  let otherProps = _babelRuntimeHelpersObjectWithoutPropertiesLoose(context, ["ref"]);
 
-  return otherProps;
+let $fb504d83237fd6ac$var$FocusableContext = /*#__PURE__*/ ($parcel$interopDefault($aB6Cp$react)).createContext(null);
+function $fb504d83237fd6ac$var$useFocusableContext(ref) {
+    let context = $aB6Cp$react.useContext($fb504d83237fd6ac$var$FocusableContext) || {
+    };
+    $aB6Cp$reactariautils.useSyncRef(context, ref);
+    // eslint-disable-next-line
+    let { ref: _ , ...otherProps } = context;
+    return otherProps;
 }
 /**
  * Provides DOM props to the nearest focusable child.
- */
-
-
-function $f284cbc8bcdf616ffabe3d006e2c9db$var$FocusableProvider(props, ref) {
-  let {
-    children
-  } = props,
-      otherProps = _babelRuntimeHelpersObjectWithoutPropertiesLoose(props, ["children"]);
-
-  let context = _babelRuntimeHelpersExtends({}, otherProps, {
-    ref
-  });
-
-  return /*#__PURE__*/_react.createElement($f284cbc8bcdf616ffabe3d006e2c9db$var$FocusableContext.Provider, {
-    value: context
-  }, children);
+ */ function $fb504d83237fd6ac$var$FocusableProvider(props, ref) {
+    let { children: children , ...otherProps } = props;
+    let context = {
+        ...otherProps,
+        ref: ref
+    };
+    return(/*#__PURE__*/ ($parcel$interopDefault($aB6Cp$react)).createElement($fb504d83237fd6ac$var$FocusableContext.Provider, {
+        value: context
+    }, children));
+}
+let $fb504d83237fd6ac$export$13f3202a3e5ddd5 = /*#__PURE__*/ ($parcel$interopDefault($aB6Cp$react)).forwardRef($fb504d83237fd6ac$var$FocusableProvider);
+function $fb504d83237fd6ac$export$4c014de7c8940b4c(props, domRef) {
+    let { focusProps: focusProps  } = $aB6Cp$reactariainteractions.useFocus(props);
+    let { keyboardProps: keyboardProps  } = $aB6Cp$reactariainteractions.useKeyboard(props);
+    let interactions = $aB6Cp$reactariautils.mergeProps(focusProps, keyboardProps);
+    let domProps = $fb504d83237fd6ac$var$useFocusableContext(domRef);
+    let interactionProps = props.isDisabled ? {
+    } : domProps;
+    let autoFocusRef = $aB6Cp$react.useRef(props.autoFocus);
+    $aB6Cp$react.useEffect(()=>{
+        if (autoFocusRef.current && domRef.current) domRef.current.focus();
+        autoFocusRef.current = false;
+    }, []);
+    return {
+        focusableProps: $aB6Cp$reactariautils.mergeProps({
+            ...interactions,
+            tabIndex: props.excludeFromTabOrder && !props.isDisabled ? -1 : undefined
+        }, interactionProps)
+    };
 }
 
-let FocusableProvider = /*#__PURE__*/_react.forwardRef($f284cbc8bcdf616ffabe3d006e2c9db$var$FocusableProvider);
 
-exports.FocusableProvider = FocusableProvider;
 
-/**
- * Used to make an element focusable and capable of auto focus.
- */
-function useFocusable(props, domRef) {
-  let {
-    focusProps
-  } = useFocus(props);
-  let {
-    keyboardProps
-  } = useKeyboard(props);
-  let interactions = mergeProps(focusProps, keyboardProps);
-  let domProps = $f284cbc8bcdf616ffabe3d006e2c9db$var$useFocusableContext(domRef);
-  let interactionProps = props.isDisabled ? {} : domProps;
-  let autoFocusRef = useRef(props.autoFocus);
-  useEffect(() => {
-    if (autoFocusRef.current && domRef.current) {
-      domRef.current.focus();
-    }
 
-    autoFocusRef.current = false;
-  }, []);
-  return {
-    focusableProps: mergeProps(_babelRuntimeHelpersExtends({}, interactions, {
-      tabIndex: props.excludeFromTabOrder && !props.isDisabled ? -1 : undefined
-    }), interactionProps)
-  };
-}
+$parcel$exportWildcard(module.exports, $a7a032acae3ddda9$exports);
+$parcel$exportWildcard(module.exports, $dfd8c70b928eb1b3$exports);
+$parcel$exportWildcard(module.exports, $fb504d83237fd6ac$exports);
+$parcel$exportWildcard(module.exports, $581a96d6eb128c1b$exports);
+$parcel$exportWildcard(module.exports, $1c7f9157d722357d$exports);
+
 
-exports.useFocusable = useFocusable;
 //# sourceMappingURL=main.js.map