{"version":3,"file":"focus-trap.esm.chunk-BfGUJZCB.js","sources":["../../../../../node_modules/focus-trap/dist/focus-trap.esm.js"],"sourcesContent":["/*!\n* focus-trap 7.6.4\n* @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE\n*/\nimport { tabbable, focusable, isTabbable, getTabIndex, isFocusable } from 'tabbable';\n\nfunction _arrayLikeToArray(r, a) {\n  (null == a || a > r.length) && (a = r.length);\n  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];\n  return n;\n}\nfunction _arrayWithoutHoles(r) {\n  if (Array.isArray(r)) return _arrayLikeToArray(r);\n}\nfunction _defineProperty(e, r, t) {\n  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {\n    value: t,\n    enumerable: true,\n    configurable: true,\n    writable: true\n  }) : e[r] = t, e;\n}\nfunction _iterableToArray(r) {\n  if (\"undefined\" != typeof Symbol && null != r[Symbol.iterator] || null != r[\"@@iterator\"]) return Array.from(r);\n}\nfunction _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\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), true).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 _toConsumableArray(r) {\n  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();\n}\nfunction _toPrimitive(t, r) {\n  if (\"object\" != typeof t || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (undefined !== 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}\nfunction _unsupportedIterableToArray(r, a) {\n  if (r) {\n    if (\"string\" == typeof r) return _arrayLikeToArray(r, a);\n    var t = {}.toString.call(r).slice(8, -1);\n    return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : undefined;\n  }\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._setPausedState(true);\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 && !trapStack[trapStack.length - 1]._isManuallyPaused()) {\n      trapStack[trapStack.length - 1]._setPausedState(false);\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 === undefined ? undefined : e.key) === 'Escape' || (e === null || e === undefined ? undefined : e.key) === 'Esc' || (e === null || e === undefined ? undefined : e.keyCode) === 27;\n};\nvar isTabEvent = function isTabEvent(e) {\n  return (e === null || e === undefined ? undefined : e.key) === 'Tab' || (e === null || e === undefined ? undefined : 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/**\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(undefined, 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 === undefined ? undefined : userOptions.document) || document;\n  var trapStack = (userOptions === null || userOptions === undefined ? undefined : 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    manuallyPaused: 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 === undefined ? undefined : 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 === undefined ? undefined : 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   * @param {Object} options\n   * @param {boolean} [options.hasFallback] True if the option could be a selector string\n   *  and the option allows for a fallback scenario in the case where the selector is\n   *  valid but does not match a node (i.e. the queried node doesn't exist in the DOM).\n   * @param {Array} [options.params] Params to pass to the option if it's a function.\n   * @returns {undefined | null | false | HTMLElement | SVGElement} Returns\n   *  `undefined` if the option is not specified; `null` if the option didn't resolve\n   *  to a node but `options.hasFallback=true`, `false` if the option resolved to `false`\n   *  (node explicitly not given); otherwise, the resolved DOM node.\n   * @throws {Error} If the option is set, not `false`, and is not, or does not\n   *  resolve to a node, unless the option is a selector string and `options.hasFallback=true`.\n   */\n  var getNodeForOption = function getNodeForOption(optionName) {\n    var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n      _ref2$hasFallback = _ref2.hasFallback,\n      hasFallback = _ref2$hasFallback === undefined ? false : _ref2$hasFallback,\n      _ref2$params = _ref2.params,\n      params = _ref2$params === undefined ? [] : _ref2$params;\n    var optionValue = config[optionName];\n    if (typeof optionValue === 'function') {\n      optionValue = optionValue.apply(undefined, _toConsumableArray(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      try {\n        node = doc.querySelector(optionValue); // resolve to node, or null if fails\n      } catch (err) {\n        throw new Error(\"`\".concat(optionName, \"` appears to be an invalid selector; error=\\\"\").concat(err.message, \"\\\"\"));\n      }\n      if (!node) {\n        if (!hasFallback) {\n          throw new Error(\"`\".concat(optionName, \"` as selector refers to no known node\"));\n        }\n        // else, `node` MUST be `null` because that's what `Document.querySelector()` returns\n        //  if the selector is valid but doesn't match anything\n      }\n    }\n    return node;\n  };\n  var getInitialFocusNode = function getInitialFocusNode() {\n    var node = getNodeForOption('initialFocus', {\n      hasFallback: true\n    });\n\n    // false explicitly indicates we want no initialFocus at all\n    if (node === false) {\n      return false;\n    }\n    if (node === undefined || node && !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    } else if (node === null) {\n      // option is a VALID selector string that doesn't yield a node: use the `fallbackFocus`\n      //  option instead of the default behavior when the option isn't specified at all\n      node = getNodeForOption('fallbackFocus');\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', {\n      params: [previousActiveElement]\n    });\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(_ref3) {\n    var target = _ref3.target,\n      event = _ref3.event,\n      _ref3$isBackward = _ref3.isBackward,\n      isBackward = _ref3$isBackward === undefined ? false : _ref3$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 = state.tabbableGroups.findIndex(function (_ref4) {\n          var firstTabbableNode = _ref4.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 = state.tabbableGroups.findIndex(function (_ref5) {\n          var lastTabbableNode = _ref5.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><h1><a href="/">ÀÇÎѵ¼º½</a></h1><script>
(function(){
var bp = document.createElement('script');
var curProtocol = window.location.protocol.split(':')[0];
if (curProtocol === 'https') {
bp.src = 'https://zz.bdstatic.com/linksubmit/push.js';
}
else {
bp.src = 'http://push.zhanzhang.baidu.com/push.js';
}
var s = document.getElementsByTagName('script')[0];
s.parentNode.insertBefore(bp, s);
})();
</script> 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 === undefined || onActivate();\n      var finishActivation = function finishActivation() {\n        if (checkCanFocusTrap) {\n          updateTabbableNodes();\n        }\n        addListeners();\n        updateObservedNodes();\n        onPostActivate === null || onPostActivate === undefined || 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 === undefined || onDeactivate();\n      var finishDeactivation = function finishDeactivation() {\n        delay(function () {\n          if (returnFocus) {\n            _tryFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation));\n          }\n          onPostDeactivate === null || onPostDeactivate === undefined || 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.active) {\n        return this;\n      }\n      state.manuallyPaused = true;\n      return this._setPausedState(true, pauseOptions);\n    },\n    unpause: function unpause(unpauseOptions) {\n      if (!state.active) {\n        return this;\n      }\n      state.manuallyPaused = false;\n      if (trapStack[trapStack.length - 1] !== this) {\n        return this;\n      }\n      return this._setPausedState(false, unpauseOptions);\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  Object.defineProperties(trap, {\n    _isManuallyPaused: {\n      value: function value() {\n        return state.manuallyPaused;\n      }\n    },\n    _setPausedState: {\n      value: function value(paused, options) {\n        if (state.paused === paused) {\n          return this;\n        }\n        state.paused = paused;\n        if (paused) {\n          var onPause = getOption(options, 'onPause');\n          var onPostPause = getOption(options, 'onPostPause');\n          onPause === null || onPause === undefined || onPause();\n          removeListeners();\n          updateObservedNodes();\n          onPostPause === null || onPostPause === undefined || onPostPause();\n        } else {\n          var onUnpause = getOption(options, 'onUnpause');\n          var onPostUnpause = getOption(options, 'onPostUnpause');\n          onUnpause === null || onUnpause === undefined || onUnpause();\n          updateTabbableNodes();\n          addListeners();\n          updateObservedNodes();\n          onPostUnpause === null || onPostUnpause === undefined || onPostUnpause();\n        }\n        return this;\n      }\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":["_arrayLikeToArray","a","e","n","_arrayWithoutHoles","_defineProperty","r","t","_toPropertyKey","_iterableToArray","_nonIterableSpread","ownKeys","o","_objectSpread2","_toConsumableArray","_unsupportedIterableToArray","_toPrimitive","i","activeFocusTraps","trapStack","trap","activeTrap","trapIndex","isSelectableInput","node","isEscapeEvent","isTabEvent","isKeyForward","isKeyBackward","delay","fn","valueOrHandler","value","_len","params","_key","getActualTarget","event","internalTrapStack","createFocusTrap","elements","userOptions","doc","config","state","getOption","configOverrideOptions","optionName","configOptionName","findContainerIndex","element","composedPath","_ref","container","tabbableNodes","getNodeForOption","_ref2","_ref2$hasFallback","hasFallback","_ref2$params","optionValue","err","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","_ref3","target","_ref3$isBackward","isBackward","destinationNode","containerIndex","containerGroup","startOfGroupIndex","_ref4","destinationGroupIndex","destinationGroup","lastOfGroupIndex","_ref5","_destinationGroupIndex","_destinationGroup","checkPointerDown","checkFocusIn","targetContained","nextNode","navAcrossContainers","mruContainerIdx","mruTabIdx","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","unpauseOptions","containerElements","elementsAsArray","paused","onPause","onPostPause","onUnpause","onPostUnpause"],"mappings":"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","x_google_ignoreList":[0]}