{"version":3,"file":"zoomv.5139.min.js?t=a038b293d70e5bccc98e","mappings":"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","sources":["webpack://@hero-digital/zoom/./node_modules/body-scroll-lock/lib/bodyScrollLock.esm.js","webpack://@hero-digital/zoom/./node_modules/tabbable/dist/index.esm.js","webpack://@hero-digital/zoom/./node_modules/focus-trap/dist/focus-trap.esm.js"],"sourcesContent":["function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\n// Older browsers don't support event options, feature detect it.\n\n// Adopted and modified solution from Bohdan Didukh (2017)\n// https://stackoverflow.com/questions/41594997/ios-10-safari-prevent-scrolling-behind-a-fixed-overlay-and-maintain-scroll-posi\n\nvar hasPassiveEvents = false;\nif (typeof window !== 'undefined') {\n  var passiveTestOptions = {\n    get passive() {\n      hasPassiveEvents = true;\n      return undefined;\n    }\n  };\n  window.addEventListener('testPassive', null, passiveTestOptions);\n  window.removeEventListener('testPassive', null, passiveTestOptions);\n}\n\nvar isIosDevice = typeof window !== 'undefined' && window.navigator && window.navigator.platform && (/iP(ad|hone|od)/.test(window.navigator.platform) || window.navigator.platform === 'MacIntel' && window.navigator.maxTouchPoints > 1);\n\n\nvar locks = [];\nvar documentListenerAdded = false;\nvar initialClientY = -1;\nvar previousBodyOverflowSetting = void 0;\nvar previousBodyPosition = void 0;\nvar previousBodyPaddingRight = void 0;\n\n// returns true if `el` should be allowed to receive touchmove events.\nvar allowTouchMove = function allowTouchMove(el) {\n  return locks.some(function (lock) {\n    if (lock.options.allowTouchMove && lock.options.allowTouchMove(el)) {\n      return true;\n    }\n\n    return false;\n  });\n};\n\nvar preventDefault = function preventDefault(rawEvent) {\n  var e = rawEvent || window.event;\n\n  // For the case whereby consumers adds a touchmove event listener to document.\n  // Recall that we do document.addEventListener('touchmove', preventDefault, { passive: false })\n  // in disableBodyScroll - so if we provide this opportunity to allowTouchMove, then\n  // the touchmove event on document will break.\n  if (allowTouchMove(e.target)) {\n    return true;\n  }\n\n  // Do not prevent if the event has more than one touch (usually meaning this is a multi touch gesture like pinch to zoom).\n  if (e.touches.length > 1) return true;\n\n  if (e.preventDefault) e.preventDefault();\n\n  return false;\n};\n\nvar setOverflowHidden = function setOverflowHidden(options) {\n  // If previousBodyPaddingRight is already set, don't set it again.\n  if (previousBodyPaddingRight === undefined) {\n    var _reserveScrollBarGap = !!options && options.reserveScrollBarGap === true;\n    var scrollBarGap = window.innerWidth - document.documentElement.clientWidth;\n\n    if (_reserveScrollBarGap && scrollBarGap > 0) {\n      var computedBodyPaddingRight = parseInt(window.getComputedStyle(document.body).getPropertyValue('padding-right'), 10);\n      previousBodyPaddingRight = document.body.style.paddingRight;\n      document.body.style.paddingRight = computedBodyPaddingRight + scrollBarGap + 'px';\n    }\n  }\n\n  // If previousBodyOverflowSetting is already set, don't set it again.\n  if (previousBodyOverflowSetting === undefined) {\n    previousBodyOverflowSetting = document.body.style.overflow;\n    document.body.style.overflow = 'hidden';\n  }\n};\n\nvar restoreOverflowSetting = function restoreOverflowSetting() {\n  if (previousBodyPaddingRight !== undefined) {\n    document.body.style.paddingRight = previousBodyPaddingRight;\n\n    // Restore previousBodyPaddingRight to undefined so setOverflowHidden knows it\n    // can be set again.\n    previousBodyPaddingRight = undefined;\n  }\n\n  if (previousBodyOverflowSetting !== undefined) {\n    document.body.style.overflow = previousBodyOverflowSetting;\n\n    // Restore previousBodyOverflowSetting to undefined\n    // so setOverflowHidden knows it can be set again.\n    previousBodyOverflowSetting = undefined;\n  }\n};\n\nvar setPositionFixed = function setPositionFixed() {\n  return window.requestAnimationFrame(function () {\n    // If previousBodyPosition is already set, don't set it again.\n    if (previousBodyPosition === undefined) {\n      previousBodyPosition = {\n        position: document.body.style.position,\n        top: document.body.style.top,\n        left: document.body.style.left\n      };\n\n      // Update the dom inside an animation frame \n      var _window = window,\n          scrollY = _window.scrollY,\n          scrollX = _window.scrollX,\n          innerHeight = _window.innerHeight;\n\n      document.body.style.position = 'fixed';\n      document.body.style.top = -scrollY;\n      document.body.style.left = -scrollX;\n\n      setTimeout(function () {\n        return window.requestAnimationFrame(function () {\n          // Attempt to check if the bottom bar appeared due to the position change\n          var bottomBarHeight = innerHeight - window.innerHeight;\n          if (bottomBarHeight && scrollY >= innerHeight) {\n            // Move the content further up so that the bottom bar doesn't hide it\n            document.body.style.top = -(scrollY + bottomBarHeight);\n          }\n        });\n      }, 300);\n    }\n  });\n};\n\nvar restorePositionSetting = function restorePositionSetting() {\n  if (previousBodyPosition !== undefined) {\n    // Convert the position from \"px\" to Int\n    var y = -parseInt(document.body.style.top, 10);\n    var x = -parseInt(document.body.style.left, 10);\n\n    // Restore styles\n    document.body.style.position = previousBodyPosition.position;\n    document.body.style.top = previousBodyPosition.top;\n    document.body.style.left = previousBodyPosition.left;\n\n    // Restore scroll\n    window.scrollTo(x, y);\n\n    previousBodyPosition = undefined;\n  }\n};\n\n// https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollHeight#Problems_and_solutions\nvar isTargetElementTotallyScrolled = function isTargetElementTotallyScrolled(targetElement) {\n  return targetElement ? targetElement.scrollHeight - targetElement.scrollTop <= targetElement.clientHeight : false;\n};\n\nvar handleScroll = function handleScroll(event, targetElement) {\n  var clientY = event.targetTouches[0].clientY - initialClientY;\n\n  if (allowTouchMove(event.target)) {\n    return false;\n  }\n\n  if (targetElement && targetElement.scrollTop === 0 && clientY > 0) {\n    // element is at the top of its scroll.\n    return preventDefault(event);\n  }\n\n  if (isTargetElementTotallyScrolled(targetElement) && clientY < 0) {\n    // element is at the bottom of its scroll.\n    return preventDefault(event);\n  }\n\n  event.stopPropagation();\n  return true;\n};\n\nexport var disableBodyScroll = function disableBodyScroll(targetElement, options) {\n  // targetElement must be provided\n  if (!targetElement) {\n    // eslint-disable-next-line no-console\n    console.error('disableBodyScroll unsuccessful - targetElement must be provided when calling disableBodyScroll on IOS devices.');\n    return;\n  }\n\n  // disableBodyScroll must not have been called on this targetElement before\n  if (locks.some(function (lock) {\n    return lock.targetElement === targetElement;\n  })) {\n    return;\n  }\n\n  var lock = {\n    targetElement: targetElement,\n    options: options || {}\n  };\n\n  locks = [].concat(_toConsumableArray(locks), [lock]);\n\n  if (isIosDevice) {\n    setPositionFixed();\n  } else {\n    setOverflowHidden(options);\n  }\n\n  if (isIosDevice) {\n    targetElement.ontouchstart = function (event) {\n      if (event.targetTouches.length === 1) {\n        // detect single touch.\n        initialClientY = event.targetTouches[0].clientY;\n      }\n    };\n    targetElement.ontouchmove = function (event) {\n      if (event.targetTouches.length === 1) {\n        // detect single touch.\n        handleScroll(event, targetElement);\n      }\n    };\n\n    if (!documentListenerAdded) {\n      document.addEventListener('touchmove', preventDefault, hasPassiveEvents ? { passive: false } : undefined);\n      documentListenerAdded = true;\n    }\n  }\n};\n\nexport var clearAllBodyScrollLocks = function clearAllBodyScrollLocks() {\n  if (isIosDevice) {\n    // Clear all locks ontouchstart/ontouchmove handlers, and the references.\n    locks.forEach(function (lock) {\n      lock.targetElement.ontouchstart = null;\n      lock.targetElement.ontouchmove = null;\n    });\n\n    if (documentListenerAdded) {\n      document.removeEventListener('touchmove', preventDefault, hasPassiveEvents ? { passive: false } : undefined);\n      documentListenerAdded = false;\n    }\n\n    // Reset initial clientY.\n    initialClientY = -1;\n  }\n\n  if (isIosDevice) {\n    restorePositionSetting();\n  } else {\n    restoreOverflowSetting();\n  }\n\n  locks = [];\n};\n\nexport var enableBodyScroll = function enableBodyScroll(targetElement) {\n  if (!targetElement) {\n    // eslint-disable-next-line no-console\n    console.error('enableBodyScroll unsuccessful - targetElement must be provided when calling enableBodyScroll on IOS devices.');\n    return;\n  }\n\n  locks = locks.filter(function (lock) {\n    return lock.targetElement !== targetElement;\n  });\n\n  if (isIosDevice) {\n    targetElement.ontouchstart = null;\n    targetElement.ontouchmove = null;\n\n    if (documentListenerAdded && locks.length === 0) {\n      document.removeEventListener('touchmove', preventDefault, hasPassiveEvents ? { passive: false } : undefined);\n      documentListenerAdded = false;\n    }\n  }\n\n  if (isIosDevice) {\n    restorePositionSetting();\n  } else {\n    restoreOverflowSetting();\n  }\n};\n\n","/*!\n* tabbable 6.1.1\n* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE\n*/\n// NOTE: separate `:not()` selectors has broader browser support than the newer\n//  `:not([inert], [inert] *)` (Feb 2023)\n// CAREFUL: JSDom does not support `:not([inert] *)` as a selector; using it causes\n//  the entire query to fail, resulting in no nodes found, which will break a lot\n//  of things... so we have to rely on JS to identify nodes inside an inert container\nvar candidateSelectors = ['input:not([inert])', 'select:not([inert])', 'textarea:not([inert])', 'a[href]:not([inert])', 'button:not([inert])', '[tabindex]:not(slot):not([inert])', 'audio[controls]:not([inert])', 'video[controls]:not([inert])', '[contenteditable]:not([contenteditable=\"false\"]):not([inert])', 'details>summary:first-of-type:not([inert])', 'details:not([inert])'];\nvar candidateSelector = /* #__PURE__ */candidateSelectors.join(',');\nvar NoElement = typeof Element === 'undefined';\nvar matches = NoElement ? function () {} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;\nvar getRootNode = !NoElement && Element.prototype.getRootNode ? function (element) {\n  var _element$getRootNode;\n  return element === null || element === void 0 ? void 0 : (_element$getRootNode = element.getRootNode) === null || _element$getRootNode === void 0 ? void 0 : _element$getRootNode.call(element);\n} : function (element) {\n  return element === null || element === void 0 ? void 0 : element.ownerDocument;\n};\n\n/**\n * Determines if a node is inert or in an inert ancestor.\n * @param {Element} [node]\n * @param {boolean} [lookUp] If true and `node` is not inert, looks up at ancestors to\n *  see if any of them are inert. If false, only `node` itself is considered.\n * @returns {boolean} True if inert itself or by way of being in an inert ancestor.\n *  False if `node` is falsy.\n */\nvar isInert = function isInert(node, lookUp) {\n  var _node$getAttribute;\n  if (lookUp === void 0) {\n    lookUp = true;\n  }\n  // CAREFUL: JSDom does not support inert at all, so we can't use the `HTMLElement.inert`\n  //  JS API property; we have to check the attribute, which can either be empty or 'true';\n  //  if it's `null` (not specified) or 'false', it's an active element\n  var inertAtt = node === null || node === void 0 ? void 0 : (_node$getAttribute = node.getAttribute) === null || _node$getAttribute === void 0 ? void 0 : _node$getAttribute.call(node, 'inert');\n  var inert = inertAtt === '' || inertAtt === 'true';\n\n  // NOTE: this could also be handled with `node.matches('[inert], :is([inert] *)')`\n  //  if it weren't for `matches()` not being a function on shadow roots; the following\n  //  code works for any kind of node\n  // CAREFUL: JSDom does not appear to support certain selectors like `:not([inert] *)`\n  //  so it likely would not support `:is([inert] *)` either...\n  var result = inert || lookUp && node && isInert(node.parentNode); // recursive\n\n  return result;\n};\n\n/**\n * Determines if a node's content is editable.\n * @param {Element} [node]\n * @returns True if it's content-editable; false if it's not or `node` is falsy.\n */\nvar isContentEditable = function isContentEditable(node) {\n  var _node$getAttribute2;\n  // CAREFUL: JSDom does not support the `HTMLElement.isContentEditable` API so we have\n  //  to use the attribute directly to check for this, which can either be empty or 'true';\n  //  if it's `null` (not specified) or 'false', it's a non-editable element\n  var attValue = node === null || node === void 0 ? void 0 : (_node$getAttribute2 = node.getAttribute) === null || _node$getAttribute2 === void 0 ? void 0 : _node$getAttribute2.call(node, 'contenteditable');\n  return attValue === '' || attValue === 'true';\n};\n\n/**\n * @param {Element} el container to check in\n * @param {boolean} includeContainer add container to check\n * @param {(node: Element) => boolean} filter filter candidates\n * @returns {Element[]}\n */\nvar getCandidates = function getCandidates(el, includeContainer, filter) {\n  // even if `includeContainer=false`, we still have to check it for inertness because\n  //  if it's inert, all its children are inert\n  if (isInert(el)) {\n    return [];\n  }\n  var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));\n  if (includeContainer && matches.call(el, candidateSelector)) {\n    candidates.unshift(el);\n  }\n  candidates = candidates.filter(filter);\n  return candidates;\n};\n\n/**\n * @callback GetShadowRoot\n * @param {Element} element to check for shadow root\n * @returns {ShadowRoot|boolean} ShadowRoot if available or boolean indicating if a shadowRoot is attached but not available.\n */\n\n/**\n * @callback ShadowRootFilter\n * @param {Element} shadowHostNode the element which contains shadow content\n * @returns {boolean} true if a shadow root could potentially contain valid candidates.\n */\n\n/**\n * @typedef {Object} CandidateScope\n * @property {Element} scopeParent contains inner candidates\n * @property {Element[]} candidates list of candidates found in the scope parent\n */\n\n/**\n * @typedef {Object} IterativeOptions\n * @property {GetShadowRoot|boolean} getShadowRoot true if shadow support is enabled; falsy if not;\n *  if a function, implies shadow support is enabled and either returns the shadow root of an element\n *  or a boolean stating if it has an undisclosed shadow root\n * @property {(node: Element) => boolean} filter filter candidates\n * @property {boolean} flatten if true then result will flatten any CandidateScope into the returned list\n * @property {ShadowRootFilter} shadowRootFilter filter shadow roots;\n */\n\n/**\n * @param {Element[]} elements list of element containers to match candidates from\n * @param {boolean} includeContainer add container list to check\n * @param {IterativeOptions} options\n * @returns {Array.<Element|CandidateScope>}\n */\nvar getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {\n  var candidates = [];\n  var elementsToCheck = Array.from(elements);\n  while (elementsToCheck.length) {\n    var element = elementsToCheck.shift();\n    if (isInert(element, false)) {\n      // no need to look up since we're drilling down\n      // anything inside this container will also be inert\n      continue;\n    }\n    if (element.tagName === 'SLOT') {\n      // add shadow dom slot scope (slot itself cannot be focusable)\n      var assigned = element.assignedElements();\n      var content = assigned.length ? assigned : element.children;\n      var nestedCandidates = getCandidatesIteratively(content, true, options);\n      if (options.flatten) {\n        candidates.push.apply(candidates, nestedCandidates);\n      } else {\n        candidates.push({\n          scopeParent: element,\n          candidates: nestedCandidates\n        });\n      }\n    } else {\n      // check candidate element\n      var validCandidate = matches.call(element, candidateSelector);\n      if (validCandidate && options.filter(element) && (includeContainer || !elements.includes(element))) {\n        candidates.push(element);\n      }\n\n      // iterate over shadow content if possible\n      var shadowRoot = element.shadowRoot ||\n      // check for an undisclosed shadow\n      typeof options.getShadowRoot === 'function' && options.getShadowRoot(element);\n\n      // no inert look up because we're already drilling down and checking for inertness\n      //  on the way down, so all containers to this root node should have already been\n      //  vetted as non-inert\n      var validShadowRoot = !isInert(shadowRoot, false) && (!options.shadowRootFilter || options.shadowRootFilter(element));\n      if (shadowRoot && validShadowRoot) {\n        // add shadow dom scope IIF a shadow root node was given; otherwise, an undisclosed\n        //  shadow exists, so look at light dom children as fallback BUT create a scope for any\n        //  child candidates found because they're likely slotted elements (elements that are\n        //  children of the web component element (which has the shadow), in the light dom, but\n        //  slotted somewhere _inside_ the undisclosed shadow) -- the scope is created below,\n        //  _after_ we return from this recursive call\n        var _nestedCandidates = getCandidatesIteratively(shadowRoot === true ? element.children : shadowRoot.children, true, options);\n        if (options.flatten) {\n          candidates.push.apply(candidates, _nestedCandidates);\n        } else {\n          candidates.push({\n            scopeParent: element,\n            candidates: _nestedCandidates\n          });\n        }\n      } else {\n        // there's not shadow so just dig into the element's (light dom) children\n        //  __without__ giving the element special scope treatment\n        elementsToCheck.unshift.apply(elementsToCheck, element.children);\n      }\n    }\n  }\n  return candidates;\n};\nvar getTabindex = function getTabindex(node, isScope) {\n  if (node.tabIndex < 0) {\n    // in Chrome, <details/>, <audio controls/> and <video controls/> elements get a default\n    // `tabIndex` of -1 when the 'tabindex' attribute isn't specified in the DOM,\n    // yet they are still part of the regular tab order; in FF, they get a default\n    // `tabIndex` of 0; since Chrome still puts those elements in the regular tab\n    // order, consider their tab index to be 0.\n    // Also browsers do not return `tabIndex` correctly for contentEditable nodes;\n    // so if they don't have a tabindex attribute specifically set, assume it's 0.\n    //\n    // isScope is positive for custom element with shadow root or slot that by default\n    // have tabIndex -1, but need to be sorted by document order in order for their\n    // content to be inserted in the correct position\n    if ((isScope || /^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || isContentEditable(node)) && isNaN(parseInt(node.getAttribute('tabindex'), 10))) {\n      return 0;\n    }\n  }\n  return node.tabIndex;\n};\nvar sortOrderedTabbables = function sortOrderedTabbables(a, b) {\n  return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;\n};\nvar isInput = function isInput(node) {\n  return node.tagName === 'INPUT';\n};\nvar isHiddenInput = function isHiddenInput(node) {\n  return isInput(node) && node.type === 'hidden';\n};\nvar isDetailsWithSummary = function isDetailsWithSummary(node) {\n  var r = node.tagName === 'DETAILS' && Array.prototype.slice.apply(node.children).some(function (child) {\n    return child.tagName === 'SUMMARY';\n  });\n  return r;\n};\nvar getCheckedRadio = function getCheckedRadio(nodes, form) {\n  for (var i = 0; i < nodes.length; i++) {\n    if (nodes[i].checked && nodes[i].form === form) {\n      return nodes[i];\n    }\n  }\n};\nvar isTabbableRadio = function isTabbableRadio(node) {\n  if (!node.name) {\n    return true;\n  }\n  var radioScope = node.form || getRootNode(node);\n  var queryRadios = function queryRadios(name) {\n    return radioScope.querySelectorAll('input[type=\"radio\"][name=\"' + name + '\"]');\n  };\n  var radioSet;\n  if (typeof window !== 'undefined' && typeof window.CSS !== 'undefined' && typeof window.CSS.escape === 'function') {\n    radioSet = queryRadios(window.CSS.escape(node.name));\n  } else {\n    try {\n      radioSet = queryRadios(node.name);\n    } catch (err) {\n      // eslint-disable-next-line no-console\n      console.error('Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s', err.message);\n      return false;\n    }\n  }\n  var checked = getCheckedRadio(radioSet, node.form);\n  return !checked || checked === node;\n};\nvar isRadio = function isRadio(node) {\n  return isInput(node) && node.type === 'radio';\n};\nvar isNonTabbableRadio = function isNonTabbableRadio(node) {\n  return isRadio(node) && !isTabbableRadio(node);\n};\n\n// determines if a node is ultimately attached to the window's document\nvar isNodeAttached = function isNodeAttached(node) {\n  var _nodeRoot;\n  // The root node is the shadow root if the node is in a shadow DOM; some document otherwise\n  //  (but NOT _the_ document; see second 'If' comment below for more).\n  // If rootNode is shadow root, it'll have a host, which is the element to which the shadow\n  //  is attached, and the one we need to check if it's in the document or not (because the\n  //  shadow, and all nodes it contains, is never considered in the document since shadows\n  //  behave like self-contained DOMs; but if the shadow's HOST, which is part of the document,\n  //  is hidden, or is not in the document itself but is detached, it will affect the shadow's\n  //  visibility, including all the nodes it contains). The host could be any normal node,\n  //  or a custom element (i.e. web component). Either way, that's the one that is considered\n  //  part of the document, not the shadow root, nor any of its children (i.e. the node being\n  //  tested).\n  // To further complicate things, we have to look all the way up until we find a shadow HOST\n  //  that is attached (or find none) because the node might be in nested shadows...\n  // If rootNode is not a shadow root, it won't have a host, and so rootNode should be the\n  //  document (per the docs) and while it's a Document-type object, that document does not\n  //  appear to be the same as the node's `ownerDocument` for some reason, so it's safer\n  //  to ignore the rootNode at this point, and use `node.ownerDocument`. Otherwise,\n  //  using `rootNode.contains(node)` will _always_ be true we'll get false-positives when\n  //  node is actually detached.\n  // NOTE: If `nodeRootHost` or `node` happens to be the `document` itself (which is possible\n  //  if a tabbable/focusable node was quickly added to the DOM, focused, and then removed\n  //  from the DOM as in https://github.com/focus-trap/focus-trap-react/issues/905), then\n  //  `ownerDocument` will be `null`, hence the optional chaining on it.\n  var nodeRoot = node && getRootNode(node);\n  var nodeRootHost = (_nodeRoot = nodeRoot) === null || _nodeRoot === void 0 ? void 0 : _nodeRoot.host;\n\n  // in some cases, a detached node will return itself as the root instead of a document or\n  //  shadow root object, in which case, we shouldn't try to look further up the host chain\n  var attached = false;\n  if (nodeRoot && nodeRoot !== node) {\n    var _nodeRootHost, _nodeRootHost$ownerDo, _node$ownerDocument;\n    attached = !!((_nodeRootHost = nodeRootHost) !== null && _nodeRootHost !== void 0 && (_nodeRootHost$ownerDo = _nodeRootHost.ownerDocument) !== null && _nodeRootHost$ownerDo !== void 0 && _nodeRootHost$ownerDo.contains(nodeRootHost) || node !== null && node !== void 0 && (_node$ownerDocument = node.ownerDocument) !== null && _node$ownerDocument !== void 0 && _node$ownerDocument.contains(node));\n    while (!attached && nodeRootHost) {\n      var _nodeRoot2, _nodeRootHost2, _nodeRootHost2$ownerD;\n      // since it's not attached and we have a root host, the node MUST be in a nested shadow DOM,\n      //  which means we need to get the host's host and check if that parent host is contained\n      //  in (i.e. attached to) the document\n      nodeRoot = getRootNode(nodeRootHost);\n      nodeRootHost = (_nodeRoot2 = nodeRoot) === null || _nodeRoot2 === void 0 ? void 0 : _nodeRoot2.host;\n      attached = !!((_nodeRootHost2 = nodeRootHost) !== null && _nodeRootHost2 !== void 0 && (_nodeRootHost2$ownerD = _nodeRootHost2.ownerDocument) !== null && _nodeRootHost2$ownerD !== void 0 && _nodeRootHost2$ownerD.contains(nodeRootHost));\n    }\n  }\n  return attached;\n};\nvar isZeroArea = function isZeroArea(node) {\n  var _node$getBoundingClie = node.getBoundingClientRect(),\n    width = _node$getBoundingClie.width,\n    height = _node$getBoundingClie.height;\n  return width === 0 && height === 0;\n};\nvar isHidden = function isHidden(node, _ref) {\n  var displayCheck = _ref.displayCheck,\n    getShadowRoot = _ref.getShadowRoot;\n  // NOTE: visibility will be `undefined` if node is detached from the document\n  //  (see notes about this further down), which means we will consider it visible\n  //  (this is legacy behavior from a very long way back)\n  // NOTE: we check this regardless of `displayCheck=\"none\"` because this is a\n  //  _visibility_ check, not a _display_ check\n  if (getComputedStyle(node).visibility === 'hidden') {\n    return true;\n  }\n  var isDirectSummary = matches.call(node, 'details>summary:first-of-type');\n  var nodeUnderDetails = isDirectSummary ? node.parentElement : node;\n  if (matches.call(nodeUnderDetails, 'details:not([open]) *')) {\n    return true;\n  }\n  if (!displayCheck || displayCheck === 'full' || displayCheck === 'legacy-full') {\n    if (typeof getShadowRoot === 'function') {\n      // figure out if we should consider the node to be in an undisclosed shadow and use the\n      //  'non-zero-area' fallback\n      var originalNode = node;\n      while (node) {\n        var parentElement = node.parentElement;\n        var rootNode = getRootNode(node);\n        if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true // check if there's an undisclosed shadow\n        ) {\n          // node has an undisclosed shadow which means we can only treat it as a black box, so we\n          //  fall back to a non-zero-area test\n          return isZeroArea(node);\n        } else if (node.assignedSlot) {\n          // iterate up slot\n          node = node.assignedSlot;\n        } else if (!parentElement && rootNode !== node.ownerDocument) {\n          // cross shadow boundary\n          node = rootNode.host;\n        } else {\n          // iterate up normal dom\n          node = parentElement;\n        }\n      }\n      node = originalNode;\n    }\n    // else, `getShadowRoot` might be true, but all that does is enable shadow DOM support\n    //  (i.e. it does not also presume that all nodes might have undisclosed shadows); or\n    //  it might be a falsy value, which means shadow DOM support is disabled\n\n    // Since we didn't find it sitting in an undisclosed shadow (or shadows are disabled)\n    //  now we can just test to see if it would normally be visible or not, provided it's\n    //  attached to the main document.\n    // NOTE: We must consider case where node is inside a shadow DOM and given directly to\n    //  `isTabbable()` or `isFocusable()` -- regardless of `getShadowRoot` option setting.\n\n    if (isNodeAttached(node)) {\n      // this works wherever the node is: if there's at least one client rect, it's\n      //  somehow displayed; it also covers the CSS 'display: contents' case where the\n      //  node itself is hidden in place of its contents; and there's no need to search\n      //  up the hierarchy either\n      return !node.getClientRects().length;\n    }\n\n    // Else, the node isn't attached to the document, which means the `getClientRects()`\n    //  API will __always__ return zero rects (this can happen, for example, if React\n    //  is used to render nodes onto a detached tree, as confirmed in this thread:\n    //  https://github.com/facebook/react/issues/9117#issuecomment-284228870)\n    //\n    // It also means that even window.getComputedStyle(node).display will return `undefined`\n    //  because styles are only computed for nodes that are in the document.\n    //\n    // NOTE: THIS HAS BEEN THE CASE FOR YEARS. It is not new, nor is it caused by tabbable\n    //  somehow. Though it was never stated officially, anyone who has ever used tabbable\n    //  APIs on nodes in detached containers has actually implicitly used tabbable in what\n    //  was later (as of v5.2.0 on Apr 9, 2021) called `displayCheck=\"none\"` mode -- essentially\n    //  considering __everything__ to be visible because of the innability to determine styles.\n    //\n    // v6.0.0: As of this major release, the default 'full' option __no longer treats detached\n    //  nodes as visible with the 'none' fallback.__\n    if (displayCheck !== 'legacy-full') {\n      return true; // hidden\n    }\n    // else, fallback to 'none' mode and consider the node visible\n  } else if (displayCheck === 'non-zero-area') {\n    // NOTE: Even though this tests that the node's client rect is non-zero to determine\n    //  whether it's displayed, and that a detached node will __always__ have a zero-area\n    //  client rect, we don't special-case for whether the node is attached or not. In\n    //  this mode, we do want to consider nodes that have a zero area to be hidden at all\n    //  times, and that includes attached or not.\n    return isZeroArea(node);\n  }\n\n  // visible, as far as we can tell, or per current `displayCheck=none` mode, we assume\n  //  it's visible\n  return false;\n};\n\n// form fields (nested) inside a disabled fieldset are not focusable/tabbable\n//  unless they are in the _first_ <legend> element of the top-most disabled\n//  fieldset\nvar isDisabledFromFieldset = function isDisabledFromFieldset(node) {\n  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {\n    var parentNode = node.parentElement;\n    // check if `node` is contained in a disabled <fieldset>\n    while (parentNode) {\n      if (parentNode.tagName === 'FIELDSET' && parentNode.disabled) {\n        // look for the first <legend> among the children of the disabled <fieldset>\n        for (var i = 0; i < parentNode.children.length; i++) {\n          var child = parentNode.children.item(i);\n          // when the first <legend> (in document order) is found\n          if (child.tagName === 'LEGEND') {\n            // if its parent <fieldset> is not nested in another disabled <fieldset>,\n            // return whether `node` is a descendant of its first <legend>\n            return matches.call(parentNode, 'fieldset[disabled] *') ? true : !child.contains(node);\n          }\n        }\n        // the disabled <fieldset> containing `node` has no <legend>\n        return true;\n      }\n      parentNode = parentNode.parentElement;\n    }\n  }\n\n  // else, node's tabbable/focusable state should not be affected by a fieldset's\n  //  enabled/disabled state\n  return false;\n};\nvar isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable(options, node) {\n  if (node.disabled ||\n  // we must do an inert look up to filter out any elements inside an inert ancestor\n  //  because we're limited in the type of selectors we can use in JSDom (see related\n  //  note related to `candidateSelectors`)\n  isInert(node) || isHiddenInput(node) || isHidden(node, options) ||\n  // For a details element with a summary, the summary element gets the focus\n  isDetailsWithSummary(node) || isDisabledFromFieldset(node)) {\n    return false;\n  }\n  return true;\n};\nvar isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable(options, node) {\n  if (isNonTabbableRadio(node) || getTabindex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) {\n    return false;\n  }\n  return true;\n};\nvar isValidShadowRootTabbable = function isValidShadowRootTabbable(shadowHostNode) {\n  var tabIndex = parseInt(shadowHostNode.getAttribute('tabindex'), 10);\n  if (isNaN(tabIndex) || tabIndex >= 0) {\n    return true;\n  }\n  // If a custom element has an explicit negative tabindex,\n  // browsers will not allow tab targeting said element's children.\n  return false;\n};\n\n/**\n * @param {Array.<Element|CandidateScope>} candidates\n * @returns Element[]\n */\nvar sortByOrder = function sortByOrder(candidates) {\n  var regularTabbables = [];\n  var orderedTabbables = [];\n  candidates.forEach(function (item, i) {\n    var isScope = !!item.scopeParent;\n    var element = isScope ? item.scopeParent : item;\n    var candidateTabindex = getTabindex(element, isScope);\n    var elements = isScope ? sortByOrder(item.candidates) : element;\n    if (candidateTabindex === 0) {\n      isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element);\n    } else {\n      orderedTabbables.push({\n        documentOrder: i,\n        tabIndex: candidateTabindex,\n        item: item,\n        isScope: isScope,\n        content: elements\n      });\n    }\n  });\n  return orderedTabbables.sort(sortOrderedTabbables).reduce(function (acc, sortable) {\n    sortable.isScope ? acc.push.apply(acc, sortable.content) : acc.push(sortable.content);\n    return acc;\n  }, []).concat(regularTabbables);\n};\nvar tabbable = function tabbable(el, options) {\n  options = options || {};\n  var candidates;\n  if (options.getShadowRoot) {\n    candidates = getCandidatesIteratively([el], options.includeContainer, {\n      filter: isNodeMatchingSelectorTabbable.bind(null, options),\n      flatten: false,\n      getShadowRoot: options.getShadowRoot,\n      shadowRootFilter: isValidShadowRootTabbable\n    });\n  } else {\n    candidates = getCandidates(el, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));\n  }\n  return sortByOrder(candidates);\n};\nvar focusable = function focusable(el, options) {\n  options = options || {};\n  var candidates;\n  if (options.getShadowRoot) {\n    candidates = getCandidatesIteratively([el], options.includeContainer, {\n      filter: isNodeMatchingSelectorFocusable.bind(null, options),\n      flatten: true,\n      getShadowRoot: options.getShadowRoot\n    });\n  } else {\n    candidates = getCandidates(el, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));\n  }\n  return candidates;\n};\nvar isTabbable = function isTabbable(node, options) {\n  options = options || {};\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (matches.call(node, candidateSelector) === false) {\n    return false;\n  }\n  return isNodeMatchingSelectorTabbable(options, node);\n};\nvar focusableCandidateSelector = /* #__PURE__ */candidateSelectors.concat('iframe').join(',');\nvar isFocusable = function isFocusable(node, options) {\n  options = options || {};\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (matches.call(node, focusableCandidateSelector) === false) {\n    return false;\n  }\n  return isNodeMatchingSelectorFocusable(options, node);\n};\n\nexport { focusable, isFocusable, isTabbable, tabbable };\n//# sourceMappingURL=index.esm.js.map\n","/*!\n* focus-trap 7.3.1\n* @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE\n*/\nimport { tabbable, focusable, isTabbable, isFocusable } from 'tabbable';\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    enumerableOnly && (symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    })), keys.push.apply(keys, symbols);\n  }\n  return keys;\n}\nfunction _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = null != arguments[i] ? arguments[i] : {};\n    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {\n      _defineProperty(target, key, source[key]);\n    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {\n      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n    });\n  }\n  return target;\n}\nfunction _defineProperty(obj, key, value) {\n  key = _toPropertyKey(key);\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}\nfunction _toPrimitive(input, hint) {\n  if (typeof input !== \"object\" || input === null) return input;\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (typeof res !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}\nfunction _toPropertyKey(arg) {\n  var key = _toPrimitive(arg, \"string\");\n  return typeof key === \"symbol\" ? key : String(key);\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.key === 'Escape' || e.key === 'Esc' || e.keyCode === 27;\n};\nvar isTabEvent = function isTabEvent(e) {\n  return e.key === 'Tab' || 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\n    return true; // next\n  });\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    //   firstTabbableNode: HTMLElement|null,\n    //   lastTabbableNode: HTMLElement|null,\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  };\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   * @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) {\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) ||\n      // 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      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\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) {\n      // option not specified: 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\n      var focusableNodes = focusable(container, config.tabbableOptions);\n      return {\n        container: container,\n        tabbableNodes: tabbableNodes,\n        focusableNodes: focusableNodes,\n        firstTabbableNode: tabbableNodes.length > 0 ? tabbableNodes[0] : null,\n        lastTabbableNode: tabbableNodes.length > 0 ? tabbableNodes[tabbableNodes.length - 1] : null,\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          // NOTE: If tabindex is positive (in order to manipulate the tab order separate\n          //  from the DOM order), this __will not work__ because the list of focusableNodes,\n          //  while it contains tabbable nodes, does not sort its nodes in any order other\n          //  than DOM order, because it can't: Where would you place focusable (but not\n          //  tabbable) nodes in that order? They have no order, because they aren't tabbale...\n          // Support for positive tabindex is already broken and hard to manage (possibly\n          //  not supportable, TBD), so this isn't going to make things worse than they\n          //  already are, and at least makes things better for the majority of cases where\n          //  tabindex is either 0/unset or negative.\n          // FYI, positive tabindex issue: https://github.com/focus-trap/focus-trap/issues/375\n          var nodeIdx = focusableNodes.findIndex(function (n) {\n            return n === node;\n          });\n          if (nodeIdx < 0) {\n            return undefined;\n          }\n          if (forward) {\n            return focusableNodes.slice(nodeIdx + 1).find(function (n) {\n              return isTabbable(n, config.tabbableOptions);\n            });\n          }\n          return focusableNodes.slice(0, nodeIdx).reverse().find(function (n) {\n            return isTabbable(n, config.tabbableOptions);\n          });\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  var tryFocus = function tryFocus(node) {\n    if (node === false) {\n      return;\n    }\n    if (node === doc.activeElement) {\n      return;\n    }\n    if (!node || !node.focus) {\n      tryFocus(getInitialFocusNode());\n      return;\n    }\n    node.focus({\n      preventScroll: !!config.preventScroll\n    });\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  // 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) >= 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  var checkFocusIn = function checkFocusIn(e) {\n    var target = getActualTarget(e);\n    var targetContained = findContainerIndex(target) >= 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      e.stopImmediatePropagation();\n      tryFocus(state.mostRecentlyFocusedNode || getInitialFocusNode());\n    }\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    var 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);\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 (_ref2) {\n          var firstTabbableNode = _ref2.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 = destinationGroup.lastTabbableNode;\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 (_ref3) {\n          var lastTabbableNode = _ref3.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 = _destinationGroup.firstTabbableNode;\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    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\n  var checkKey = function checkKey(event) {\n    if (isEscapeEvent(event) && valueOrHandler(config.escapeDeactivates, event) !== false) {\n      event.preventDefault();\n      trap.deactivate();\n      return;\n    }\n    if (config.isKeyForward(event) || config.isKeyBackward(event)) {\n      checkKeyNav(event, config.isKeyBackward(event));\n    }\n  };\n  var checkClick = function checkClick(e) {\n    var target = getActualTarget(e);\n    if (findContainerIndex(target) >= 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', checkKey, {\n      capture: true,\n      passive: false\n    });\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', checkKey, true);\n    return trap;\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      if (onActivate) {\n        onActivate();\n      }\n      var finishActivation = function finishActivation() {\n        if (checkCanFocusTrap) {\n          updateTabbableNodes();\n        }\n        addListeners();\n        if (onPostActivate) {\n          onPostActivate();\n        }\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      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      if (onDeactivate) {\n        onDeactivate();\n      }\n      var finishDeactivation = function finishDeactivation() {\n        delay(function () {\n          if (returnFocus) {\n            tryFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation));\n          }\n          if (onPostDeactivate) {\n            onPostDeactivate();\n          }\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() {\n      if (state.paused || !state.active) {\n        return this;\n      }\n      state.paused = true;\n      removeListeners();\n      return this;\n    },\n    unpause: function unpause() {\n      if (!state.paused || !state.active) {\n        return this;\n      }\n      state.paused = false;\n      updateTabbableNodes();\n      addListeners();\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      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":["hasPassiveEvents","window","passiveTestOptions","passive","addEventListener","removeEventListener","isIosDevice","navigator","platform","test","maxTouchPoints","locks","documentListenerAdded","initialClientY","previousBodyOverflowSetting","previousBodyPosition","previousBodyPaddingRight","allowTouchMove","el","some","lock","options","preventDefault","rawEvent","e","event","target","touches","length","disableBodyScroll","targetElement","concat","arr","Array","isArray","i","arr2","from","_toConsumableArray","requestAnimationFrame","undefined","position","document","body","style","top","left","_window","scrollY","scrollX","innerHeight","setTimeout","bottomBarHeight","_reserveScrollBarGap","reserveScrollBarGap","scrollBarGap","innerWidth","documentElement","clientWidth","computedBodyPaddingRight","parseInt","getComputedStyle","getPropertyValue","paddingRight","overflow","setOverflowHidden","ontouchstart","targetTouches","clientY","ontouchmove","scrollTop","scrollHeight","clientHeight","isTargetElementTotallyScrolled","stopPropagation","handleScroll","console","error","enableBodyScroll","filter","y","x","scrollTo","restorePositionSetting","candidateSelectors","candidateSelector","join","NoElement","Element","matches","prototype","msMatchesSelector","webkitMatchesSelector","getRootNode","element","_element$getRootNode","call","ownerDocument","isInert","node","lookUp","_node$getAttribute","inertAtt","getAttribute","parentNode","getCandidates","includeContainer","candidates","slice","apply","querySelectorAll","unshift","getCandidatesIteratively","elements","elementsToCheck","shift","tagName","assigned","assignedElements","nestedCandidates","children","flatten","push","scopeParent","includes","shadowRoot","getShadowRoot","validShadowRoot","shadowRootFilter","_nestedCandidates","getTabindex","isScope","tabIndex","_node$getAttribute2","attValue","isContentEditable","isNaN","sortOrderedTabbables","a","b","documentOrder","isInput","isZeroArea","_node$getBoundingClie","getBoundingClientRect","width","height","isNodeMatchingSelectorFocusable","disabled","type","isHiddenInput","_ref","displayCheck","visibility","nodeUnderDetails","parentElement","originalNode","rootNode","assignedSlot","host","_nodeRoot","_nodeRootHost","_nodeRootHost$ownerDo","_node$ownerDocument","nodeRoot","nodeRootHost","attached","contains","_nodeRoot2","_nodeRootHost2","_nodeRootHost2$ownerD","isNodeAttached","getClientRects","isHidden","child","isDetailsWithSummary","item","isDisabledFromFieldset","isNodeMatchingSelectorTabbable","isRadio","name","radioSet","radioScope","form","queryRadios","CSS","escape","err","message","checked","nodes","getCheckedRadio","isTabbableRadio","isNonTabbableRadio","isValidShadowRootTabbable","shadowHostNode","sortByOrder","regularTabbables","orderedTabbables","forEach","candidateTabindex","content","sort","reduce","acc","sortable","tabbable","bind","isTabbable","Error","focusableCandidateSelector","isFocusable","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","sym","getOwnPropertyDescriptor","enumerable","_objectSpread2","arguments","source","key","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","obj","value","arg","input","prim","Symbol","toPrimitive","res","hint","TypeError","String","_toPrimitive","_toPropertyKey","configurable","writable","isTabEvent","keyCode","isKeyForward","shiftKey","isKeyBackward","delay","fn","findIndex","idx","every","valueOrHandler","_len","params","_key","getActualTarget","composedPath","internalTrapStack","createFocusTrap","userOptions","trap","doc","trapStack","config","returnFocusOnDeactivate","escapeDeactivates","delayInitialFocus","state","containers","containerGroups","tabbableGroups","nodeFocusedBeforeActivation","mostRecentlyFocusedNode","active","paused","delayInitialFocusTimer","getOption","configOverrideOptions","optionName","configOptionName","findContainerIndex","container","tabbableNodes","find","getNodeForOption","optionValue","_len2","_key2","querySelector","getInitialFocusNode","activeElement","firstTabbableGroup","firstTabbableNode","updateTabbableNodes","map","tabbableOptions","focusableNodes","lastTabbableNode","nextTabbableNode","forward","nodeIdx","n","reverse","group","tryFocus","focus","preventScroll","toLowerCase","select","isSelectableInput","getReturnFocusNode","previousActiveElement","checkPointerDown","clickOutsideDeactivates","deactivate","returnFocus","allowOutsideClick","checkFocusIn","targetContained","Document","stopImmediatePropagation","checkKey","isBackward","destinationNode","containerIndex","containerGroup","startOfGroupIndex","_ref2","destinationGroupIndex","lastOfGroupIndex","_ref3","_destinationGroupIndex","checkKeyNav","checkClick","addListeners","activeTrap","pause","trapIndex","indexOf","splice","activeFocusTraps","capture","removeListeners","activate","activateOptions","this","onActivate","onPostActivate","checkCanFocusTrap","finishActivation","then","deactivateOptions","onDeactivate","onPostDeactivate","checkCanReturnFocus","clearTimeout","unpause","finishDeactivation","updateContainerElements","containerElements","elementsAsArray","Boolean"],"sourceRoot":""}