{"version":3,"file":"focus-trap-DQh7w5fV.js","sources":["../../../node_modules/focus-trap/dist/focus-trap.esm.js"],"sourcesContent":["/*!\n* focus-trap 7.6.0\n* @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE\n*/\nimport { isFocusable, tabbable, focusable, isTabbable, getTabIndex } from 'tabbable';\n\nfunction _defineProperty(e, r, t) {\n  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {\n    value: t,\n    enumerable: !0,\n    configurable: !0,\n    writable: !0\n  }) : e[r] = t, e;\n}\nfunction ownKeys(e, r) {\n  var t = Object.keys(e);\n  if (Object.getOwnPropertySymbols) {\n    var o = Object.getOwnPropertySymbols(e);\n    r && (o = o.filter(function (r) {\n      return Object.getOwnPropertyDescriptor(e, r).enumerable;\n    })), t.push.apply(t, o);\n  }\n  return t;\n}\nfunction _objectSpread2(e) {\n  for (var r = 1; r < arguments.length; r++) {\n    var t = null != arguments[r] ? arguments[r] : {};\n    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {\n      _defineProperty(e, r, t[r]);\n    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {\n      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));\n    });\n  }\n  return e;\n}\nfunction _toPrimitive(t, r) {\n  if (\"object\" != typeof t || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (void 0 !== e) {\n    var i = e.call(t, r || \"default\");\n    if (\"object\" != typeof i) return i;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (\"string\" === r ? String : Number)(t);\n}\nfunction _toPropertyKey(t) {\n  var i = _toPrimitive(t, \"string\");\n  return \"symbol\" == typeof i ? i : i + \"\";\n}\n\nvar activeFocusTraps = {\n  activateTrap: function activateTrap(trapStack, trap) {\n    if (trapStack.length > 0) {\n      var activeTrap = trapStack[trapStack.length - 1];\n      if (activeTrap !== trap) {\n        activeTrap.pause();\n      }\n    }\n    var trapIndex = trapStack.indexOf(trap);\n    if (trapIndex === -1) {\n      trapStack.push(trap);\n    } else {\n      // move this existing trap to the front of the queue\n      trapStack.splice(trapIndex, 1);\n      trapStack.push(trap);\n    }\n  },\n  deactivateTrap: function deactivateTrap(trapStack, trap) {\n    var trapIndex = trapStack.indexOf(trap);\n    if (trapIndex !== -1) {\n      trapStack.splice(trapIndex, 1);\n    }\n    if (trapStack.length > 0) {\n      trapStack[trapStack.length - 1].unpause();\n    }\n  }\n};\nvar isSelectableInput = function isSelectableInput(node) {\n  return node.tagName && node.tagName.toLowerCase() === 'input' && typeof node.select === 'function';\n};\nvar isEscapeEvent = function isEscapeEvent(e) {\n  return (e === null || e === void 0 ? void 0 : e.key) === 'Escape' || (e === null || e === void 0 ? void 0 : e.key) === 'Esc' || (e === null || e === void 0 ? void 0 : e.keyCode) === 27;\n};\nvar isTabEvent = function isTabEvent(e) {\n  return (e === null || e === void 0 ? void 0 : e.key) === 'Tab' || (e === null || e === void 0 ? void 0 : e.keyCode) === 9;\n};\n\n// checks for TAB by default\nvar isKeyForward = function isKeyForward(e) {\n  return isTabEvent(e) && !e.shiftKey;\n};\n\n// checks for SHIFT+TAB by default\nvar isKeyBackward = function isKeyBackward(e) {\n  return isTabEvent(e) && e.shiftKey;\n};\nvar delay = function delay(fn) {\n  return setTimeout(fn, 0);\n};\n\n// Array.find/findIndex() are not supported on IE; this replicates enough\n//  of Array.findIndex() for our needs\nvar findIndex = function findIndex(arr, fn) {\n  var idx = -1;\n  arr.every(function (value, i) {\n    if (fn(value)) {\n      idx = i;\n      return false; // break\n    }\n    return true; // next\n  });\n  return idx;\n};\n\n/**\n * Get an option's value when it could be a plain value, or a handler that provides\n *  the value.\n * @param {*} value Option's value to check.\n * @param {...*} [params] Any parameters to pass to the handler, if `value` is a function.\n * @returns {*} The `value`, or the handler's returned value.\n */\nvar valueOrHandler = function valueOrHandler(value) {\n  for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    params[_key - 1] = arguments[_key];\n  }\n  return typeof value === 'function' ? value.apply(void 0, params) : value;\n};\nvar getActualTarget = function getActualTarget(event) {\n  // NOTE: If the trap is _inside_ a shadow DOM, event.target will always be the\n  //  shadow host. However, event.target.composedPath() will be an array of\n  //  nodes \"clicked\" from inner-most (the actual element inside the shadow) to\n  //  outer-most (the host HTML document). If we have access to composedPath(),\n  //  then use its first element; otherwise, fall back to event.target (and\n  //  this only works for an _open_ shadow DOM; otherwise,\n  //  composedPath()[0] === event.target always).\n  return event.target.shadowRoot && typeof event.composedPath === 'function' ? event.composedPath()[0] : event.target;\n};\n\n// NOTE: this must be _outside_ `createFocusTrap()` to make sure all traps in this\n//  current instance use the same stack if `userOptions.trapStack` isn't specified\nvar internalTrapStack = [];\nvar createFocusTrap = function createFocusTrap(elements, userOptions) {\n  // SSR: a live trap shouldn't be created in this type of environment so this\n  //  should be safe code to execute if the `document` option isn't specified\n  var doc = (userOptions === null || userOptions === void 0 ? void 0 : userOptions.document) || document;\n  var trapStack = (userOptions === null || userOptions === void 0 ? void 0 : userOptions.trapStack) || internalTrapStack;\n  var config = _objectSpread2({\n    returnFocusOnDeactivate: true,\n    escapeDeactivates: true,\n    delayInitialFocus: true,\n    isKeyForward: isKeyForward,\n    isKeyBackward: isKeyBackward\n  }, userOptions);\n  var state = {\n    // containers given to createFocusTrap()\n    // @type {Array<HTMLElement>}\n    containers: [],\n    // list of objects identifying tabbable nodes in `containers` in the trap\n    // NOTE: it's possible that a group has no tabbable nodes if nodes get removed while the trap\n    //  is active, but the trap should never get to a state where there isn't at least one group\n    //  with at least one tabbable node in it (that would lead to an error condition that would\n    //  result in an error being thrown)\n    // @type {Array<{\n    //   container: HTMLElement,\n    //   tabbableNodes: Array<HTMLElement>, // empty if none\n    //   focusableNodes: Array<HTMLElement>, // empty if none\n    //   posTabIndexesFound: boolean,\n    //   firstTabbableNode: HTMLElement|undefined,\n    //   lastTabbableNode: HTMLElement|undefined,\n    //   firstDomTabbableNode: HTMLElement|undefined,\n    //   lastDomTabbableNode: HTMLElement|undefined,\n    //   nextTabbableNode: (node: HTMLElement, forward: boolean) => HTMLElement|undefined\n    // }>}\n    containerGroups: [],\n    // same order/length as `containers` list\n\n    // references to objects in `containerGroups`, but only those that actually have\n    //  tabbable nodes in them\n    // NOTE: same order as `containers` and `containerGroups`, but __not necessarily__\n    //  the same length\n    tabbableGroups: [],\n    nodeFocusedBeforeActivation: null,\n    mostRecentlyFocusedNode: null,\n    active: false,\n    paused: false,\n    // timer ID for when delayInitialFocus is true and initial focus in this trap\n    //  has been delayed during activation\n    delayInitialFocusTimer: undefined,\n    // the most recent KeyboardEvent for the configured nav key (typically [SHIFT+]TAB), if any\n    recentNavEvent: undefined\n  };\n  var trap; // eslint-disable-line prefer-const -- some private functions reference it, and its methods reference private functions, so we must declare here and define later\n\n  /**\n   * Gets a configuration option value.\n   * @param {Object|undefined} configOverrideOptions If true, and option is defined in this set,\n   *  value will be taken from this object. Otherwise, value will be taken from base configuration.\n   * @param {string} optionName Name of the option whose value is sought.\n   * @param {string|undefined} [configOptionName] Name of option to use __instead of__ `optionName`\n   *  IIF `configOverrideOptions` is not defined. Otherwise, `optionName` is used.\n   */\n  var getOption = function getOption(configOverrideOptions, optionName, configOptionName) {\n    return configOverrideOptions && configOverrideOptions[optionName] !== undefined ? configOverrideOptions[optionName] : config[configOptionName || optionName];\n  };\n\n  /**\n   * Finds the index of the container that contains the element.\n   * @param {HTMLElement} element\n   * @param {Event} [event] If available, and `element` isn't directly found in any container,\n   *  the event's composed path is used to see if includes any known trap containers in the\n   *  case where the element is inside a Shadow DOM.\n   * @returns {number} Index of the container in either `state.containers` or\n   *  `state.containerGroups` (the order/length of these lists are the same); -1\n   *  if the element isn't found.\n   */\n  var findContainerIndex = function findContainerIndex(element, event) {\n    var composedPath = typeof (event === null || event === void 0 ? void 0 : event.composedPath) === 'function' ? event.composedPath() : undefined;\n    // NOTE: search `containerGroups` because it's possible a group contains no tabbable\n    //  nodes, but still contains focusable nodes (e.g. if they all have `tabindex=-1`)\n    //  and we still need to find the element in there\n    return state.containerGroups.findIndex(function (_ref) {\n      var container = _ref.container,\n        tabbableNodes = _ref.tabbableNodes;\n      return container.contains(element) || ( // fall back to explicit tabbable search which will take into consideration any\n      //  web components if the `tabbableOptions.getShadowRoot` option was used for\n      //  the trap, enabling shadow DOM support in tabbable (`Node.contains()` doesn't\n      //  look inside web components even if open)\n      composedPath === null || composedPath === void 0 ? void 0 : composedPath.includes(container)) || tabbableNodes.find(function (node) {\n        return node === element;\n      });\n    });\n  };\n\n  /**\n   * Gets the node for the given option, which is expected to be an option that\n   *  can be either a DOM node, a string that is a selector to get a node, `false`\n   *  (if a node is explicitly NOT given), or a function that returns any of these\n   *  values.\n   * @param {string} optionName\n   * @returns {undefined | false | HTMLElement | SVGElement} Returns\n   *  `undefined` if the option is not specified; `false` if the option\n   *  resolved to `false` (node explicitly not given); otherwise, the resolved\n   *  DOM node.\n   * @throws {Error} If the option is set, not `false`, and is not, or does not\n   *  resolve to a node.\n   */\n  var getNodeForOption = function getNodeForOption(optionName) {\n    var optionValue = config[optionName];\n    if (typeof optionValue === 'function') {\n      for (var _len2 = arguments.length, params = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n        params[_key2 - 1] = arguments[_key2];\n      }\n      optionValue = optionValue.apply(void 0, params);\n    }\n    if (optionValue === true) {\n      optionValue = undefined; // use default value\n    }\n    if (!optionValue) {\n      if (optionValue === undefined || optionValue === false) {\n        return optionValue;\n      }\n      // else, empty string (invalid), null (invalid), 0 (invalid)\n\n      throw new Error(\"`\".concat(optionName, \"` was specified but was not a node, or did not return a node\"));\n    }\n    var node = optionValue; // could be HTMLElement, SVGElement, or non-empty string at this point\n\n    if (typeof optionValue === 'string') {\n      node = doc.querySelector(optionValue); // resolve to node, or null if fails\n      if (!node) {\n        throw new Error(\"`\".concat(optionName, \"` as selector refers to no known node\"));\n      }\n    }\n    return node;\n  };\n  var getInitialFocusNode = function getInitialFocusNode() {\n    var node = getNodeForOption('initialFocus');\n\n    // false explicitly indicates we want no initialFocus at all\n    if (node === false) {\n      return false;\n    }\n    if (node === undefined || !isFocusable(node, config.tabbableOptions)) {\n      // option not specified nor focusable: use fallback options\n      if (findContainerIndex(doc.activeElement) >= 0) {\n        node = doc.activeElement;\n      } else {\n        var firstTabbableGroup = state.tabbableGroups[0];\n        var firstTabbableNode = firstTabbableGroup && firstTabbableGroup.firstTabbableNode;\n\n        // NOTE: `fallbackFocus` option function cannot return `false` (not supported)\n        node = firstTabbableNode || getNodeForOption('fallbackFocus');\n      }\n    }\n    if (!node) {\n      throw new Error('Your focus-trap needs to have at least one focusable element');\n    }\n    return node;\n  };\n  var updateTabbableNodes = function updateTabbableNodes() {\n    state.containerGroups = state.containers.map(function (container) {\n      var tabbableNodes = tabbable(container, config.tabbableOptions);\n\n      // NOTE: if we have tabbable nodes, we must have focusable nodes; focusable nodes\n      //  are a superset of tabbable nodes since nodes with negative `tabindex` attributes\n      //  are focusable but not tabbable\n      var focusableNodes = focusable(container, config.tabbableOptions);\n      var firstTabbableNode = tabbableNodes.length > 0 ? tabbableNodes[0] : undefined;\n      var lastTabbableNode = tabbableNodes.length > 0 ? tabbableNodes[tabbableNodes.length - 1] : undefined;\n      var firstDomTabbableNode = focusableNodes.find(function (node) {\n        return isTabbable(node);\n      });\n      var lastDomTabbableNode = focusableNodes.slice().reverse().find(function (node) {\n        return isTabbable(node);\n      });\n      var posTabIndexesFound = !!tabbableNodes.find(function (node) {\n        return getTabIndex(node) > 0;\n      });\n      return {\n        container: container,\n        tabbableNodes: tabbableNodes,\n        focusableNodes: focusableNodes,\n        /** True if at least one node with positive `tabindex` was found in this container. */\n        posTabIndexesFound: posTabIndexesFound,\n        /** First tabbable node in container, __tabindex__ order; `undefined` if none. */\n        firstTabbableNode: firstTabbableNode,\n        /** Last tabbable node in container, __tabindex__ order; `undefined` if none. */\n        lastTabbableNode: lastTabbableNode,\n        // NOTE: DOM order is NOT NECESSARILY \"document position\" order, but figuring that out\n        //  would require more than just https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition\n        //  because that API doesn't work with Shadow DOM as well as it should (@see\n        //  https://github.com/whatwg/dom/issues/320) and since this first/last is only needed, so far,\n        //  to address an edge case related to positive tabindex support, this seems like a much easier,\n        //  \"close enough most of the time\" alternative for positive tabindexes which should generally\n        //  be avoided anyway...\n        /** First tabbable node in container, __DOM__ order; `undefined` if none. */\n        firstDomTabbableNode: firstDomTabbableNode,\n        /** Last tabbable node in container, __DOM__ order; `undefined` if none. */\n        lastDomTabbableNode: lastDomTabbableNode,\n        /**\n         * Finds the __tabbable__ node that follows the given node in the specified direction,\n         *  in this container, if any.\n         * @param {HTMLElement} node\n         * @param {boolean} [forward] True if going in forward tab order; false if going\n         *  in reverse.\n         * @returns {HTMLElement|undefined} The next tabbable node, if any.\n         */\n        nextTabbableNode: function nextTabbableNode(node) {\n          var forward = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n          var nodeIdx = tabbableNodes.indexOf(node);\n          if (nodeIdx < 0) {\n            // either not tabbable nor focusable, or was focused but not tabbable (negative tabindex):\n            //  since `node` should at least have been focusable, we assume that's the case and mimic\n            //  what browsers do, which is set focus to the next node in __document position order__,\n            //  regardless of positive tabindexes, if any -- and for reasons explained in the NOTE\n            //  above related to `firstDomTabbable` and `lastDomTabbable` properties, we fall back to\n            //  basic DOM order\n            if (forward) {\n              return focusableNodes.slice(focusableNodes.indexOf(node) + 1).find(function (el) {\n                return isTabbable(el);\n              });\n            }\n            return focusableNodes.slice(0, focusableNodes.indexOf(node)).reverse().find(function (el) {\n              return isTabbable(el);\n            });\n          }\n          return tabbableNodes[nodeIdx + (forward ? 1 : -1)];\n        }\n      };\n    });\n    state.tabbableGroups = state.containerGroups.filter(function (group) {\n      return group.tabbableNodes.length > 0;\n    });\n\n    // throw if no groups have tabbable nodes and we don't have a fallback focus node either\n    if (state.tabbableGroups.length <= 0 && !getNodeForOption('fallbackFocus') // returning false not supported for this option\n    ) {\n      throw new Error('Your focus-trap must have at least one container with at least one tabbable node in it at all times');\n    }\n\n    // NOTE: Positive tabindexes are only properly supported in single-container traps because\n    //  doing it across multiple containers where tabindexes could be all over the place\n    //  would require Tabbable to support multiple containers, would require additional\n    //  specialized Shadow DOM support, and would require Tabbable's multi-container support\n    //  to look at those containers in document position order rather than user-provided\n    //  order (as they are treated in Focus-trap, for legacy reasons). See discussion on\n    //  https://github.com/focus-trap/focus-trap/issues/375 for more details.\n    if (state.containerGroups.find(function (g) {\n      return g.posTabIndexesFound;\n    }) && state.containerGroups.length > 1) {\n      throw new Error(\"At least one node with a positive tabindex was found in one of your focus-trap's multiple containers. Positive tabindexes are only supported in single-container focus-traps.\");\n    }\n  };\n\n  /**\n   * Gets the current activeElement. If it's a web-component and has open shadow-root\n   * it will recursively search inside shadow roots for the \"true\" activeElement.\n   *\n   * @param {Document | ShadowRoot} el\n   *\n   * @returns {HTMLElement} The element that currently has the focus\n   **/\n  var _getActiveElement = function getActiveElement(el) {\n    var activeElement = el.activeElement;\n    if (!activeElement) {\n      return;\n    }\n    if (activeElement.shadowRoot && activeElement.shadowRoot.activeElement !== null) {\n      return _getActiveElement(activeElement.shadowRoot);\n    }\n    return activeElement;\n  };\n  var _tryFocus = function tryFocus(node) {\n    if (node === false) {\n      return;\n    }\n    if (node === _getActiveElement(document)) {\n      return;\n    }\n    if (!node || !node.focus) {\n      _tryFocus(getInitialFocusNode());\n      return;\n    }\n    node.focus({\n      preventScroll: !!config.preventScroll\n    });\n    // NOTE: focus() API does not trigger focusIn event so set MRU node manually\n    state.mostRecentlyFocusedNode = node;\n    if (isSelectableInput(node)) {\n      node.select();\n    }\n  };\n  var getReturnFocusNode = function getReturnFocusNode(previousActiveElement) {\n    var node = getNodeForOption('setReturnFocus', previousActiveElement);\n    return node ? node : node === false ? false : previousActiveElement;\n  };\n\n  /**\n   * Finds the next node (in either direction) where focus should move according to a\n   *  keyboard focus-in event.\n   * @param {Object} params\n   * @param {Node} [params.target] Known target __from which__ to navigate, if any.\n   * @param {KeyboardEvent|FocusEvent} [params.event] Event to use if `target` isn't known (event\n   *  will be used to determine the `target`). Ignored if `target` is specified.\n   * @param {boolean} [params.isBackward] True if focus should move backward.\n   * @returns {Node|undefined} The next node, or `undefined` if a next node couldn't be\n   *  determined given the current state of the trap.\n   */\n  var findNextNavNode = function findNextNavNode(_ref2) {\n    var target = _ref2.target,\n      event = _ref2.event,\n      _ref2$isBackward = _ref2.isBackward,\n      isBackward = _ref2$isBackward === void 0 ? false : _ref2$isBackward;\n    target = target || getActualTarget(event);\n    updateTabbableNodes();\n    var destinationNode = null;\n    if (state.tabbableGroups.length > 0) {\n      // make sure the target is actually contained in a group\n      // NOTE: the target may also be the container itself if it's focusable\n      //  with tabIndex='-1' and was given initial focus\n      var containerIndex = findContainerIndex(target, event);\n      var containerGroup = containerIndex >= 0 ? state.containerGroups[containerIndex] : undefined;\n      if (containerIndex < 0) {\n        // target not found in any group: quite possible focus has escaped the trap,\n        //  so bring it back into...\n        if (isBackward) {\n          // ...the last node in the last group\n          destinationNode = state.tabbableGroups[state.tabbableGroups.length - 1].lastTabbableNode;\n        } else {\n          // ...the first node in the first group\n          destinationNode = state.tabbableGroups[0].firstTabbableNode;\n        }\n      } else if (isBackward) {\n        // REVERSE\n\n        // is the target the first tabbable node in a group?\n        var startOfGroupIndex = findIndex(state.tabbableGroups, function (_ref3) {\n          var firstTabbableNode = _ref3.firstTabbableNode;\n          return target === firstTabbableNode;\n        });\n        if (startOfGroupIndex < 0 && (containerGroup.container === target || isFocusable(target, config.tabbableOptions) && !isTabbable(target, config.tabbableOptions) && !containerGroup.nextTabbableNode(target, false))) {\n          // an exception case where the target is either the container itself, or\n          //  a non-tabbable node that was given focus (i.e. tabindex is negative\n          //  and user clicked on it or node was programmatically given focus)\n          //  and is not followed by any other tabbable node, in which\n          //  case, we should handle shift+tab as if focus were on the container's\n          //  first tabbable node, and go to the last tabbable node of the LAST group\n          startOfGroupIndex = containerIndex;\n        }\n        if (startOfGroupIndex >= 0) {\n          // YES: then shift+tab should go to the last tabbable node in the\n          //  previous group (and wrap around to the last tabbable node of\n          //  the LAST group if it's the first tabbable node of the FIRST group)\n          var destinationGroupIndex = startOfGroupIndex === 0 ? state.tabbableGroups.length - 1 : startOfGroupIndex - 1;\n          var destinationGroup = state.tabbableGroups[destinationGroupIndex];\n          destinationNode = getTabIndex(target) >= 0 ? destinationGroup.lastTabbableNode : destinationGroup.lastDomTabbableNode;\n        } else if (!isTabEvent(event)) {\n          // user must have customized the nav keys so we have to move focus manually _within_\n          //  the active group: do this based on the order determined by tabbable()\n          destinationNode = containerGroup.nextTabbableNode(target, false);\n        }\n      } else {\n        // FORWARD\n\n        // is the target the last tabbable node in a group?\n        var lastOfGroupIndex = findIndex(state.tabbableGroups, function (_ref4) {\n          var lastTabbableNode = _ref4.lastTabbableNode;\n          return target === lastTabbableNode;\n        });\n        if (lastOfGroupIndex < 0 && (containerGroup.container === target || isFocusable(target, config.tabbableOptions) && !isTabbable(target, config.tabbableOptions) && !containerGroup.nextTabbableNode(target))) {\n          // an exception case where the target is the container itself, or\n          //  a non-tabbable node that was given focus (i.e. tabindex is negative\n          //  and user clicked on it or node was programmatically given focus)\n          //  and is not followed by any other tabbable node, in which\n          //  case, we should handle tab as if focus were on the container's\n          //  last tabbable node, and go to the first tabbable node of the FIRST group\n          lastOfGroupIndex = containerIndex;\n        }\n        if (lastOfGroupIndex >= 0) {\n          // YES: then tab should go to the first tabbable node in the next\n          //  group (and wrap around to the first tabbable node of the FIRST\n          //  group if it's the last tabbable node of the LAST group)\n          var _destinationGroupIndex = lastOfGroupIndex === state.tabbableGroups.length - 1 ? 0 : lastOfGroupIndex + 1;\n          var _destinationGroup = state.tabbableGroups[_destinationGroupIndex];\n          destinationNode = getTabIndex(target) >= 0 ? _destinationGroup.firstTabbableNode : _destinationGroup.firstDomTabbableNode;\n        } else if (!isTabEvent(event)) {\n          // user must have customized the nav keys so we have to move focus manually _within_\n          //  the active group: do this based on the order determined by tabbable()\n          destinationNode = containerGroup.nextTabbableNode(target);\n        }\n      }\n    } else {\n      // no groups available\n      // NOTE: the fallbackFocus option does not support returning false to opt-out\n      destinationNode = getNodeForOption('fallbackFocus');\n    }\n    return destinationNode;\n  };\n\n  // This needs to be done on mousedown and touchstart instead of click\n  // so that it precedes the focus event.\n  var checkPointerDown = function checkPointerDown(e) {\n    var target = getActualTarget(e);\n    if (findContainerIndex(target, e) >= 0) {\n      // allow the click since it ocurred inside the trap\n      return;\n    }\n    if (valueOrHandler(config.clickOutsideDeactivates, e)) {\n      // immediately deactivate the trap\n      trap.deactivate({\n        // NOTE: by setting `returnFocus: false`, deactivate() will do nothing,\n        //  which will result in the outside click setting focus to the node\n        //  that was clicked (and if not focusable, to \"nothing\"); by setting\n        //  `returnFocus: true`, we'll attempt to re-focus the node originally-focused\n        //  on activation (or the configured `setReturnFocus` node), whether the\n        //  outside click was on a focusable node or not\n        returnFocus: config.returnFocusOnDeactivate\n      });\n      return;\n    }\n\n    // This is needed for mobile devices.\n    // (If we'll only let `click` events through,\n    // then on mobile they will be blocked anyways if `touchstart` is blocked.)\n    if (valueOrHandler(config.allowOutsideClick, e)) {\n      // allow the click outside the trap to take place\n      return;\n    }\n\n    // otherwise, prevent the click\n    e.preventDefault();\n  };\n\n  // In case focus escapes the trap for some strange reason, pull it back in.\n  // NOTE: the focusIn event is NOT cancelable, so if focus escapes, it may cause unexpected\n  //  scrolling if the node that got focused was out of view; there's nothing we can do to\n  //  prevent that from happening by the time we discover that focus escaped\n  var checkFocusIn = function checkFocusIn(event) {\n    var target = getActualTarget(event);\n    var targetContained = findContainerIndex(target, event) >= 0;\n\n    // In Firefox when you Tab out of an iframe the Document is briefly focused.\n    if (targetContained || target instanceof Document) {\n      if (targetContained) {\n        state.mostRecentlyFocusedNode = target;\n      }\n    } else {\n      // escaped! pull it back in to where it just left\n      event.stopImmediatePropagation();\n\n      // focus will escape if the MRU node had a positive tab index and user tried to nav forward;\n      //  it will also escape if the MRU node had a 0 tab index and user tried to nav backward\n      //  toward a node with a positive tab index\n      var nextNode; // next node to focus, if we find one\n      var navAcrossContainers = true;\n      if (state.mostRecentlyFocusedNode) {\n        if (getTabIndex(state.mostRecentlyFocusedNode) > 0) {\n          // MRU container index must be >=0 otherwise we wouldn't have it as an MRU node...\n          var mruContainerIdx = findContainerIndex(state.mostRecentlyFocusedNode);\n          // there MAY not be any tabbable nodes in the container if there are at least 2 containers\n          //  and the MRU node is focusable but not tabbable (focus-trap requires at least 1 container\n          //  with at least one tabbable node in order to function, so this could be the other container\n          //  with nothing tabbable in it)\n          var tabbableNodes = state.containerGroups[mruContainerIdx].tabbableNodes;\n          if (tabbableNodes.length > 0) {\n            // MRU tab index MAY not be found if the MRU node is focusable but not tabbable\n            var mruTabIdx = tabbableNodes.findIndex(function (node) {\n              return node === state.mostRecentlyFocusedNode;\n            });\n            if (mruTabIdx >= 0) {\n              if (config.isKeyForward(state.recentNavEvent)) {\n                if (mruTabIdx + 1 < tabbableNodes.length) {\n                  nextNode = tabbableNodes[mruTabIdx + 1];\n                  navAcrossContainers = false;\n                }\n                // else, don't wrap within the container as focus should move to next/previous\n                //  container\n              } else {\n                if (mruTabIdx - 1 >= 0) {\n                  nextNode = tabbableNodes[mruTabIdx - 1];\n                  navAcrossContainers = false;\n                }\n                // else, don't wrap within the container as focus should move to next/previous\n                //  container\n              }\n              // else, don't find in container order without considering direction too\n            }\n          }\n          // else, no tabbable nodes in that container (which means we must have at least one other\n          //  container with at least one tabbable node in it, otherwise focus-trap would've thrown\n          //  an error the last time updateTabbableNodes() was run): find next node among all known\n          //  containers\n        } else {\n          // check to see if there's at least one tabbable node with a positive tab index inside\n          //  the trap because focus seems to escape when navigating backward from a tabbable node\n          //  with tabindex=0 when this is the case (instead of wrapping to the tabbable node with\n          //  the greatest positive tab index like it should)\n          if (!state.containerGroups.some(function (g) {\n            return g.tabbableNodes.some(function (n) {\n              return getTabIndex(n) > 0;\n            });\n          })) {\n            // no containers with tabbable nodes with positive tab indexes which means the focus\n            //  escaped for some other reason and we should just execute the fallback to the\n            //  MRU node or initial focus node, if any\n            navAcrossContainers = false;\n          }\n        }\n      } else {\n        // no MRU node means we're likely in some initial condition when the trap has just\n        //  been activated and initial focus hasn't been given yet, in which case we should\n        //  fall through to trying to focus the initial focus node, which is what should\n        //  happen below at this point in the logic\n        navAcrossContainers = false;\n      }\n      if (navAcrossContainers) {\n        nextNode = findNextNavNode({\n          // move FROM the MRU node, not event-related node (which will be the node that is\n          //  outside the trap causing the focus escape we're trying to fix)\n          target: state.mostRecentlyFocusedNode,\n          isBackward: config.isKeyBackward(state.recentNavEvent)\n        });\n      }\n      if (nextNode) {\n        _tryFocus(nextNode);\n      } else {\n        _tryFocus(state.mostRecentlyFocusedNode || getInitialFocusNode());\n      }\n    }\n    state.recentNavEvent = undefined; // clear\n  };\n\n  // Hijack key nav events on the first and last focusable nodes of the trap,\n  // in order to prevent focus from escaping. If it escapes for even a\n  // moment it can end up scrolling the page and causing confusion so we\n  // kind of need to capture the action at the keydown phase.\n  var checkKeyNav = function checkKeyNav(event) {\n    var isBackward = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n    state.recentNavEvent = event;\n    var destinationNode = findNextNavNode({\n      event: event,\n      isBackward: isBackward\n    });\n    if (destinationNode) {\n      if (isTabEvent(event)) {\n        // since tab natively moves focus, we wouldn't have a destination node unless we\n        //  were on the edge of a container and had to move to the next/previous edge, in\n        //  which case we want to prevent default to keep the browser from moving focus\n        //  to where it normally would\n        event.preventDefault();\n      }\n      _tryFocus(destinationNode);\n    }\n    // else, let the browser take care of [shift+]tab and move the focus\n  };\n  var checkTabKey = function checkTabKey(event) {\n    if (config.isKeyForward(event) || config.isKeyBackward(event)) {\n      checkKeyNav(event, config.isKeyBackward(event));\n    }\n  };\n\n  // we use a different event phase for the Escape key to allow canceling the event and checking for this in escapeDeactivates\n  var checkEscapeKey = function checkEscapeKey(event) {\n    if (isEscapeEvent(event) && valueOrHandler(config.escapeDeactivates, event) !== false) {\n      event.preventDefault();\n      trap.deactivate();\n    }\n  };\n  var checkClick = function checkClick(e) {\n    var target = getActualTarget(e);\n    if (findContainerIndex(target, e) >= 0) {\n      return;\n    }\n    if (valueOrHandler(config.clickOutsideDeactivates, e)) {\n      return;\n    }\n    if (valueOrHandler(config.allowOutsideClick, e)) {\n      return;\n    }\n    e.preventDefault();\n    e.stopImmediatePropagation();\n  };\n\n  //\n  // EVENT LISTENERS\n  //\n\n  var addListeners = function addListeners() {\n    if (!state.active) {\n      return;\n    }\n\n    // There can be only one listening focus trap at a time\n    activeFocusTraps.activateTrap(trapStack, trap);\n\n    // Delay ensures that the focused element doesn't capture the event\n    // that caused the focus trap activation.\n    state.delayInitialFocusTimer = config.delayInitialFocus ? delay(function () {\n      _tryFocus(getInitialFocusNode());\n    }) : _tryFocus(getInitialFocusNode());\n    doc.addEventListener('focusin', checkFocusIn, true);\n    doc.addEventListener('mousedown', checkPointerDown, {\n      capture: true,\n      passive: false\n    });\n    doc.addEventListener('touchstart', checkPointerDown, {\n      capture: true,\n      passive: false\n    });\n    doc.addEventListener('click', checkClick, {\n      capture: true,\n      passive: false\n    });\n    doc.addEventListener('keydown', checkTabKey, {\n      capture: true,\n      passive: false\n    });\n    doc.addEventListener('keydown', checkEscapeKey);\n    return trap;\n  };\n  var removeListeners = function removeListeners() {\n    if (!state.active) {\n      return;\n    }\n    doc.removeEventListener('focusin', checkFocusIn, true);\n    doc.removeEventListener('mousedown', checkPointerDown, true);\n    doc.removeEventListener('touchstart', checkPointerDown, true);\n    doc.removeEventListener('click', checkClick, true);\n    doc.removeEventListener('keydown', checkTabKey, true);\n    doc.removeEventListener('keydown', checkEscapeKey);\n    return trap;\n  };\n\n  //\n  // MUTATION OBSERVER\n  //\n\n  var checkDomRemoval = function checkDomRemoval(mutations) {\n    var isFocusedNodeRemoved = mutations.some(function (mutation) {\n      var removedNodes = Array.from(mutation.removedNodes);\n      return removedNodes.some(function (node) {\n        return node === state.mostRecentlyFocusedNode;\n      });\n    });\n\n    // If the currently focused is removed then browsers will move focus to the\n    // <body> element. If this happens, try to move focus back into the trap.\n    if (isFocusedNodeRemoved) {\n      _tryFocus(getInitialFocusNode());\n    }\n  };\n\n  // Use MutationObserver - if supported - to detect if focused node is removed\n  // from the DOM.\n  var mutationObserver = typeof window !== 'undefined' && 'MutationObserver' in window ? new MutationObserver(checkDomRemoval) : undefined;\n  var updateObservedNodes = function updateObservedNodes() {\n    if (!mutationObserver) {\n      return;\n    }\n    mutationObserver.disconnect();\n    if (state.active && !state.paused) {\n      state.containers.map(function (container) {\n        mutationObserver.observe(container, {\n          subtree: true,\n          childList: true\n        });\n      });\n    }\n  };\n\n  //\n  // TRAP DEFINITION\n  //\n\n  trap = {\n    get active() {\n      return state.active;\n    },\n    get paused() {\n      return state.paused;\n    },\n    activate: function activate(activateOptions) {\n      if (state.active) {\n        return this;\n      }\n      var onActivate = getOption(activateOptions, 'onActivate');\n      var onPostActivate = getOption(activateOptions, 'onPostActivate');\n      var checkCanFocusTrap = getOption(activateOptions, 'checkCanFocusTrap');\n      if (!checkCanFocusTrap) {\n        updateTabbableNodes();\n      }\n      state.active = true;\n      state.paused = false;\n      state.nodeFocusedBeforeActivation = doc.activeElement;\n      onActivate === null || onActivate === void 0 || onActivate();\n      var finishActivation = function finishActivation() {\n        if (checkCanFocusTrap) {\n          updateTabbableNodes();\n        }\n        addListeners();\n        updateObservedNodes();\n        onPostActivate === null || onPostActivate === void 0 || onPostActivate();\n      };\n      if (checkCanFocusTrap) {\n        checkCanFocusTrap(state.containers.concat()).then(finishActivation, finishActivation);\n        return this;\n      }\n      finishActivation();\n      return this;\n    },\n    deactivate: function deactivate(deactivateOptions) {\n      if (!state.active) {\n        return this;\n      }\n      var options = _objectSpread2({\n        onDeactivate: config.onDeactivate,\n        onPostDeactivate: config.onPostDeactivate,\n        checkCanReturnFocus: config.checkCanReturnFocus\n      }, deactivateOptions);\n      clearTimeout(state.delayInitialFocusTimer); // noop if undefined\n      state.delayInitialFocusTimer = undefined;\n      removeListeners();\n      state.active = false;\n      state.paused = false;\n      updateObservedNodes();\n      activeFocusTraps.deactivateTrap(trapStack, trap);\n      var onDeactivate = getOption(options, 'onDeactivate');\n      var onPostDeactivate = getOption(options, 'onPostDeactivate');\n      var checkCanReturnFocus = getOption(options, 'checkCanReturnFocus');\n      var returnFocus = getOption(options, 'returnFocus', 'returnFocusOnDeactivate');\n      onDeactivate === null || onDeactivate === void 0 || onDeactivate();\n      var finishDeactivation = function finishDeactivation() {\n        delay(function () {\n          if (returnFocus) {\n            _tryFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation));\n          }\n          onPostDeactivate === null || onPostDeactivate === void 0 || onPostDeactivate();\n        });\n      };\n      if (returnFocus && checkCanReturnFocus) {\n        checkCanReturnFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation)).then(finishDeactivation, finishDeactivation);\n        return this;\n      }\n      finishDeactivation();\n      return this;\n    },\n    pause: function pause(pauseOptions) {\n      if (state.paused || !state.active) {\n        return this;\n      }\n      var onPause = getOption(pauseOptions, 'onPause');\n      var onPostPause = getOption(pauseOptions, 'onPostPause');\n      state.paused = true;\n      onPause === null || onPause === void 0 || onPause();\n      removeListeners();\n      updateObservedNodes();\n      onPostPause === null || onPostPause === void 0 || onPostPause();\n      return this;\n    },\n    unpause: function unpause(unpauseOptions) {\n      if (!state.paused || !state.active) {\n        return this;\n      }\n      var onUnpause = getOption(unpauseOptions, 'onUnpause');\n      var onPostUnpause = getOption(unpauseOptions, 'onPostUnpause');\n      state.paused = false;\n      onUnpause === null || onUnpause === void 0 || onUnpause();\n      updateTabbableNodes();\n      addListeners();\n      updateObservedNodes();\n      onPostUnpause === null || onPostUnpause === void 0 || onPostUnpause();\n      return this;\n    },\n    updateContainerElements: function updateContainerElements(containerElements) {\n      var elementsAsArray = [].concat(containerElements).filter(Boolean);\n      state.containers = elementsAsArray.map(function (element) {\n        return typeof element === 'string' ? doc.querySelector(element) : element;\n      });\n      if (state.active) {\n        updateTabbableNodes();\n      }\n      updateObservedNodes();\n      return this;\n    }\n  };\n\n  // initialize container elements\n  trap.updateContainerElements(elements);\n  return trap;\n};\n\nexport { createFocusTrap };\n//# sourceMappingURL=focus-trap.esm.js.map\n"],"names":["_defineProperty","e","r","t","_toPropertyKey","ownKeys","o","_objectSpread2","_toPrimitive","i","activeFocusTraps","trapStack","trap","activeTrap","trapIndex","isSelectableInput","node","isEscapeEvent","isTabEvent","isKeyForward","isKeyBackward","delay","fn","findIndex","arr","idx","value","valueOrHandler","_len","params","_key","getActualTarget","event","internalTrapStack","createFocusTrap","elements","userOptions","doc","config","state","getOption","configOverrideOptions","optionName","configOptionName","findContainerIndex","element","composedPath","_ref","container","tabbableNodes","getNodeForOption","optionValue","_len2","_key2","getInitialFocusNode","isFocusable","firstTabbableGroup","firstTabbableNode","updateTabbableNodes","tabbable","focusableNodes","focusable","lastTabbableNode","firstDomTabbableNode","isTabbable","lastDomTabbableNode","posTabIndexesFound","getTabIndex","forward","nodeIdx","el","group","g","_getActiveElement","activeElement","_tryFocus","getReturnFocusNode","previousActiveElement","findNextNavNode","_ref2","target","_ref2$isBackward","isBackward","destinationNode","containerIndex","containerGroup","startOfGroupIndex","_ref3","destinationGroupIndex","destinationGroup","lastOfGroupIndex","_ref4","_destinationGroupIndex","_destinationGroup","checkPointerDown","checkFocusIn","targetContained","nextNode","navAcrossContainers","mruContainerIdx","mruTabIdx","n","checkKeyNav","checkTabKey","checkEscapeKey","checkClick","addListeners","removeListeners","checkDomRemoval","mutations","isFocusedNodeRemoved","mutation","removedNodes","mutationObserver","updateObservedNodes","activateOptions","onActivate","onPostActivate","checkCanFocusTrap","finishActivation","deactivateOptions","options","onDeactivate","onPostDeactivate","checkCanReturnFocus","returnFocus","finishDeactivation","pauseOptions","onPause","onPostPause","unpauseOptions","onUnpause","onPostUnpause","containerElements","elementsAsArray"],"mappings":"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","x_google_ignoreList":[0]}