{"mappings":"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","sources":["packages/@react-aria/focus/src/index.ts","packages/@react-aria/focus/src/FocusScope.tsx","packages/@react-aria/focus/src/focusSafely.ts","packages/@react-aria/focus/src/isElementVisible.ts","packages/@react-aria/focus/src/FocusRing.tsx","packages/@react-aria/focus/src/useFocusRing.ts","packages/@react-aria/focus/src/useFocusable.tsx","packages/@react-aria/focus/src/useHasTabbableChild.ts"],"sourcesContent":["/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nexport {FocusScope, useFocusManager, getFocusableTreeWalker, createFocusManager, isElementInChildOfActiveScope} from './FocusScope';\nexport {FocusRing} from './FocusRing';\nexport {FocusableProvider, useFocusable} from './useFocusable';\nexport {useFocusRing} from './useFocusRing';\nexport {focusSafely} from './focusSafely';\nexport {useHasTabbableChild} from './useHasTabbableChild';\n\nexport type {FocusScopeProps, FocusManager, FocusManagerOptions} from './FocusScope';\nexport type {FocusRingProps} from './FocusRing';\nexport type {FocusableAria, FocusableOptions, FocusableProviderProps} from './useFocusable';\nexport type {AriaFocusRingProps, FocusRingAria} from './useFocusRing';\n","/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {FocusableElement} from '@react-types/shared';\nimport {focusSafely} from './focusSafely';\nimport {isElementVisible} from './isElementVisible';\nimport React, {ReactNode, RefObject, useContext, useEffect, useMemo, useRef} from 'react';\nimport {useLayoutEffect} from '@react-aria/utils';\n\n\nexport interface FocusScopeProps {\n  /** The contents of the focus scope. */\n  children: ReactNode,\n\n  /**\n   * Whether to contain focus inside the scope, so users cannot\n   * move focus outside, for example in a modal dialog.\n   */\n  contain?: boolean,\n\n  /**\n   * Whether to restore focus back to the element that was focused\n   * when the focus scope mounted, after the focus scope unmounts.\n   */\n  restoreFocus?: boolean,\n\n  /** Whether to auto focus the first focusable element in the focus scope on mount. */\n  autoFocus?: boolean\n}\n\nexport interface FocusManagerOptions {\n  /** The element to start searching from. The currently focused element by default. */\n  from?: Element,\n  /** Whether to only include tabbable elements, or all focusable elements. */\n  tabbable?: boolean,\n  /** Whether focus should wrap around when it reaches the end of the scope. */\n  wrap?: boolean,\n  /** A callback that determines whether the given element is focused. */\n  accept?: (node: Element) => boolean\n}\n\nexport interface FocusManager {\n  /** Moves focus to the next focusable or tabbable element in the focus scope. */\n  focusNext(opts?: FocusManagerOptions): FocusableElement,\n  /** Moves focus to the previous focusable or tabbable element in the focus scope. */\n  focusPrevious(opts?: FocusManagerOptions): FocusableElement,\n  /** Moves focus to the first focusable or tabbable element in the focus scope. */\n  focusFirst(opts?: FocusManagerOptions): FocusableElement,\n    /** Moves focus to the last focusable or tabbable element in the focus scope. */\n  focusLast(opts?: FocusManagerOptions): FocusableElement\n}\n\ntype ScopeRef = RefObject<Element[]>;\ninterface IFocusContext {\n  focusManager: FocusManager,\n  parentNode: TreeNode | null\n}\n\nconst FocusContext = React.createContext<IFocusContext>(null);\n\nlet activeScope: ScopeRef = null;\n\n// This is a hacky DOM-based implementation of a FocusScope until this RFC lands in React:\n// https://github.com/reactjs/rfcs/pull/109\n\n/**\n * A FocusScope manages focus for its descendants. It supports containing focus inside\n * the scope, restoring focus to the previously focused element on unmount, and auto\n * focusing children on mount. It also acts as a container for a programmatic focus\n * management interface that can be used to move focus forward and back in response\n * to user events.\n */\nexport function FocusScope(props: FocusScopeProps) {\n  let {children, contain, restoreFocus, autoFocus} = props;\n  let startRef = useRef<HTMLSpanElement>();\n  let endRef = useRef<HTMLSpanElement>();\n  let scopeRef = useRef<Element[]>([]);\n  let {parentNode} = useContext(FocusContext) || {};\n\n  // Create a tree node here so we can add children to it even before it is added to the tree.\n  let node = useMemo(() => new TreeNode({scopeRef}), [scopeRef]);\n\n  useLayoutEffect(() => {\n    // If a new scope mounts outside the active scope, (e.g. DialogContainer launched from a menu),\n    // use the active scope as the parent instead of the parent from context. Layout effects run bottom\n    // up, so if the parent is not yet added to the tree, don't do this. Only the outer-most FocusScope\n    // that is being added should get the activeScope as its parent.\n    let parent = parentNode || focusScopeTree.root;\n    if (focusScopeTree.getTreeNode(parent.scopeRef) && activeScope && !isAncestorScope(activeScope, parent.scopeRef)) {\n      let activeNode = focusScopeTree.getTreeNode(activeScope);\n      if (activeNode) {\n        parent = activeNode;\n      }\n    }\n\n    // Add the node to the parent, and to the tree.\n    parent.addChild(node);\n    focusScopeTree.addNode(node);\n  }, [node, parentNode]);\n\n  useLayoutEffect(() => {\n    let node = focusScopeTree.getTreeNode(scopeRef);\n    node.contain = contain;\n  }, [contain]);\n\n  useLayoutEffect(() => {\n    // Find all rendered nodes between the sentinels and add them to the scope.\n    let node = startRef.current.nextSibling;\n    let nodes = [];\n    while (node && node !== endRef.current) {\n      nodes.push(node);\n      node = node.nextSibling;\n    }\n\n    scopeRef.current = nodes;\n  }, [children]);\n\n  useActiveScopeTracker(scopeRef, restoreFocus, contain);\n  useFocusContainment(scopeRef, contain);\n  useRestoreFocus(scopeRef, restoreFocus, contain);\n  useAutoFocus(scopeRef, autoFocus);\n\n  // this layout effect needs to run last so that focusScopeTree cleanup happens at the last moment possible\n  useEffect(() => {\n    if (scopeRef) {\n      let activeElement = document.activeElement;\n      let scope = null;\n      // In strict mode, active scope is incorrectly updated since cleanup will run even though scope hasn't unmounted.\n      // To fix this, we need to update the actual activeScope here\n      if (isElementInScope(activeElement, scopeRef.current)) {\n        // Since useLayoutEffect runs for children first, we need to traverse the focusScope tree and find the bottom most scope that\n        // contains the active element and set that as the activeScope\n        for (let node of focusScopeTree.traverse()) {\n          if (isElementInScope(activeElement, node.scopeRef.current)) {\n            scope = node;\n          }\n        }\n\n        if (scope === focusScopeTree.getTreeNode(scopeRef)) {\n          activeScope = scope.scopeRef;\n        }\n      }\n\n      return () => {\n        // Scope may have been re-parented.\n        let parentScope = focusScopeTree.getTreeNode(scopeRef).parent.scopeRef;\n\n        // Restore the active scope on unmount if this scope or a descendant scope is active.\n        // Parent effect cleanups run before children, so we need to check if the\n        // parent scope actually still exists before restoring the active scope to it.\n        if (\n          (scopeRef === activeScope || isAncestorScope(scopeRef, activeScope)) &&\n          (!parentScope || focusScopeTree.getTreeNode(parentScope))\n        ) {\n          activeScope = parentScope;\n        }\n        focusScopeTree.removeTreeNode(scopeRef);\n      };\n    }\n  }, [scopeRef]);\n\n  let focusManager = useMemo(() => createFocusManagerForScope(scopeRef), []);\n  let value = useMemo(() => ({\n    focusManager,\n    parentNode: node\n  }), [node, focusManager]);\n\n  return (\n    <FocusContext.Provider value={value}>\n      <span data-focus-scope-start hidden ref={startRef} />\n      {children}\n      <span data-focus-scope-end hidden ref={endRef} />\n    </FocusContext.Provider>\n  );\n}\n\n/**\n * Returns a FocusManager interface for the parent FocusScope.\n * A FocusManager can be used to programmatically move focus within\n * a FocusScope, e.g. in response to user events like keyboard navigation.\n */\nexport function useFocusManager(): FocusManager {\n  return useContext(FocusContext)?.focusManager;\n}\n\nfunction createFocusManagerForScope(scopeRef: React.RefObject<Element[]>): FocusManager {\n  return {\n    focusNext(opts: FocusManagerOptions = {}) {\n      let scope = scopeRef.current;\n      let {from, tabbable, wrap, accept} = opts;\n      let node = from || document.activeElement;\n      let sentinel = scope[0].previousElementSibling;\n      let walker = getFocusableTreeWalker(getScopeRoot(scope), {tabbable, accept}, scope);\n      walker.currentNode = isElementInScope(node, scope) ? node : sentinel;\n      let nextNode = walker.nextNode() as FocusableElement;\n      if (!nextNode && wrap) {\n        walker.currentNode = sentinel;\n        nextNode = walker.nextNode() as FocusableElement;\n      }\n      if (nextNode) {\n        focusElement(nextNode, true);\n      }\n      return nextNode;\n    },\n    focusPrevious(opts: FocusManagerOptions = {}) {\n      let scope = scopeRef.current;\n      let {from, tabbable, wrap, accept} = opts;\n      let node = from || document.activeElement;\n      let sentinel = scope[scope.length - 1].nextElementSibling;\n      let walker = getFocusableTreeWalker(getScopeRoot(scope), {tabbable, accept}, scope);\n      walker.currentNode = isElementInScope(node, scope) ? node : sentinel;\n      let previousNode = walker.previousNode() as FocusableElement;\n      if (!previousNode && wrap) {\n        walker.currentNode = sentinel;\n        previousNode = walker.previousNode() as FocusableElement;\n      }\n      if (previousNode) {\n        focusElement(previousNode, true);\n      }\n      return previousNode;\n    },\n    focusFirst(opts = {}) {\n      let scope = scopeRef.current;\n      let {tabbable, accept} = opts;\n      let walker = getFocusableTreeWalker(getScopeRoot(scope), {tabbable, accept}, scope);\n      walker.currentNode = scope[0].previousElementSibling;\n      let nextNode = walker.nextNode() as FocusableElement;\n      if (nextNode) {\n        focusElement(nextNode, true);\n      }\n      return nextNode;\n    },\n    focusLast(opts = {}) {\n      let scope = scopeRef.current;\n      let {tabbable, accept} = opts;\n      let walker = getFocusableTreeWalker(getScopeRoot(scope), {tabbable, accept}, scope);\n      walker.currentNode = scope[scope.length - 1].nextElementSibling;\n      let previousNode = walker.previousNode() as FocusableElement;\n      if (previousNode) {\n        focusElement(previousNode, true);\n      }\n      return previousNode;\n    }\n  };\n}\n\nconst focusableElements = [\n  'input:not([disabled]):not([type=hidden])',\n  'select:not([disabled])',\n  'textarea:not([disabled])',\n  'button:not([disabled])',\n  'a[href]',\n  'area[href]',\n  'summary',\n  'iframe',\n  'object',\n  'embed',\n  'audio[controls]',\n  'video[controls]',\n  '[contenteditable]'\n];\n\nconst FOCUSABLE_ELEMENT_SELECTOR = focusableElements.join(':not([hidden]),') + ',[tabindex]:not([disabled]):not([hidden])';\n\nfocusableElements.push('[tabindex]:not([tabindex=\"-1\"]):not([disabled])');\nconst TABBABLE_ELEMENT_SELECTOR = focusableElements.join(':not([hidden]):not([tabindex=\"-1\"]),');\n\nfunction getScopeRoot(scope: Element[]) {\n  return scope[0].parentElement;\n}\n\nfunction shouldContainFocus(scopeRef: ScopeRef) {\n  let scope = focusScopeTree.getTreeNode(activeScope);\n  while (scope && scope.scopeRef !== scopeRef) {\n    if (scope.contain) {\n      return false;\n    }\n\n    scope = scope.parent;\n  }\n\n  return true;\n}\n\nfunction useFocusContainment(scopeRef: RefObject<Element[]>, contain: boolean) {\n  let focusedNode = useRef<FocusableElement>();\n\n  let raf = useRef(null);\n  useLayoutEffect(() => {\n    let scope = scopeRef.current;\n    if (!contain) {\n      // if contain was changed, then we should cancel any ongoing waits to pull focus back into containment\n      if (raf.current) {\n        cancelAnimationFrame(raf.current);\n        raf.current = null;\n      }\n      return;\n    }\n\n    // Handle the Tab key to contain focus within the scope\n    let onKeyDown = (e) => {\n      if (e.key !== 'Tab' || e.altKey || e.ctrlKey || e.metaKey || !shouldContainFocus(scopeRef)) {\n        return;\n      }\n\n      let focusedElement = document.activeElement;\n      let scope = scopeRef.current;\n      if (!isElementInScope(focusedElement, scope)) {\n        return;\n      }\n\n      let walker = getFocusableTreeWalker(getScopeRoot(scope), {tabbable: true}, scope);\n      walker.currentNode = focusedElement;\n      let nextElement = (e.shiftKey ? walker.previousNode() : walker.nextNode()) as FocusableElement;\n      if (!nextElement) {\n        walker.currentNode = e.shiftKey ? scope[scope.length - 1].nextElementSibling : scope[0].previousElementSibling;\n        nextElement = (e.shiftKey ? walker.previousNode() : walker.nextNode())  as FocusableElement;\n      }\n\n      e.preventDefault();\n      if (nextElement) {\n        focusElement(nextElement, true);\n      }\n    };\n\n    let onFocus = (e) => {\n      // If focusing an element in a child scope of the currently active scope, the child becomes active.\n      // Moving out of the active scope to an ancestor is not allowed.\n      if ((!activeScope || isAncestorScope(activeScope, scopeRef)) && isElementInScope(e.target, scopeRef.current)) {\n        activeScope = scopeRef;\n        focusedNode.current = e.target;\n      } else if (shouldContainFocus(scopeRef) && !isElementInChildScope(e.target, scopeRef)) {\n        // If a focus event occurs outside the active scope (e.g. user tabs from browser location bar),\n        // restore focus to the previously focused node or the first tabbable element in the active scope.\n        if (focusedNode.current) {\n          focusedNode.current.focus();\n        } else if (activeScope) {\n          focusFirstInScope(activeScope.current);\n        }\n      } else if (shouldContainFocus(scopeRef)) {\n        focusedNode.current = e.target;\n      }\n    };\n\n    let onBlur = (e) => {\n      // Firefox doesn't shift focus back to the Dialog properly without this\n      if (raf.current) {\n        cancelAnimationFrame(raf.current);\n      }\n      raf.current = requestAnimationFrame(() => {\n        // Use document.activeElement instead of e.relatedTarget so we can tell if user clicked into iframe\n        if (shouldContainFocus(scopeRef) && !isElementInChildScope(document.activeElement, scopeRef)) {\n          activeScope = scopeRef;\n          if (document.body.contains(e.target)) {\n            focusedNode.current = e.target;\n            focusedNode.current.focus();\n          } else if (activeScope) {\n            focusFirstInScope(activeScope.current);\n          }\n        }\n      });\n    };\n\n    document.addEventListener('keydown', onKeyDown, false);\n    document.addEventListener('focusin', onFocus, false);\n    scope.forEach(element => element.addEventListener('focusin', onFocus, false));\n    scope.forEach(element => element.addEventListener('focusout', onBlur, false));\n    return () => {\n      document.removeEventListener('keydown', onKeyDown, false);\n      document.removeEventListener('focusin', onFocus, false);\n      scope.forEach(element => element.removeEventListener('focusin', onFocus, false));\n      scope.forEach(element => element.removeEventListener('focusout', onBlur, false));\n    };\n  }, [scopeRef, contain]);\n\n  // This is a useLayoutEffect so it is guaranteed to run before our async synthetic blur\n  // eslint-disable-next-line arrow-body-style\n  useLayoutEffect(() => {\n    return () => {\n      if (raf.current) {\n        cancelAnimationFrame(raf.current);\n      }\n    };\n  }, [raf]);\n}\n\nfunction isElementInAnyScope(element: Element) {\n  return isElementInChildScope(element);\n}\n\nfunction isElementInScope(element: Element, scope: Element[]) {\n  return scope.some(node => node.contains(element));\n}\n\nfunction isElementInChildScope(element: Element, scope: ScopeRef = null) {\n  // If the element is within a top layer element (e.g. toasts), always allow moving focus there.\n  if (element instanceof Element && element.closest('[data-react-aria-top-layer]')) {\n    return true;\n  }\n\n  // node.contains in isElementInScope covers child scopes that are also DOM children,\n  // but does not cover child scopes in portals.\n  for (let {scopeRef: s} of focusScopeTree.traverse(focusScopeTree.getTreeNode(scope))) {\n    if (isElementInScope(element, s.current)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/** @private */\nexport function isElementInChildOfActiveScope(element: Element) {\n  return isElementInChildScope(element, activeScope);\n}\n\nfunction isAncestorScope(ancestor: ScopeRef, scope: ScopeRef) {\n  let parent = focusScopeTree.getTreeNode(scope)?.parent;\n  while (parent) {\n    if (parent.scopeRef === ancestor) {\n      return true;\n    }\n    parent = parent.parent;\n  }\n  return false;\n}\n\nfunction focusElement(element: FocusableElement | null, scroll = false) {\n  if (element != null && !scroll) {\n    try {\n      focusSafely(element);\n    } catch (err) {\n      // ignore\n    }\n  } else if (element != null) {\n    try {\n      element.focus();\n    } catch (err) {\n      // ignore\n    }\n  }\n}\n\nfunction focusFirstInScope(scope: Element[], tabbable:boolean = true) {\n  let sentinel = scope[0].previousElementSibling;\n  let walker = getFocusableTreeWalker(getScopeRoot(scope), {tabbable}, scope);\n  walker.currentNode = sentinel;\n  let nextNode = walker.nextNode();\n\n  // If the scope does not contain a tabbable element, use the first focusable element.\n  if (tabbable && !nextNode) {\n    walker = getFocusableTreeWalker(getScopeRoot(scope), {tabbable: false}, scope);\n    walker.currentNode = sentinel;\n    nextNode = walker.nextNode();\n  }\n\n  focusElement(nextNode as FocusableElement);\n}\n\nfunction useAutoFocus(scopeRef: RefObject<Element[]>, autoFocus: boolean) {\n  const autoFocusRef = React.useRef(autoFocus);\n  useEffect(() => {\n    if (autoFocusRef.current) {\n      activeScope = scopeRef;\n      if (!isElementInScope(document.activeElement, activeScope.current)) {\n        focusFirstInScope(scopeRef.current);\n      }\n    }\n    autoFocusRef.current = false;\n  }, [scopeRef]);\n}\n\nfunction useActiveScopeTracker(scopeRef: RefObject<Element[]>, restore: boolean, contain: boolean) {\n  // tracks the active scope, in case restore and contain are both false.\n  // if either are true, this is tracked in useRestoreFocus or useFocusContainment.\n  useLayoutEffect(() => {\n    if (restore || contain) {\n      return;\n    }\n\n    let scope = scopeRef.current;\n\n    let onFocus = (e: FocusEvent) => {\n      let target = e.target as Element;\n      if (isElementInScope(target, scopeRef.current)) {\n        activeScope = scopeRef;\n      } else if (!isElementInAnyScope(target)) {\n        activeScope = null;\n      }\n    };\n\n    document.addEventListener('focusin', onFocus, false);\n    scope.forEach(element => element.addEventListener('focusin', onFocus, false));\n    return () => {\n      document.removeEventListener('focusin', onFocus, false);\n      scope.forEach(element => element.removeEventListener('focusin', onFocus, false));\n    };\n  }, [scopeRef, restore, contain]);\n}\n\nfunction shouldRestoreFocus(scopeRef: ScopeRef) {\n  let scope = focusScopeTree.getTreeNode(activeScope);\n  while (scope && scope.scopeRef !== scopeRef) {\n    if (scope.nodeToRestore) {\n      return false;\n    }\n\n    scope = scope.parent;\n  }\n\n  return scope?.scopeRef === scopeRef;\n}\n\nfunction useRestoreFocus(scopeRef: RefObject<Element[]>, restoreFocus: boolean, contain: boolean) {\n  // create a ref during render instead of useLayoutEffect so the active element is saved before a child with autoFocus=true mounts.\n  const nodeToRestoreRef = useRef(typeof document !== 'undefined' ? document.activeElement as FocusableElement : null);\n\n  // restoring scopes should all track if they are active regardless of contain, but contain already tracks it plus logic to contain the focus\n  // restoring-non-containing scopes should only care if they become active so they can perform the restore\n  useLayoutEffect(() => {\n    let scope = scopeRef.current;\n    if (!restoreFocus || contain) {\n      return;\n    }\n\n    let onFocus = () => {\n      // If focusing an element in a child scope of the currently active scope, the child becomes active.\n      // Moving out of the active scope to an ancestor is not allowed.\n      if ((!activeScope || isAncestorScope(activeScope, scopeRef)) &&\n      isElementInScope(document.activeElement, scopeRef.current)\n      ) {\n        activeScope = scopeRef;\n      }\n    };\n\n    document.addEventListener('focusin', onFocus, false);\n    scope.forEach(element => element.addEventListener('focusin', onFocus, false));\n    return () => {\n      document.removeEventListener('focusin', onFocus, false);\n      scope.forEach(element => element.removeEventListener('focusin', onFocus, false));\n    };\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [scopeRef, contain]);\n\n  useLayoutEffect(() => {\n    if (!restoreFocus) {\n      return;\n    }\n\n    // Handle the Tab key so that tabbing out of the scope goes to the next element\n    // after the node that had focus when the scope mounted. This is important when\n    // using portals for overlays, so that focus goes to the expected element when\n    // tabbing out of the overlay.\n    let onKeyDown = (e: KeyboardEvent) => {\n      if (e.key !== 'Tab' || e.altKey || e.ctrlKey || e.metaKey || !shouldContainFocus(scopeRef)) {\n        return;\n      }\n\n      let focusedElement = document.activeElement as FocusableElement;\n      if (!isElementInScope(focusedElement, scopeRef.current)) {\n        return;\n      }\n      let nodeToRestore = focusScopeTree.getTreeNode(scopeRef).nodeToRestore;\n\n      // Create a DOM tree walker that matches all tabbable elements\n      let walker = getFocusableTreeWalker(document.body, {tabbable: true});\n\n      // Find the next tabbable element after the currently focused element\n      walker.currentNode = focusedElement;\n      let nextElement = (e.shiftKey ? walker.previousNode() : walker.nextNode()) as FocusableElement;\n\n      if (!document.body.contains(nodeToRestore) || nodeToRestore === document.body) {\n        nodeToRestore = null;\n        focusScopeTree.getTreeNode(scopeRef).nodeToRestore = null;\n      }\n\n      // If there is no next element, or it is outside the current scope, move focus to the\n      // next element after the node to restore to instead.\n      if ((!nextElement || !isElementInScope(nextElement, scopeRef.current)) && nodeToRestore) {\n        walker.currentNode = nodeToRestore;\n\n        // Skip over elements within the scope, in case the scope immediately follows the node to restore.\n        do {\n          nextElement = (e.shiftKey ? walker.previousNode() : walker.nextNode()) as FocusableElement;\n        } while (isElementInScope(nextElement, scopeRef.current));\n\n        e.preventDefault();\n        e.stopPropagation();\n        if (nextElement) {\n          focusElement(nextElement, true);\n        } else {\n           // If there is no next element and the nodeToRestore isn't within a FocusScope (i.e. we are leaving the top level focus scope)\n           // then move focus to the body.\n           // Otherwise restore focus to the nodeToRestore (e.g menu within a popover -> tabbing to close the menu should move focus to menu trigger)\n          if (!isElementInAnyScope(nodeToRestore)) {\n            focusedElement.blur();\n          } else {\n            focusElement(nodeToRestore, true);\n          }\n        }\n      }\n    };\n\n    if (!contain) {\n      document.addEventListener('keydown', onKeyDown, true);\n    }\n\n    return () => {\n      if (!contain) {\n        document.removeEventListener('keydown', onKeyDown, true);\n      }\n    };\n  }, [scopeRef, restoreFocus, contain]);\n\n  // useLayoutEffect instead of useEffect so the active element is saved synchronously instead of asynchronously.\n  useLayoutEffect(() => {\n    if (!restoreFocus) {\n      return;\n    }\n\n    focusScopeTree.getTreeNode(scopeRef).nodeToRestore = nodeToRestoreRef.current;\n\n    return () => {\n      let nodeToRestore = focusScopeTree.getTreeNode(scopeRef).nodeToRestore;\n\n      // if we already lost focus to the body and this was the active scope, then we should attempt to restore\n      if (\n        restoreFocus\n        && nodeToRestore\n        && (\n          // eslint-disable-next-line react-hooks/exhaustive-deps\n          isElementInScope(document.activeElement, scopeRef.current)\n          || (document.activeElement === document.body && shouldRestoreFocus(scopeRef))\n        )\n      ) {\n        // freeze the focusScopeTree so it persists after the raf, otherwise during unmount nodes are removed from it\n        let clonedTree = focusScopeTree.clone();\n        requestAnimationFrame(() => {\n          // Only restore focus if we've lost focus to the body, the alternative is that focus has been purposefully moved elsewhere\n          if (document.activeElement === document.body) {\n            // look up the tree starting with our scope to find a nodeToRestore still in the DOM\n            let treeNode = clonedTree.getTreeNode(scopeRef);\n            while (treeNode) {\n              if (treeNode.nodeToRestore && document.body.contains(treeNode.nodeToRestore)) {\n                focusElement(treeNode.nodeToRestore);\n                return;\n              }\n              treeNode = treeNode.parent;\n            }\n\n            // If no nodeToRestore was found, focus the first element in the nearest\n            // ancestor scope that is still in the tree.\n            treeNode = clonedTree.getTreeNode(scopeRef);\n            while (treeNode) {\n              if (treeNode.scopeRef && focusScopeTree.getTreeNode(treeNode.scopeRef)) {\n                focusFirstInScope(treeNode.scopeRef.current, true);\n                return;\n              }\n              treeNode = treeNode.parent;\n            }\n          }\n        });\n      }\n    };\n  }, [scopeRef, restoreFocus]);\n}\n\n/**\n * Create a [TreeWalker]{@link https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker}\n * that matches all focusable/tabbable elements.\n */\nexport function getFocusableTreeWalker(root: Element, opts?: FocusManagerOptions, scope?: Element[]) {\n  let selector = opts?.tabbable ? TABBABLE_ELEMENT_SELECTOR : FOCUSABLE_ELEMENT_SELECTOR;\n  let walker = document.createTreeWalker(\n    root,\n    NodeFilter.SHOW_ELEMENT,\n    {\n      acceptNode(node) {\n        // Skip nodes inside the starting node.\n        if (opts?.from?.contains(node)) {\n          return NodeFilter.FILTER_REJECT;\n        }\n\n        if ((node as Element).matches(selector)\n          && isElementVisible(node as Element)\n          && (!scope || isElementInScope(node as Element, scope))\n          && (!opts?.accept || opts.accept(node as Element))\n        ) {\n          return NodeFilter.FILTER_ACCEPT;\n        }\n\n        return NodeFilter.FILTER_SKIP;\n      }\n    }\n  );\n\n  if (opts?.from) {\n    walker.currentNode = opts.from;\n  }\n\n  return walker;\n}\n\n/**\n * Creates a FocusManager object that can be used to move focus within an element.\n */\nexport function createFocusManager(ref: RefObject<Element>, defaultOptions: FocusManagerOptions = {}): FocusManager {\n  return {\n    focusNext(opts: FocusManagerOptions = {}) {\n      let root = ref.current;\n      if (!root) {\n        return;\n      }\n      let {from, tabbable = defaultOptions.tabbable, wrap = defaultOptions.wrap, accept = defaultOptions.accept} = opts;\n      let node = from || document.activeElement;\n      let walker = getFocusableTreeWalker(root, {tabbable, accept});\n      if (root.contains(node)) {\n        walker.currentNode = node;\n      }\n      let nextNode = walker.nextNode() as FocusableElement;\n      if (!nextNode && wrap) {\n        walker.currentNode = root;\n        nextNode = walker.nextNode() as FocusableElement;\n      }\n      if (nextNode) {\n        focusElement(nextNode, true);\n      }\n      return nextNode;\n    },\n    focusPrevious(opts: FocusManagerOptions = defaultOptions) {\n      let root = ref.current;\n      if (!root) {\n        return;\n      }\n      let {from, tabbable = defaultOptions.tabbable, wrap = defaultOptions.wrap, accept = defaultOptions.accept} = opts;\n      let node = from || document.activeElement;\n      let walker = getFocusableTreeWalker(root, {tabbable, accept});\n      if (root.contains(node)) {\n        walker.currentNode = node;\n      } else {\n        let next = last(walker);\n        if (next) {\n          focusElement(next, true);\n        }\n        return next;\n      }\n      let previousNode = walker.previousNode() as FocusableElement;\n      if (!previousNode && wrap) {\n        walker.currentNode = root;\n        previousNode = last(walker);\n      }\n      if (previousNode) {\n        focusElement(previousNode, true);\n      }\n      return previousNode;\n    },\n    focusFirst(opts = defaultOptions) {\n      let root = ref.current;\n      if (!root) {\n        return;\n      }\n      let {tabbable = defaultOptions.tabbable, accept = defaultOptions.accept} = opts;\n      let walker = getFocusableTreeWalker(root, {tabbable, accept});\n      let nextNode = walker.nextNode() as FocusableElement;\n      if (nextNode) {\n        focusElement(nextNode, true);\n      }\n      return nextNode;\n    },\n    focusLast(opts = defaultOptions) {\n      let root = ref.current;\n      if (!root) {\n        return;\n      }\n      let {tabbable = defaultOptions.tabbable, accept = defaultOptions.accept} = opts;\n      let walker = getFocusableTreeWalker(root, {tabbable, accept});\n      let next = last(walker);\n      if (next) {\n        focusElement(next, true);\n      }\n      return next;\n    }\n  };\n}\n\nfunction last(walker: TreeWalker) {\n  let next: FocusableElement;\n  let last: FocusableElement;\n  do {\n    last = walker.lastChild() as FocusableElement;\n    if (last) {\n      next = last;\n    }\n  } while (last);\n  return next;\n}\n\n\nclass Tree {\n  root: TreeNode;\n  private fastMap = new Map<ScopeRef, TreeNode>();\n\n  constructor() {\n    this.root = new TreeNode({scopeRef: null});\n    this.fastMap.set(null, this.root);\n  }\n\n  get size() {\n    return this.fastMap.size;\n  }\n\n  getTreeNode(data: ScopeRef) {\n    return this.fastMap.get(data);\n  }\n\n  addTreeNode(scopeRef: ScopeRef, parent: ScopeRef, nodeToRestore?: FocusableElement) {\n    let parentNode = this.fastMap.get(parent ?? null);\n    let node = new TreeNode({scopeRef});\n    parentNode.addChild(node);\n    node.parent = parentNode;\n    this.fastMap.set(scopeRef, node);\n    if (nodeToRestore) {\n      node.nodeToRestore = nodeToRestore;\n    }\n  }\n\n  addNode(node: TreeNode) {\n    this.fastMap.set(node.scopeRef, node);\n  }\n\n  removeTreeNode(scopeRef: ScopeRef) {\n    // never remove the root\n    if (scopeRef === null) {\n      return;\n    }\n    let node = this.fastMap.get(scopeRef);\n    let parentNode = node.parent;\n    // when we remove a scope, check if any sibling scopes are trying to restore focus to something inside the scope we're removing\n    // if we are, then replace the siblings restore with the restore from the scope we're removing\n    for (let current of this.traverse()) {\n      if (\n        current !== node &&\n        node.nodeToRestore &&\n        current.nodeToRestore &&\n        node.scopeRef.current &&\n        isElementInScope(current.nodeToRestore, node.scopeRef.current)\n      ) {\n        current.nodeToRestore = node.nodeToRestore;\n      }\n    }\n    let children = node.children;\n    parentNode.removeChild(node);\n    if (children.size > 0) {\n      children.forEach(child => parentNode.addChild(child));\n    }\n\n    this.fastMap.delete(node.scopeRef);\n  }\n\n  // Pre Order Depth First\n  *traverse(node: TreeNode = this.root): Generator<TreeNode> {\n    if (node.scopeRef != null) {\n      yield node;\n    }\n    if (node.children.size > 0) {\n      for (let child of node.children) {\n        yield* this.traverse(child);\n      }\n    }\n  }\n\n  clone(): Tree {\n    let newTree = new Tree();\n    for (let node of this.traverse()) {\n      newTree.addTreeNode(node.scopeRef, node.parent.scopeRef, node.nodeToRestore);\n    }\n    return newTree;\n  }\n}\n\nclass TreeNode {\n  public scopeRef: ScopeRef;\n  public nodeToRestore: FocusableElement;\n  public parent: TreeNode;\n  public children: Set<TreeNode> = new Set();\n  public contain = false;\n\n  constructor(props: {scopeRef: ScopeRef}) {\n    this.scopeRef = props.scopeRef;\n  }\n  addChild(node: TreeNode) {\n    this.children.add(node);\n    node.parent = this;\n  }\n  removeChild(node: TreeNode) {\n    this.children.delete(node);\n    node.parent = undefined;\n  }\n}\n\nexport let focusScopeTree = new Tree();\n","/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the 'License');\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {FocusableElement} from '@react-types/shared';\nimport {focusWithoutScrolling, runAfterTransition} from '@react-aria/utils';\nimport {getInteractionModality} from '@react-aria/interactions';\n\n/**\n * A utility function that focuses an element while avoiding undesired side effects such\n * as page scrolling and screen reader issues with CSS transitions.\n */\nexport function focusSafely(element: FocusableElement) {\n  // If the user is interacting with a virtual cursor, e.g. screen reader, then\n  // wait until after any animated transitions that are currently occurring on\n  // the page before shifting focus. This avoids issues with VoiceOver on iOS\n  // causing the page to scroll when moving focus if the element is transitioning\n  // from off the screen.\n  if (getInteractionModality() === 'virtual') {\n    let lastFocusedElement = document.activeElement;\n    runAfterTransition(() => {\n      // If focus did not move and the element is still in the document, focus it.\n      if (document.activeElement === lastFocusedElement && document.contains(element)) {\n        focusWithoutScrolling(element);\n      }\n    });\n  } else {\n    focusWithoutScrolling(element);\n  }\n}\n","/*\n * Copyright 2021 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nfunction isStyleVisible(element: Element) {\n  if (!(element instanceof HTMLElement) && !(element instanceof SVGElement)) {\n    return false;\n  }\n\n  let {display, visibility} = element.style;\n\n  let isVisible = (\n    display !== 'none' &&\n    visibility !== 'hidden' &&\n    visibility !== 'collapse'\n  );\n\n  if (isVisible) {\n    const {getComputedStyle} = element.ownerDocument.defaultView;\n    let {display: computedDisplay, visibility: computedVisibility} = getComputedStyle(element);\n\n    isVisible = (\n      computedDisplay !== 'none' &&\n      computedVisibility !== 'hidden' &&\n      computedVisibility !== 'collapse'\n    );\n  }\n\n  return isVisible;\n}\n\nfunction isAttributeVisible(element: Element, childElement?: Element) {\n  return (\n    !element.hasAttribute('hidden') &&\n    (element.nodeName === 'DETAILS' &&\n      childElement &&\n      childElement.nodeName !== 'SUMMARY'\n      ? element.hasAttribute('open')\n      : true)\n  );\n}\n\n/**\n * Adapted from https://github.com/testing-library/jest-dom and \n * https://github.com/vuejs/vue-test-utils-next/.\n * Licensed under the MIT License.\n * @param element - Element to evaluate for display or visibility.\n */  \nexport function isElementVisible(element: Element, childElement?: Element) {\n  return (\n    element.nodeName !== '#comment' &&\n    isStyleVisible(element) &&\n    isAttributeVisible(element, childElement) &&\n    (!element.parentElement || isElementVisible(element.parentElement, element))\n  );\n}\n","/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport clsx from 'clsx';\nimport {mergeProps} from '@react-aria/utils';\nimport React, {ReactElement} from 'react';\nimport {useFocusRing} from './useFocusRing';\n\nexport interface FocusRingProps {\n  /** Child element to apply CSS classes to. */\n  children: ReactElement,\n  /** CSS class to apply when the element is focused. */\n  focusClass?: string,\n  /** CSS class to apply when the element has keyboard focus. */\n  focusRingClass?: string,\n  /**\n   * Whether to show the focus ring when something\n   * inside the container element has focus (true), or\n   * only if the container itself has focus (false).\n   * @default false\n   */\n  within?: boolean,\n  /** Whether the element is a text input. */\n  isTextInput?: boolean,\n  /** Whether the element will be auto focused. */\n  autoFocus?: boolean\n}\n\n/**\n * A utility component that applies a CSS class when an element has keyboard focus.\n * Focus rings are visible only when the user is interacting with a keyboard,\n * not with a mouse, touch, or other input methods.\n */\nexport function FocusRing(props: FocusRingProps) {\n  let {children, focusClass, focusRingClass} = props;\n  let {isFocused, isFocusVisible, focusProps} = useFocusRing(props);\n  let child = React.Children.only(children);\n\n  return React.cloneElement(child, mergeProps(child.props, {\n    ...focusProps,\n    className: clsx({\n      [focusClass || '']: isFocused,\n      [focusRingClass || '']: isFocusVisible\n    })\n  }));\n}\n","import {DOMAttributes} from '@react-types/shared';\nimport {isFocusVisible, useFocus, useFocusVisibleListener, useFocusWithin} from '@react-aria/interactions';\nimport {useCallback, useRef, useState} from 'react';\n\nexport interface AriaFocusRingProps {\n  /**\n   * Whether to show the focus ring when something\n   * inside the container element has focus (true), or\n   * only if the container itself has focus (false).\n   * @default 'false'\n   */\n  within?: boolean,\n\n  /** Whether the element is a text input. */\n  isTextInput?: boolean,\n\n  /** Whether the element will be auto focused. */\n  autoFocus?: boolean\n}\n\nexport interface FocusRingAria {\n  /** Whether the element is currently focused. */\n  isFocused: boolean,\n\n  /** Whether keyboard focus should be visible. */\n  isFocusVisible: boolean,\n\n  /** Props to apply to the container element with the focus ring. */\n  focusProps: DOMAttributes\n}\n\n/**\n * Determines whether a focus ring should be shown to indicate keyboard focus.\n * Focus rings are visible only when the user is interacting with a keyboard,\n * not with a mouse, touch, or other input methods.\n */\nexport function useFocusRing(props: AriaFocusRingProps = {}): FocusRingAria {\n  let {\n    autoFocus = false,\n    isTextInput,\n    within\n  } = props;\n  let state = useRef({\n    isFocused: false,\n    isFocusVisible: autoFocus || isFocusVisible()\n  });\n  let [isFocused, setFocused] = useState(false);\n  let [isFocusVisibleState, setFocusVisible] = useState(() => state.current.isFocused && state.current.isFocusVisible);\n\n  let updateState = useCallback(() => setFocusVisible(state.current.isFocused && state.current.isFocusVisible), []);\n\n  let onFocusChange = useCallback(isFocused => {\n    state.current.isFocused = isFocused;\n    setFocused(isFocused);\n    updateState();\n  }, [updateState]);\n\n  useFocusVisibleListener((isFocusVisible) => {\n    state.current.isFocusVisible = isFocusVisible;\n    updateState();\n  }, [], {isTextInput});\n\n  let {focusProps} = useFocus({\n    isDisabled: within,\n    onFocusChange\n  });\n\n  let {focusWithinProps} = useFocusWithin({\n    isDisabled: !within,\n    onFocusWithinChange: onFocusChange\n  });\n\n  return {\n    isFocused,\n    isFocusVisible: isFocusVisibleState,\n    focusProps: within ? focusWithinProps : focusProps\n  };\n}\n","/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {DOMAttributes, FocusableDOMProps, FocusableElement, FocusableProps} from '@react-types/shared';\nimport {focusSafely} from './';\nimport {mergeProps, useSyncRef} from '@react-aria/utils';\nimport React, {MutableRefObject, ReactNode, RefObject, useContext, useEffect, useRef} from 'react';\nimport {useFocus, useKeyboard} from '@react-aria/interactions';\n\nexport interface FocusableOptions extends FocusableProps, FocusableDOMProps {\n  /** Whether focus should be disabled. */\n  isDisabled?: boolean\n}\n\nexport interface FocusableProviderProps extends DOMAttributes {\n  /** The child element to provide DOM props to. */\n  children?: ReactNode\n}\n\ninterface FocusableContextValue extends FocusableProviderProps {\n  ref?: MutableRefObject<FocusableElement>\n}\n\nlet FocusableContext = React.createContext<FocusableContextValue>(null);\n\nfunction useFocusableContext(ref: RefObject<FocusableElement>): FocusableContextValue {\n  let context = useContext(FocusableContext) || {};\n  useSyncRef(context, ref);\n\n  // eslint-disable-next-line\n  let {ref: _, ...otherProps} = context;\n  return otherProps;\n}\n\n/**\n * Provides DOM props to the nearest focusable child.\n */\nfunction FocusableProvider(props: FocusableProviderProps, ref: RefObject<FocusableElement>) {\n  let {children, ...otherProps} = props;\n  let context = {\n    ...otherProps,\n    ref\n  };\n\n  return (\n    <FocusableContext.Provider value={context}>\n      {children}\n    </FocusableContext.Provider>\n  );\n}\n\nlet _FocusableProvider = React.forwardRef(FocusableProvider);\nexport {_FocusableProvider as FocusableProvider};\n\nexport interface FocusableAria {\n  /** Props for the focusable element. */\n  focusableProps: DOMAttributes\n}\n\n/**\n * Used to make an element focusable and capable of auto focus.\n */\nexport function useFocusable(props: FocusableOptions, domRef: RefObject<FocusableElement>): FocusableAria {\n  let {focusProps} = useFocus(props);\n  let {keyboardProps} = useKeyboard(props);\n  let interactions = mergeProps(focusProps, keyboardProps);\n  let domProps = useFocusableContext(domRef);\n  let interactionProps = props.isDisabled ? {} : domProps;\n  let autoFocusRef = useRef(props.autoFocus);\n\n  useEffect(() => {\n    if (autoFocusRef.current && domRef.current) {\n      focusSafely(domRef.current);\n    }\n    autoFocusRef.current = false;\n  }, [domRef]);\n\n  return {\n    focusableProps: mergeProps(\n      {\n        ...interactions,\n        tabIndex: props.excludeFromTabOrder && !props.isDisabled ? -1 : undefined\n      },\n      interactionProps\n    )\n  };\n}\n","/*\n * Copyright 2022 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {getFocusableTreeWalker} from './FocusScope';\nimport {RefObject, useState} from 'react';\nimport {useLayoutEffect} from '@react-aria/utils';\n\ninterface AriaHasTabbableChildOptions {\n  isDisabled?: boolean\n}\n\n// This was created for a special empty case of a component that can have child or\n// be empty, like Collection/Virtualizer/Table/ListView/etc. When these components\n// are empty they can have a message with a tabbable element, which is like them\n// being not empty, when it comes to focus and tab order.\n\n/**\n * Returns whether an element has a tabbable child, and updates as children change.\n * @private\n */\nexport function useHasTabbableChild(ref: RefObject<Element>, options?: AriaHasTabbableChildOptions): boolean {\n  let isDisabled = options?.isDisabled;\n  let [hasTabbableChild, setHasTabbableChild] = useState(false);\n\n  useLayoutEffect(() => {\n    if (ref?.current && !isDisabled) {\n      let update = () => {\n        if (ref.current) {\n          let walker = getFocusableTreeWalker(ref.current, {tabbable: true});\n          setHasTabbableChild(!!walker.nextNode());\n        }\n      };\n\n      update();\n\n      // Update when new elements are inserted, or the tabIndex/disabled attribute updates.\n      let observer = new MutationObserver(update);\n      observer.observe(ref.current, {\n        subtree: true,\n        childList: true,\n        attributes: true,\n        attributeFilter: ['tabIndex', 'disabled']\n      });\n\n      return () => {\n        // Disconnect mutation observer when a React update occurs on the top-level component\n        // so we update synchronously after re-rendering. Otherwise React will emit act warnings\n        // in tests since mutation observers fire asynchronously. The mutation observer is necessary\n        // so we also update if a child component re-renders and adds/removes something tabbable.\n        observer.disconnect();\n      };\n    }\n  });\n\n  return isDisabled ? false : hasTabbableChild;\n}\n"],"names":[],"version":3,"file":"main.js.map"}