{"version":3,"sources":["index.umd.js","focus-trap.umd.js","cac.panel.js","cac.openingHours.js"],"names":["global","factory","current","exports","module","define","amd","globalThis","self","tabbable","noConflict","this","getCandidates","el","includeContainer","filter","candidates","isInert","Array","prototype","slice","apply","querySelectorAll","candidateSelector","matches","call","unshift","getCandidatesIteratively","elements","options","elementsToCheck","from","length","shadowRoot","_nestedCandidates","element","shift","tagName","nestedCandidates","assigned","assignedElements","children","flatten","push","scopeParent","includes","getShadowRoot","validShadowRoot","shadowRootFilter","hasTabIndex","node","isNaN","parseInt","getAttribute","isInput","isTabbableRadio","name","queryRadios","radioScope","form","getRootNode","window","CSS","escape","radioSet","err","console","error","message","checked","nodes","i","isZeroArea","width","_node$getBoundingClie","getBoundingClientRect","height","isNodeMatchingSelectorTabbable","isNonTabbableRadio","getTabIndex","isNodeMatchingSelectorFocusable","isValidShadowRootTabbable","shadowHostNode","tabIndex","sortByOrder","regularTabbables","orderedTabbables","forEach","item","isScope","candidateTabindex","getSortOrderTabIndex","documentOrder","content","sort","sortOrderedTabbables","reduce","acc","sortable","concat","candidateSelectors","join","NoElement","Element","msMatchesSelector","webkitMatchesSelector","_element$getRootNode","ownerDocument","lookUp","inertAtt","_node$getAttribute","parentNode","attValue","test","_node$getAttribute2","Error","a","b","isHiddenInput","type","isDetailsWithSummary","some","child","isHidden","_ref","displayCheck","getComputedStyle","visibility","nodeUnderDetails","parentElement","originalNode","rootNode","assignedSlot","host","_node$ownerDocument","nodeRoot","nodeRootHost","_nodeRoot","attached","_nodeRootHost","_nodeRootHost$ownerDo","contains","_nodeRootHost2$ownerD","_nodeRootHost2","_nodeRoot2","getClientRects","isDisabledFromFieldset","disabled","focusableCandidateSelector","focusable","container","bind","isFocusable","isTabbable","Object","defineProperty","value","require","focusTrap","_arrayLikeToArray","r","e","n","_defineProperty","t","Symbol","toPrimitive","String","Number","TypeError","enumerable","configurable","writable","ownKeys","o","keys","getOwnPropertySymbols","getOwnPropertyDescriptor","_objectSpread2","arguments","getOwnPropertyDescriptors","defineProperties","_toConsumableArray","isArray","iterator","toString","constructor","isKeyForward","isTabEvent","shiftKey","isKeyBackward","delay","fn","setTimeout","findIndex","arr","idx","every","valueOrHandler","_len","params","_key","getActualTarget","event","target","composedPath","activeFocusTraps","trapStack","trap","activeTrap","pause","trapIndex","indexOf","splice","unpause","key","keyCode","internalTrapStack","createFocusTrap","userOptions","getOption","configOverrideOptions","optionName","configOptionName","undefined","config","updateTabbableNodes","state","containerGroups","containers","map","tabbableNodes","tabbableOptions","focusableNodes","firstTabbableNode","lastTabbableNode","firstDomTabbableNode","find","lastDomTabbableNode","reverse","posTabIndexesFound","nextTabbableNode","forward","nodeIdx","tabbableGroups","group","getNodeForOption","g","getReturnFocusNode","previousActiveElement","addListeners","active","delayInitialFocusTimer","delayInitialFocus","_tryFocus","getInitialFocusNode","doc","addEventListener","checkFocusIn","checkPointerDown","capture","passive","checkClick","checkTabKey","checkEscapeKey","removeListeners","removeEventListener","updateObservedNodes","mutationObserver","disconnect","paused","observe","subtree","childList","document","returnFocusOnDeactivate","escapeDeactivates","nodeFocusedBeforeActivation","mostRecentlyFocusedNode","recentNavEvent","findContainerIndex","_ref2","_ref2$hasFallback","hasFallback","_ref2$params","optionValue","querySelector","firstTabbableGroup","activeElement","_getActiveElement","focus","preventScroll","toLowerCase","select","findNextNavNode","_ref3","containerGroup","_destinationGroupIndex","_ref3$isBackward","isBackward","destinationNode","containerIndex","startOfGroupIndex","_ref4","destinationGroupIndex","destinationGroup","lastOfGroupIndex","_ref5","_destinationGroup","clickOutsideDeactivates","deactivate","returnFocus","allowOutsideClick","preventDefault","nextNode","targetContained","Document","stopImmediatePropagation","navAcrossContainers","mruContainerIdx","mruTabIdx","checkKeyNav","MutationObserver","mutations","mutation","removedNodes","activate","activateOptions","onActivate","onPostActivate","checkCanFocusTrap","finishActivation","then","deactivateOptions","onDeactivate","onPostDeactivate","checkCanReturnFocus","clearTimeout","finishDeactivation","pauseOptions","onPause","onPostPause","unpauseOptions","onUnpause","onPostUnpause","updateContainerElements","containerElements","elementsAsArray","Boolean","Panel","panel","classList","remove","settings","closeBtns","openBtns","onopen","onclose","instance","onready","dismissible","unobstrusive","initialFocus","fallbackFocus","panelInstance","focusTrapConfig","close","ext","registerCallback","evnt","func","registerOnOpenCallback","registerOnCloseCallback","registerOnReadyCallback","status","open","isOpen","init","_this","handleOpen","dataset","replacing","historyHasState","history","modalOpen","modelName","windowTop","scrollY","style","setProperty","body","add","addEventListeners","replaceState","id","pushState","replaced","removeEventListeners","scrollBehavior","scrollTo","back","handleClose","handleContainerClick","create","entries","val","hasOwnProperty","Reflect","set","openHandler","closeHandler","logPopstate","log","handlePopstate","shouldOpen","PanelEnquiryObject","containerElement","view","img","data","elem","update","src","textContent","description","innerHTML","updateData","scrollRestoration","cac_data","openingHours","panels"],"mappings":"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","file":"panels.min.js","sourcesContent":["/*!\r\n* tabbable 6.2.0\r\n* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE\r\n*/\r\n(function (global, factory) {\r\n  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\r\n  typeof define === 'function' && define.amd ? define(['exports'], factory) :\r\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, (function () {\r\n    var current = global.tabbable;\r\n    var exports = global.tabbable = {};\r\n    factory(exports);\r\n    exports.noConflict = function () { global.tabbable = current; return exports; };\r\n  })());\r\n})(this, (function (exports) { 'use strict';\r\n\r\n  // NOTE: separate `:not()` selectors has broader browser support than the newer\r\n  //  `:not([inert], [inert] *)` (Feb 2023)\r\n  // CAREFUL: JSDom does not support `:not([inert] *)` as a selector; using it causes\r\n  //  the entire query to fail, resulting in no nodes found, which will break a lot\r\n  //  of things... so we have to rely on JS to identify nodes inside an inert container\r\n  var 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])'];\r\n  var candidateSelector = /* #__PURE__ */candidateSelectors.join(',');\r\n  var NoElement = typeof Element === 'undefined';\r\n  var matches = NoElement ? function () {} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;\r\n  var getRootNode = !NoElement && Element.prototype.getRootNode ? function (element) {\r\n    var _element$getRootNode;\r\n    return element === null || element === void 0 ? void 0 : (_element$getRootNode = element.getRootNode) === null || _element$getRootNode === void 0 ? void 0 : _element$getRootNode.call(element);\r\n  } : function (element) {\r\n    return element === null || element === void 0 ? void 0 : element.ownerDocument;\r\n  };\r\n\r\n  /**\r\n   * Determines if a node is inert or in an inert ancestor.\r\n   * @param {Element} [node]\r\n   * @param {boolean} [lookUp] If true and `node` is not inert, looks up at ancestors to\r\n   *  see if any of them are inert. If false, only `node` itself is considered.\r\n   * @returns {boolean} True if inert itself or by way of being in an inert ancestor.\r\n   *  False if `node` is falsy.\r\n   */\r\n  var isInert = function isInert(node, lookUp) {\r\n    var _node$getAttribute;\r\n    if (lookUp === void 0) {\r\n      lookUp = true;\r\n    }\r\n    // CAREFUL: JSDom does not support inert at all, so we can't use the `HTMLElement.inert`\r\n    //  JS API property; we have to check the attribute, which can either be empty or 'true';\r\n    //  if it's `null` (not specified) or 'false', it's an active element\r\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');\r\n    var inert = inertAtt === '' || inertAtt === 'true';\r\n\r\n    // NOTE: this could also be handled with `node.matches('[inert], :is([inert] *)')`\r\n    //  if it weren't for `matches()` not being a function on shadow roots; the following\r\n    //  code works for any kind of node\r\n    // CAREFUL: JSDom does not appear to support certain selectors like `:not([inert] *)`\r\n    //  so it likely would not support `:is([inert] *)` either...\r\n    var result = inert || lookUp && node && isInert(node.parentNode); // recursive\r\n\r\n    return result;\r\n  };\r\n\r\n  /**\r\n   * Determines if a node's content is editable.\r\n   * @param {Element} [node]\r\n   * @returns True if it's content-editable; false if it's not or `node` is falsy.\r\n   */\r\n  var isContentEditable = function isContentEditable(node) {\r\n    var _node$getAttribute2;\r\n    // CAREFUL: JSDom does not support the `HTMLElement.isContentEditable` API so we have\r\n    //  to use the attribute directly to check for this, which can either be empty or 'true';\r\n    //  if it's `null` (not specified) or 'false', it's a non-editable element\r\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');\r\n    return attValue === '' || attValue === 'true';\r\n  };\r\n\r\n  /**\r\n   * @param {Element} el container to check in\r\n   * @param {boolean} includeContainer add container to check\r\n   * @param {(node: Element) => boolean} filter filter candidates\r\n   * @returns {Element[]}\r\n   */\r\n  var getCandidates = function getCandidates(el, includeContainer, filter) {\r\n    // even if `includeContainer=false`, we still have to check it for inertness because\r\n    //  if it's inert, all its children are inert\r\n    if (isInert(el)) {\r\n      return [];\r\n    }\r\n    var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));\r\n    if (includeContainer && matches.call(el, candidateSelector)) {\r\n      candidates.unshift(el);\r\n    }\r\n    candidates = candidates.filter(filter);\r\n    return candidates;\r\n  };\r\n\r\n  /**\r\n   * @callback GetShadowRoot\r\n   * @param {Element} element to check for shadow root\r\n   * @returns {ShadowRoot|boolean} ShadowRoot if available or boolean indicating if a shadowRoot is attached but not available.\r\n   */\r\n\r\n  /**\r\n   * @callback ShadowRootFilter\r\n   * @param {Element} shadowHostNode the element which contains shadow content\r\n   * @returns {boolean} true if a shadow root could potentially contain valid candidates.\r\n   */\r\n\r\n  /**\r\n   * @typedef {Object} CandidateScope\r\n   * @property {Element} scopeParent contains inner candidates\r\n   * @property {Element[]} candidates list of candidates found in the scope parent\r\n   */\r\n\r\n  /**\r\n   * @typedef {Object} IterativeOptions\r\n   * @property {GetShadowRoot|boolean} getShadowRoot true if shadow support is enabled; falsy if not;\r\n   *  if a function, implies shadow support is enabled and either returns the shadow root of an element\r\n   *  or a boolean stating if it has an undisclosed shadow root\r\n   * @property {(node: Element) => boolean} filter filter candidates\r\n   * @property {boolean} flatten if true then result will flatten any CandidateScope into the returned list\r\n   * @property {ShadowRootFilter} shadowRootFilter filter shadow roots;\r\n   */\r\n\r\n  /**\r\n   * @param {Element[]} elements list of element containers to match candidates from\r\n   * @param {boolean} includeContainer add container list to check\r\n   * @param {IterativeOptions} options\r\n   * @returns {Array.<Element|CandidateScope>}\r\n   */\r\n  var getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {\r\n    var candidates = [];\r\n    var elementsToCheck = Array.from(elements);\r\n    while (elementsToCheck.length) {\r\n      var element = elementsToCheck.shift();\r\n      if (isInert(element, false)) {\r\n        // no need to look up since we're drilling down\r\n        // anything inside this container will also be inert\r\n        continue;\r\n      }\r\n      if (element.tagName === 'SLOT') {\r\n        // add shadow dom slot scope (slot itself cannot be focusable)\r\n        var assigned = element.assignedElements();\r\n        var content = assigned.length ? assigned : element.children;\r\n        var nestedCandidates = getCandidatesIteratively(content, true, options);\r\n        if (options.flatten) {\r\n          candidates.push.apply(candidates, nestedCandidates);\r\n        } else {\r\n          candidates.push({\r\n            scopeParent: element,\r\n            candidates: nestedCandidates\r\n          });\r\n        }\r\n      } else {\r\n        // check candidate element\r\n        var validCandidate = matches.call(element, candidateSelector);\r\n        if (validCandidate && options.filter(element) && (includeContainer || !elements.includes(element))) {\r\n          candidates.push(element);\r\n        }\r\n\r\n        // iterate over shadow content if possible\r\n        var shadowRoot = element.shadowRoot ||\r\n        // check for an undisclosed shadow\r\n        typeof options.getShadowRoot === 'function' && options.getShadowRoot(element);\r\n\r\n        // no inert look up because we're already drilling down and checking for inertness\r\n        //  on the way down, so all containers to this root node should have already been\r\n        //  vetted as non-inert\r\n        var validShadowRoot = !isInert(shadowRoot, false) && (!options.shadowRootFilter || options.shadowRootFilter(element));\r\n        if (shadowRoot && validShadowRoot) {\r\n          // add shadow dom scope IIF a shadow root node was given; otherwise, an undisclosed\r\n          //  shadow exists, so look at light dom children as fallback BUT create a scope for any\r\n          //  child candidates found because they're likely slotted elements (elements that are\r\n          //  children of the web component element (which has the shadow), in the light dom, but\r\n          //  slotted somewhere _inside_ the undisclosed shadow) -- the scope is created below,\r\n          //  _after_ we return from this recursive call\r\n          var _nestedCandidates = getCandidatesIteratively(shadowRoot === true ? element.children : shadowRoot.children, true, options);\r\n          if (options.flatten) {\r\n            candidates.push.apply(candidates, _nestedCandidates);\r\n          } else {\r\n            candidates.push({\r\n              scopeParent: element,\r\n              candidates: _nestedCandidates\r\n            });\r\n          }\r\n        } else {\r\n          // there's not shadow so just dig into the element's (light dom) children\r\n          //  __without__ giving the element special scope treatment\r\n          elementsToCheck.unshift.apply(elementsToCheck, element.children);\r\n        }\r\n      }\r\n    }\r\n    return candidates;\r\n  };\r\n\r\n  /**\r\n   * @private\r\n   * Determines if the node has an explicitly specified `tabindex` attribute.\r\n   * @param {HTMLElement} node\r\n   * @returns {boolean} True if so; false if not.\r\n   */\r\n  var hasTabIndex = function hasTabIndex(node) {\r\n    return !isNaN(parseInt(node.getAttribute('tabindex'), 10));\r\n  };\r\n\r\n  /**\r\n   * Determine the tab index of a given node.\r\n   * @param {HTMLElement} node\r\n   * @returns {number} Tab order (negative, 0, or positive number).\r\n   * @throws {Error} If `node` is falsy.\r\n   */\r\n  var getTabIndex = function getTabIndex(node) {\r\n    if (!node) {\r\n      throw new Error('No node provided');\r\n    }\r\n    if (node.tabIndex < 0) {\r\n      // in Chrome, <details/>, <audio controls/> and <video controls/> elements get a default\r\n      // `tabIndex` of -1 when the 'tabindex' attribute isn't specified in the DOM,\r\n      // yet they are still part of the regular tab order; in FF, they get a default\r\n      // `tabIndex` of 0; since Chrome still puts those elements in the regular tab\r\n      // order, consider their tab index to be 0.\r\n      // Also browsers do not return `tabIndex` correctly for contentEditable nodes;\r\n      // so if they don't have a tabindex attribute specifically set, assume it's 0.\r\n      if ((/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || isContentEditable(node)) && !hasTabIndex(node)) {\r\n        return 0;\r\n      }\r\n    }\r\n    return node.tabIndex;\r\n  };\r\n\r\n  /**\r\n   * Determine the tab index of a given node __for sort order purposes__.\r\n   * @param {HTMLElement} node\r\n   * @param {boolean} [isScope] True for a custom element with shadow root or slot that, by default,\r\n   *  has tabIndex -1, but needs to be sorted by document order in order for its content to be\r\n   *  inserted into the correct sort position.\r\n   * @returns {number} Tab order (negative, 0, or positive number).\r\n   */\r\n  var getSortOrderTabIndex = function getSortOrderTabIndex(node, isScope) {\r\n    var tabIndex = getTabIndex(node);\r\n    if (tabIndex < 0 && isScope && !hasTabIndex(node)) {\r\n      return 0;\r\n    }\r\n    return tabIndex;\r\n  };\r\n  var sortOrderedTabbables = function sortOrderedTabbables(a, b) {\r\n    return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;\r\n  };\r\n  var isInput = function isInput(node) {\r\n    return node.tagName === 'INPUT';\r\n  };\r\n  var isHiddenInput = function isHiddenInput(node) {\r\n    return isInput(node) && node.type === 'hidden';\r\n  };\r\n  var isDetailsWithSummary = function isDetailsWithSummary(node) {\r\n    var r = node.tagName === 'DETAILS' && Array.prototype.slice.apply(node.children).some(function (child) {\r\n      return child.tagName === 'SUMMARY';\r\n    });\r\n    return r;\r\n  };\r\n  var getCheckedRadio = function getCheckedRadio(nodes, form) {\r\n    for (var i = 0; i < nodes.length; i++) {\r\n      if (nodes[i].checked && nodes[i].form === form) {\r\n        return nodes[i];\r\n      }\r\n    }\r\n  };\r\n  var isTabbableRadio = function isTabbableRadio(node) {\r\n    if (!node.name) {\r\n      return true;\r\n    }\r\n    var radioScope = node.form || getRootNode(node);\r\n    var queryRadios = function queryRadios(name) {\r\n      return radioScope.querySelectorAll('input[type=\"radio\"][name=\"' + name + '\"]');\r\n    };\r\n    var radioSet;\r\n    if (typeof window !== 'undefined' && typeof window.CSS !== 'undefined' && typeof window.CSS.escape === 'function') {\r\n      radioSet = queryRadios(window.CSS.escape(node.name));\r\n    } else {\r\n      try {\r\n        radioSet = queryRadios(node.name);\r\n      } catch (err) {\r\n        // eslint-disable-next-line no-console\r\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);\r\n        return false;\r\n      }\r\n    }\r\n    var checked = getCheckedRadio(radioSet, node.form);\r\n    return !checked || checked === node;\r\n  };\r\n  var isRadio = function isRadio(node) {\r\n    return isInput(node) && node.type === 'radio';\r\n  };\r\n  var isNonTabbableRadio = function isNonTabbableRadio(node) {\r\n    return isRadio(node) && !isTabbableRadio(node);\r\n  };\r\n\r\n  // determines if a node is ultimately attached to the window's document\r\n  var isNodeAttached = function isNodeAttached(node) {\r\n    var _nodeRoot;\r\n    // The root node is the shadow root if the node is in a shadow DOM; some document otherwise\r\n    //  (but NOT _the_ document; see second 'If' comment below for more).\r\n    // If rootNode is shadow root, it'll have a host, which is the element to which the shadow\r\n    //  is attached, and the one we need to check if it's in the document or not (because the\r\n    //  shadow, and all nodes it contains, is never considered in the document since shadows\r\n    //  behave like self-contained DOMs; but if the shadow's HOST, which is part of the document,\r\n    //  is hidden, or is not in the document itself but is detached, it will affect the shadow's\r\n    //  visibility, including all the nodes it contains). The host could be any normal node,\r\n    //  or a custom element (i.e. web component). Either way, that's the one that is considered\r\n    //  part of the document, not the shadow root, nor any of its children (i.e. the node being\r\n    //  tested).\r\n    // To further complicate things, we have to look all the way up until we find a shadow HOST\r\n    //  that is attached (or find none) because the node might be in nested shadows...\r\n    // If rootNode is not a shadow root, it won't have a host, and so rootNode should be the\r\n    //  document (per the docs) and while it's a Document-type object, that document does not\r\n    //  appear to be the same as the node's `ownerDocument` for some reason, so it's safer\r\n    //  to ignore the rootNode at this point, and use `node.ownerDocument`. Otherwise,\r\n    //  using `rootNode.contains(node)` will _always_ be true we'll get false-positives when\r\n    //  node is actually detached.\r\n    // NOTE: If `nodeRootHost` or `node` happens to be the `document` itself (which is possible\r\n    //  if a tabbable/focusable node was quickly added to the DOM, focused, and then removed\r\n    //  from the DOM as in https://github.com/focus-trap/focus-trap-react/issues/905), then\r\n    //  `ownerDocument` will be `null`, hence the optional chaining on it.\r\n    var nodeRoot = node && getRootNode(node);\r\n    var nodeRootHost = (_nodeRoot = nodeRoot) === null || _nodeRoot === void 0 ? void 0 : _nodeRoot.host;\r\n\r\n    // in some cases, a detached node will return itself as the root instead of a document or\r\n    //  shadow root object, in which case, we shouldn't try to look further up the host chain\r\n    var attached = false;\r\n    if (nodeRoot && nodeRoot !== node) {\r\n      var _nodeRootHost, _nodeRootHost$ownerDo, _node$ownerDocument;\r\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));\r\n      while (!attached && nodeRootHost) {\r\n        var _nodeRoot2, _nodeRootHost2, _nodeRootHost2$ownerD;\r\n        // since it's not attached and we have a root host, the node MUST be in a nested shadow DOM,\r\n        //  which means we need to get the host's host and check if that parent host is contained\r\n        //  in (i.e. attached to) the document\r\n        nodeRoot = getRootNode(nodeRootHost);\r\n        nodeRootHost = (_nodeRoot2 = nodeRoot) === null || _nodeRoot2 === void 0 ? void 0 : _nodeRoot2.host;\r\n        attached = !!((_nodeRootHost2 = nodeRootHost) !== null && _nodeRootHost2 !== void 0 && (_nodeRootHost2$ownerD = _nodeRootHost2.ownerDocument) !== null && _nodeRootHost2$ownerD !== void 0 && _nodeRootHost2$ownerD.contains(nodeRootHost));\r\n      }\r\n    }\r\n    return attached;\r\n  };\r\n  var isZeroArea = function isZeroArea(node) {\r\n    var _node$getBoundingClie = node.getBoundingClientRect(),\r\n      width = _node$getBoundingClie.width,\r\n      height = _node$getBoundingClie.height;\r\n    return width === 0 && height === 0;\r\n  };\r\n  var isHidden = function isHidden(node, _ref) {\r\n    var displayCheck = _ref.displayCheck,\r\n      getShadowRoot = _ref.getShadowRoot;\r\n    // NOTE: visibility will be `undefined` if node is detached from the document\r\n    //  (see notes about this further down), which means we will consider it visible\r\n    //  (this is legacy behavior from a very long way back)\r\n    // NOTE: we check this regardless of `displayCheck=\"none\"` because this is a\r\n    //  _visibility_ check, not a _display_ check\r\n    if (getComputedStyle(node).visibility === 'hidden') {\r\n      return true;\r\n    }\r\n    var isDirectSummary = matches.call(node, 'details>summary:first-of-type');\r\n    var nodeUnderDetails = isDirectSummary ? node.parentElement : node;\r\n    if (matches.call(nodeUnderDetails, 'details:not([open]) *')) {\r\n      return true;\r\n    }\r\n    if (!displayCheck || displayCheck === 'full' || displayCheck === 'legacy-full') {\r\n      if (typeof getShadowRoot === 'function') {\r\n        // figure out if we should consider the node to be in an undisclosed shadow and use the\r\n        //  'non-zero-area' fallback\r\n        var originalNode = node;\r\n        while (node) {\r\n          var parentElement = node.parentElement;\r\n          var rootNode = getRootNode(node);\r\n          if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true // check if there's an undisclosed shadow\r\n          ) {\r\n            // node has an undisclosed shadow which means we can only treat it as a black box, so we\r\n            //  fall back to a non-zero-area test\r\n            return isZeroArea(node);\r\n          } else if (node.assignedSlot) {\r\n            // iterate up slot\r\n            node = node.assignedSlot;\r\n          } else if (!parentElement && rootNode !== node.ownerDocument) {\r\n            // cross shadow boundary\r\n            node = rootNode.host;\r\n          } else {\r\n            // iterate up normal dom\r\n            node = parentElement;\r\n          }\r\n        }\r\n        node = originalNode;\r\n      }\r\n      // else, `getShadowRoot` might be true, but all that does is enable shadow DOM support\r\n      //  (i.e. it does not also presume that all nodes might have undisclosed shadows); or\r\n      //  it might be a falsy value, which means shadow DOM support is disabled\r\n\r\n      // Since we didn't find it sitting in an undisclosed shadow (or shadows are disabled)\r\n      //  now we can just test to see if it would normally be visible or not, provided it's\r\n      //  attached to the main document.\r\n      // NOTE: We must consider case where node is inside a shadow DOM and given directly to\r\n      //  `isTabbable()` or `isFocusable()` -- regardless of `getShadowRoot` option setting.\r\n\r\n      if (isNodeAttached(node)) {\r\n        // this works wherever the node is: if there's at least one client rect, it's\r\n        //  somehow displayed; it also covers the CSS 'display: contents' case where the\r\n        //  node itself is hidden in place of its contents; and there's no need to search\r\n        //  up the hierarchy either\r\n        return !node.getClientRects().length;\r\n      }\r\n\r\n      // Else, the node isn't attached to the document, which means the `getClientRects()`\r\n      //  API will __always__ return zero rects (this can happen, for example, if React\r\n      //  is used to render nodes onto a detached tree, as confirmed in this thread:\r\n      //  https://github.com/facebook/react/issues/9117#issuecomment-284228870)\r\n      //\r\n      // It also means that even window.getComputedStyle(node).display will return `undefined`\r\n      //  because styles are only computed for nodes that are in the document.\r\n      //\r\n      // NOTE: THIS HAS BEEN THE CASE FOR YEARS. It is not new, nor is it caused by tabbable\r\n      //  somehow. Though it was never stated officially, anyone who has ever used tabbable\r\n      //  APIs on nodes in detached containers has actually implicitly used tabbable in what\r\n      //  was later (as of v5.2.0 on Apr 9, 2021) called `displayCheck=\"none\"` mode -- essentially\r\n      //  considering __everything__ to be visible because of the innability to determine styles.\r\n      //\r\n      // v6.0.0: As of this major release, the default 'full' option __no longer treats detached\r\n      //  nodes as visible with the 'none' fallback.__\r\n      if (displayCheck !== 'legacy-full') {\r\n        return true; // hidden\r\n      }\r\n      // else, fallback to 'none' mode and consider the node visible\r\n    } else if (displayCheck === 'non-zero-area') {\r\n      // NOTE: Even though this tests that the node's client rect is non-zero to determine\r\n      //  whether it's displayed, and that a detached node will __always__ have a zero-area\r\n      //  client rect, we don't special-case for whether the node is attached or not. In\r\n      //  this mode, we do want to consider nodes that have a zero area to be hidden at all\r\n      //  times, and that includes attached or not.\r\n      return isZeroArea(node);\r\n    }\r\n\r\n    // visible, as far as we can tell, or per current `displayCheck=none` mode, we assume\r\n    //  it's visible\r\n    return false;\r\n  };\r\n\r\n  // form fields (nested) inside a disabled fieldset are not focusable/tabbable\r\n  //  unless they are in the _first_ <legend> element of the top-most disabled\r\n  //  fieldset\r\n  var isDisabledFromFieldset = function isDisabledFromFieldset(node) {\r\n    if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {\r\n      var parentNode = node.parentElement;\r\n      // check if `node` is contained in a disabled <fieldset>\r\n      while (parentNode) {\r\n        if (parentNode.tagName === 'FIELDSET' && parentNode.disabled) {\r\n          // look for the first <legend> among the children of the disabled <fieldset>\r\n          for (var i = 0; i < parentNode.children.length; i++) {\r\n            var child = parentNode.children.item(i);\r\n            // when the first <legend> (in document order) is found\r\n            if (child.tagName === 'LEGEND') {\r\n              // if its parent <fieldset> is not nested in another disabled <fieldset>,\r\n              // return whether `node` is a descendant of its first <legend>\r\n              return matches.call(parentNode, 'fieldset[disabled] *') ? true : !child.contains(node);\r\n            }\r\n          }\r\n          // the disabled <fieldset> containing `node` has no <legend>\r\n          return true;\r\n        }\r\n        parentNode = parentNode.parentElement;\r\n      }\r\n    }\r\n\r\n    // else, node's tabbable/focusable state should not be affected by a fieldset's\r\n    //  enabled/disabled state\r\n    return false;\r\n  };\r\n  var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable(options, node) {\r\n    if (node.disabled ||\r\n    // we must do an inert look up to filter out any elements inside an inert ancestor\r\n    //  because we're limited in the type of selectors we can use in JSDom (see related\r\n    //  note related to `candidateSelectors`)\r\n    isInert(node) || isHiddenInput(node) || isHidden(node, options) ||\r\n    // For a details element with a summary, the summary element gets the focus\r\n    isDetailsWithSummary(node) || isDisabledFromFieldset(node)) {\r\n      return false;\r\n    }\r\n    return true;\r\n  };\r\n  var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable(options, node) {\r\n    if (isNonTabbableRadio(node) || getTabIndex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) {\r\n      return false;\r\n    }\r\n    return true;\r\n  };\r\n  var isValidShadowRootTabbable = function isValidShadowRootTabbable(shadowHostNode) {\r\n    var tabIndex = parseInt(shadowHostNode.getAttribute('tabindex'), 10);\r\n    if (isNaN(tabIndex) || tabIndex >= 0) {\r\n      return true;\r\n    }\r\n    // If a custom element has an explicit negative tabindex,\r\n    // browsers will not allow tab targeting said element's children.\r\n    return false;\r\n  };\r\n\r\n  /**\r\n   * @param {Array.<Element|CandidateScope>} candidates\r\n   * @returns Element[]\r\n   */\r\n  var sortByOrder = function sortByOrder(candidates) {\r\n    var regularTabbables = [];\r\n    var orderedTabbables = [];\r\n    candidates.forEach(function (item, i) {\r\n      var isScope = !!item.scopeParent;\r\n      var element = isScope ? item.scopeParent : item;\r\n      var candidateTabindex = getSortOrderTabIndex(element, isScope);\r\n      var elements = isScope ? sortByOrder(item.candidates) : element;\r\n      if (candidateTabindex === 0) {\r\n        isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element);\r\n      } else {\r\n        orderedTabbables.push({\r\n          documentOrder: i,\r\n          tabIndex: candidateTabindex,\r\n          item: item,\r\n          isScope: isScope,\r\n          content: elements\r\n        });\r\n      }\r\n    });\r\n    return orderedTabbables.sort(sortOrderedTabbables).reduce(function (acc, sortable) {\r\n      sortable.isScope ? acc.push.apply(acc, sortable.content) : acc.push(sortable.content);\r\n      return acc;\r\n    }, []).concat(regularTabbables);\r\n  };\r\n  var tabbable = function tabbable(container, options) {\r\n    options = options || {};\r\n    var candidates;\r\n    if (options.getShadowRoot) {\r\n      candidates = getCandidatesIteratively([container], options.includeContainer, {\r\n        filter: isNodeMatchingSelectorTabbable.bind(null, options),\r\n        flatten: false,\r\n        getShadowRoot: options.getShadowRoot,\r\n        shadowRootFilter: isValidShadowRootTabbable\r\n      });\r\n    } else {\r\n      candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));\r\n    }\r\n    return sortByOrder(candidates);\r\n  };\r\n  var focusable = function focusable(container, options) {\r\n    options = options || {};\r\n    var candidates;\r\n    if (options.getShadowRoot) {\r\n      candidates = getCandidatesIteratively([container], options.includeContainer, {\r\n        filter: isNodeMatchingSelectorFocusable.bind(null, options),\r\n        flatten: true,\r\n        getShadowRoot: options.getShadowRoot\r\n      });\r\n    } else {\r\n      candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));\r\n    }\r\n    return candidates;\r\n  };\r\n  var isTabbable = function isTabbable(node, options) {\r\n    options = options || {};\r\n    if (!node) {\r\n      throw new Error('No node provided');\r\n    }\r\n    if (matches.call(node, candidateSelector) === false) {\r\n      return false;\r\n    }\r\n    return isNodeMatchingSelectorTabbable(options, node);\r\n  };\r\n  var focusableCandidateSelector = /* #__PURE__ */candidateSelectors.concat('iframe').join(',');\r\n  var isFocusable = function isFocusable(node, options) {\r\n    options = options || {};\r\n    if (!node) {\r\n      throw new Error('No node provided');\r\n    }\r\n    if (matches.call(node, focusableCandidateSelector) === false) {\r\n      return false;\r\n    }\r\n    return isNodeMatchingSelectorFocusable(options, node);\r\n  };\r\n\r\n  exports.focusable = focusable;\r\n  exports.getTabIndex = getTabIndex;\r\n  exports.isFocusable = isFocusable;\r\n  exports.isTabbable = isTabbable;\r\n  exports.tabbable = tabbable;\r\n\r\n  Object.defineProperty(exports, '__esModule', { value: true });\r\n\r\n}));\r\n//# sourceMappingURL=index.umd.js.map\r\n","/*!\r\n* focus-trap 7.6.1\r\n* @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE\r\n*/\r\n(function (global, factory) {\r\n  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('tabbable')) :\r\n  typeof define === 'function' && define.amd ? define(['exports', 'tabbable'], factory) :\r\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, (function () {\r\n    var current = global.focusTrap;\r\n    var exports = global.focusTrap = {};\r\n    factory(exports, global.tabbable);\r\n    exports.noConflict = function () { global.focusTrap = current; return exports; };\r\n  })());\r\n})(this, (function (exports, tabbable) { 'use strict';\r\n\r\n  function _arrayLikeToArray(r, a) {\r\n    (null == a || a > r.length) && (a = r.length);\r\n    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];\r\n    return n;\r\n  }\r\n  function _arrayWithoutHoles(r) {\r\n    if (Array.isArray(r)) return _arrayLikeToArray(r);\r\n  }\r\n  function _defineProperty(e, r, t) {\r\n    return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {\r\n      value: t,\r\n      enumerable: !0,\r\n      configurable: !0,\r\n      writable: !0\r\n    }) : e[r] = t, e;\r\n  }\r\n  function _iterableToArray(r) {\r\n    if (\"undefined\" != typeof Symbol && null != r[Symbol.iterator] || null != r[\"@@iterator\"]) return Array.from(r);\r\n  }\r\n  function _nonIterableSpread() {\r\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.\");\r\n  }\r\n  function ownKeys(e, r) {\r\n    var t = Object.keys(e);\r\n    if (Object.getOwnPropertySymbols) {\r\n      var o = Object.getOwnPropertySymbols(e);\r\n      r && (o = o.filter(function (r) {\r\n        return Object.getOwnPropertyDescriptor(e, r).enumerable;\r\n      })), t.push.apply(t, o);\r\n    }\r\n    return t;\r\n  }\r\n  function _objectSpread2(e) {\r\n    for (var r = 1; r < arguments.length; r++) {\r\n      var t = null != arguments[r] ? arguments[r] : {};\r\n      r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {\r\n        _defineProperty(e, r, t[r]);\r\n      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {\r\n        Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));\r\n      });\r\n    }\r\n    return e;\r\n  }\r\n  function _toConsumableArray(r) {\r\n    return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();\r\n  }\r\n  function _toPrimitive(t, r) {\r\n    if (\"object\" != typeof t || !t) return t;\r\n    var e = t[Symbol.toPrimitive];\r\n    if (void 0 !== e) {\r\n      var i = e.call(t, r || \"default\");\r\n      if (\"object\" != typeof i) return i;\r\n      throw new TypeError(\"@@toPrimitive must return a primitive value.\");\r\n    }\r\n    return (\"string\" === r ? String : Number)(t);\r\n  }\r\n  function _toPropertyKey(t) {\r\n    var i = _toPrimitive(t, \"string\");\r\n    return \"symbol\" == typeof i ? i : i + \"\";\r\n  }\r\n  function _unsupportedIterableToArray(r, a) {\r\n    if (r) {\r\n      if (\"string\" == typeof r) return _arrayLikeToArray(r, a);\r\n      var t = {}.toString.call(r).slice(8, -1);\r\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) : void 0;\r\n    }\r\n  }\r\n\r\n  var activeFocusTraps = {\r\n    activateTrap: function activateTrap(trapStack, trap) {\r\n      if (trapStack.length > 0) {\r\n        var activeTrap = trapStack[trapStack.length - 1];\r\n        if (activeTrap !== trap) {\r\n          activeTrap.pause();\r\n        }\r\n      }\r\n      var trapIndex = trapStack.indexOf(trap);\r\n      if (trapIndex === -1) {\r\n        trapStack.push(trap);\r\n      } else {\r\n        // move this existing trap to the front of the queue\r\n        trapStack.splice(trapIndex, 1);\r\n        trapStack.push(trap);\r\n      }\r\n    },\r\n    deactivateTrap: function deactivateTrap(trapStack, trap) {\r\n      var trapIndex = trapStack.indexOf(trap);\r\n      if (trapIndex !== -1) {\r\n        trapStack.splice(trapIndex, 1);\r\n      }\r\n      if (trapStack.length > 0) {\r\n        trapStack[trapStack.length - 1].unpause();\r\n      }\r\n    }\r\n  };\r\n  var isSelectableInput = function isSelectableInput(node) {\r\n    return node.tagName && node.tagName.toLowerCase() === 'input' && typeof node.select === 'function';\r\n  };\r\n  var isEscapeEvent = function isEscapeEvent(e) {\r\n    return (e === null || e === void 0 ? void 0 : e.key) === 'Escape' || (e === null || e === void 0 ? void 0 : e.key) === 'Esc' || (e === null || e === void 0 ? void 0 : e.keyCode) === 27;\r\n  };\r\n  var isTabEvent = function isTabEvent(e) {\r\n    return (e === null || e === void 0 ? void 0 : e.key) === 'Tab' || (e === null || e === void 0 ? void 0 : e.keyCode) === 9;\r\n  };\r\n\r\n  // checks for TAB by default\r\n  var isKeyForward = function isKeyForward(e) {\r\n    return isTabEvent(e) && !e.shiftKey;\r\n  };\r\n\r\n  // checks for SHIFT+TAB by default\r\n  var isKeyBackward = function isKeyBackward(e) {\r\n    return isTabEvent(e) && e.shiftKey;\r\n  };\r\n  var delay = function delay(fn) {\r\n    return setTimeout(fn, 0);\r\n  };\r\n\r\n  // Array.find/findIndex() are not supported on IE; this replicates enough\r\n  //  of Array.findIndex() for our needs\r\n  var findIndex = function findIndex(arr, fn) {\r\n    var idx = -1;\r\n    arr.every(function (value, i) {\r\n      if (fn(value)) {\r\n        idx = i;\r\n        return false; // break\r\n      }\r\n      return true; // next\r\n    });\r\n    return idx;\r\n  };\r\n\r\n  /**\r\n   * Get an option's value when it could be a plain value, or a handler that provides\r\n   *  the value.\r\n   * @param {*} value Option's value to check.\r\n   * @param {...*} [params] Any parameters to pass to the handler, if `value` is a function.\r\n   * @returns {*} The `value`, or the handler's returned value.\r\n   */\r\n  var valueOrHandler = function valueOrHandler(value) {\r\n    for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\r\n      params[_key - 1] = arguments[_key];\r\n    }\r\n    return typeof value === 'function' ? value.apply(void 0, params) : value;\r\n  };\r\n  var getActualTarget = function getActualTarget(event) {\r\n    // NOTE: If the trap is _inside_ a shadow DOM, event.target will always be the\r\n    //  shadow host. However, event.target.composedPath() will be an array of\r\n    //  nodes \"clicked\" from inner-most (the actual element inside the shadow) to\r\n    //  outer-most (the host HTML document). If we have access to composedPath(),\r\n    //  then use its first element; otherwise, fall back to event.target (and\r\n    //  this only works for an _open_ shadow DOM; otherwise,\r\n    //  composedPath()[0] === event.target always).\r\n    return event.target.shadowRoot && typeof event.composedPath === 'function' ? event.composedPath()[0] : event.target;\r\n  };\r\n\r\n  // NOTE: this must be _outside_ `createFocusTrap()` to make sure all traps in this\r\n  //  current instance use the same stack if `userOptions.trapStack` isn't specified\r\n  var internalTrapStack = [];\r\n  var createFocusTrap = function createFocusTrap(elements, userOptions) {\r\n    // SSR: a live trap shouldn't be created in this type of environment so this\r\n    //  should be safe code to execute if the `document` option isn't specified\r\n    var doc = (userOptions === null || userOptions === void 0 ? void 0 : userOptions.document) || document;\r\n    var trapStack = (userOptions === null || userOptions === void 0 ? void 0 : userOptions.trapStack) || internalTrapStack;\r\n    var config = _objectSpread2({\r\n      returnFocusOnDeactivate: true,\r\n      escapeDeactivates: true,\r\n      delayInitialFocus: true,\r\n      isKeyForward: isKeyForward,\r\n      isKeyBackward: isKeyBackward\r\n    }, userOptions);\r\n    var state = {\r\n      // containers given to createFocusTrap()\r\n      // @type {Array<HTMLElement>}\r\n      containers: [],\r\n      // list of objects identifying tabbable nodes in `containers` in the trap\r\n      // NOTE: it's possible that a group has no tabbable nodes if nodes get removed while the trap\r\n      //  is active, but the trap should never get to a state where there isn't at least one group\r\n      //  with at least one tabbable node in it (that would lead to an error condition that would\r\n      //  result in an error being thrown)\r\n      // @type {Array<{\r\n      //   container: HTMLElement,\r\n      //   tabbableNodes: Array<HTMLElement>, // empty if none\r\n      //   focusableNodes: Array<HTMLElement>, // empty if none\r\n      //   posTabIndexesFound: boolean,\r\n      //   firstTabbableNode: HTMLElement|undefined,\r\n      //   lastTabbableNode: HTMLElement|undefined,\r\n      //   firstDomTabbableNode: HTMLElement|undefined,\r\n      //   lastDomTabbableNode: HTMLElement|undefined,\r\n      //   nextTabbableNode: (node: HTMLElement, forward: boolean) => HTMLElement|undefined\r\n      // }>}\r\n      containerGroups: [],\r\n      // same order/length as `containers` list\r\n\r\n      // references to objects in `containerGroups`, but only those that actually have\r\n      //  tabbable nodes in them\r\n      // NOTE: same order as `containers` and `containerGroups`, but __not necessarily__\r\n      //  the same length\r\n      tabbableGroups: [],\r\n      nodeFocusedBeforeActivation: null,\r\n      mostRecentlyFocusedNode: null,\r\n      active: false,\r\n      paused: false,\r\n      // timer ID for when delayInitialFocus is true and initial focus in this trap\r\n      //  has been delayed during activation\r\n      delayInitialFocusTimer: undefined,\r\n      // the most recent KeyboardEvent for the configured nav key (typically [SHIFT+]TAB), if any\r\n      recentNavEvent: undefined\r\n    };\r\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\r\n\r\n    /**\r\n     * Gets a configuration option value.\r\n     * @param {Object|undefined} configOverrideOptions If true, and option is defined in this set,\r\n     *  value will be taken from this object. Otherwise, value will be taken from base configuration.\r\n     * @param {string} optionName Name of the option whose value is sought.\r\n     * @param {string|undefined} [configOptionName] Name of option to use __instead of__ `optionName`\r\n     *  IIF `configOverrideOptions` is not defined. Otherwise, `optionName` is used.\r\n     */\r\n    var getOption = function getOption(configOverrideOptions, optionName, configOptionName) {\r\n      return configOverrideOptions && configOverrideOptions[optionName] !== undefined ? configOverrideOptions[optionName] : config[configOptionName || optionName];\r\n    };\r\n\r\n    /**\r\n     * Finds the index of the container that contains the element.\r\n     * @param {HTMLElement} element\r\n     * @param {Event} [event] If available, and `element` isn't directly found in any container,\r\n     *  the event's composed path is used to see if includes any known trap containers in the\r\n     *  case where the element is inside a Shadow DOM.\r\n     * @returns {number} Index of the container in either `state.containers` or\r\n     *  `state.containerGroups` (the order/length of these lists are the same); -1\r\n     *  if the element isn't found.\r\n     */\r\n    var findContainerIndex = function findContainerIndex(element, event) {\r\n      var composedPath = typeof (event === null || event === void 0 ? void 0 : event.composedPath) === 'function' ? event.composedPath() : undefined;\r\n      // NOTE: search `containerGroups` because it's possible a group contains no tabbable\r\n      //  nodes, but still contains focusable nodes (e.g. if they all have `tabindex=-1`)\r\n      //  and we still need to find the element in there\r\n      return state.containerGroups.findIndex(function (_ref) {\r\n        var container = _ref.container,\r\n          tabbableNodes = _ref.tabbableNodes;\r\n        return container.contains(element) || (// fall back to explicit tabbable search which will take into consideration any\r\n        //  web components if the `tabbableOptions.getShadowRoot` option was used for\r\n        //  the trap, enabling shadow DOM support in tabbable (`Node.contains()` doesn't\r\n        //  look inside web components even if open)\r\n        composedPath === null || composedPath === void 0 ? void 0 : composedPath.includes(container)) || tabbableNodes.find(function (node) {\r\n          return node === element;\r\n        });\r\n      });\r\n    };\r\n\r\n    /**\r\n     * Gets the node for the given option, which is expected to be an option that\r\n     *  can be either a DOM node, a string that is a selector to get a node, `false`\r\n     *  (if a node is explicitly NOT given), or a function that returns any of these\r\n     *  values.\r\n     * @param {string} optionName\r\n     * @param {Object} options\r\n     * @param {boolean} [options.hasFallback] True if the option could be a selector string\r\n     *  and the option allows for a fallback scenario in the case where the selector is\r\n     *  valid but does not match a node (i.e. the queried node doesn't exist in the DOM).\r\n     * @param {Array} [options.params] Params to pass to the option if it's a function.\r\n     * @returns {undefined | null | false | HTMLElement | SVGElement} Returns\r\n     *  `undefined` if the option is not specified; `null` if the option didn't resolve\r\n     *  to a node but `options.hasFallback=true`, `false` if the option resolved to `false`\r\n     *  (node explicitly not given); otherwise, the resolved DOM node.\r\n     * @throws {Error} If the option is set, not `false`, and is not, or does not\r\n     *  resolve to a node, unless the option is a selector string and `options.hasFallback=true`.\r\n     */\r\n    var getNodeForOption = function getNodeForOption(optionName) {\r\n      var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\r\n        _ref2$hasFallback = _ref2.hasFallback,\r\n        hasFallback = _ref2$hasFallback === void 0 ? false : _ref2$hasFallback,\r\n        _ref2$params = _ref2.params,\r\n        params = _ref2$params === void 0 ? [] : _ref2$params;\r\n      var optionValue = config[optionName];\r\n      if (typeof optionValue === 'function') {\r\n        optionValue = optionValue.apply(void 0, _toConsumableArray(params));\r\n      }\r\n      if (optionValue === true) {\r\n        optionValue = undefined; // use default value\r\n      }\r\n      if (!optionValue) {\r\n        if (optionValue === undefined || optionValue === false) {\r\n          return optionValue;\r\n        }\r\n        // else, empty string (invalid), null (invalid), 0 (invalid)\r\n\r\n        throw new Error(\"`\".concat(optionName, \"` was specified but was not a node, or did not return a node\"));\r\n      }\r\n      var node = optionValue; // could be HTMLElement, SVGElement, or non-empty string at this point\r\n\r\n      if (typeof optionValue === 'string') {\r\n        try {\r\n          node = doc.querySelector(optionValue); // resolve to node, or null if fails\r\n        } catch (err) {\r\n          throw new Error(\"`\".concat(optionName, \"` appears to be an invalid selector; error=\\\"\").concat(err.message, \"\\\"\"));\r\n        }\r\n        if (!node) {\r\n          if (!hasFallback) {\r\n            throw new Error(\"`\".concat(optionName, \"` as selector refers to no known node\"));\r\n          }\r\n          // else, `node` MUST be `null` because that's what `Document.querySelector()` returns\r\n          //  if the selector is valid but doesn't match anything\r\n        }\r\n      }\r\n      return node;\r\n    };\r\n    var getInitialFocusNode = function getInitialFocusNode() {\r\n      var node = getNodeForOption('initialFocus', {\r\n        hasFallback: true\r\n      });\r\n\r\n      // false explicitly indicates we want no initialFocus at all\r\n      if (node === false) {\r\n        return false;\r\n      }\r\n      if (node === undefined || node && !tabbable.isFocusable(node, config.tabbableOptions)) {\r\n        // option not specified nor focusable: use fallback options\r\n        if (findContainerIndex(doc.activeElement) >= 0) {\r\n          node = doc.activeElement;\r\n        } else {\r\n          var firstTabbableGroup = state.tabbableGroups[0];\r\n          var firstTabbableNode = firstTabbableGroup && firstTabbableGroup.firstTabbableNode;\r\n\r\n          // NOTE: `fallbackFocus` option function cannot return `false` (not supported)\r\n          node = firstTabbableNode || getNodeForOption('fallbackFocus');\r\n        }\r\n      } else if (node === null) {\r\n        // option is a VALID selector string that doesn't yield a node: use the `fallbackFocus`\r\n        //  option instead of the default behavior when the option isn't specified at all\r\n        node = getNodeForOption('fallbackFocus');\r\n      }\r\n      if (!node) {\r\n        throw new Error('Your focus-trap needs to have at least one focusable element');\r\n      }\r\n      return node;\r\n    };\r\n    var updateTabbableNodes = function updateTabbableNodes() {\r\n      state.containerGroups = state.containers.map(function (container) {\r\n        var tabbableNodes = tabbable.tabbable(container, config.tabbableOptions);\r\n\r\n        // NOTE: if we have tabbable nodes, we must have focusable nodes; focusable nodes\r\n        //  are a superset of tabbable nodes since nodes with negative `tabindex` attributes\r\n        //  are focusable but not tabbable\r\n        var focusableNodes = tabbable.focusable(container, config.tabbableOptions);\r\n        var firstTabbableNode = tabbableNodes.length > 0 ? tabbableNodes[0] : undefined;\r\n        var lastTabbableNode = tabbableNodes.length > 0 ? tabbableNodes[tabbableNodes.length - 1] : undefined;\r\n        var firstDomTabbableNode = focusableNodes.find(function (node) {\r\n          return tabbable.isTabbable(node);\r\n        });\r\n        var lastDomTabbableNode = focusableNodes.slice().reverse().find(function (node) {\r\n          return tabbable.isTabbable(node);\r\n        });\r\n        var posTabIndexesFound = !!tabbableNodes.find(function (node) {\r\n          return tabbable.getTabIndex(node) > 0;\r\n        });\r\n        return {\r\n          container: container,\r\n          tabbableNodes: tabbableNodes,\r\n          focusableNodes: focusableNodes,\r\n          /** True if at least one node with positive `tabindex` was found in this container. */\r\n          posTabIndexesFound: posTabIndexesFound,\r\n          /** First tabbable node in container, __tabindex__ order; `undefined` if none. */\r\n          firstTabbableNode: firstTabbableNode,\r\n          /** Last tabbable node in container, __tabindex__ order; `undefined` if none. */\r\n          lastTabbableNode: lastTabbableNode,\r\n          // NOTE: DOM order is NOT NECESSARILY \"document position\" order, but figuring that out\r\n          //  would require more than just https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition\r\n          //  because that API doesn't work with Shadow DOM as well as it should (@see\r\n          //  https://github.com/whatwg/dom/issues/320) and since this first/last is only needed, so far,\r\n          //  to address an edge case related to positive tabindex support, this seems like a much easier,\r\n          //  \"close enough most of the time\" alternative for positive tabindexes which should generally\r\n          //  be avoided anyway...\r\n          /** First tabbable node in container, __DOM__ order; `undefined` if none. */\r\n          firstDomTabbableNode: firstDomTabbableNode,\r\n          /** Last tabbable node in container, __DOM__ order; `undefined` if none. */\r\n          lastDomTabbableNode: lastDomTabbableNode,\r\n          /**\r\n           * Finds the __tabbable__ node that follows the given node in the specified direction,\r\n           *  in this container, if any.\r\n           * @param {HTMLElement} node\r\n           * @param {boolean} [forward] True if going in forward tab order; false if going\r\n           *  in reverse.\r\n           * @returns {HTMLElement|undefined} The next tabbable node, if any.\r\n           */\r\n          nextTabbableNode: function nextTabbableNode(node) {\r\n            var forward = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\r\n            var nodeIdx = tabbableNodes.indexOf(node);\r\n            if (nodeIdx < 0) {\r\n              // either not tabbable nor focusable, or was focused but not tabbable (negative tabindex):\r\n              //  since `node` should at least have been focusable, we assume that's the case and mimic\r\n              //  what browsers do, which is set focus to the next node in __document position order__,\r\n              //  regardless of positive tabindexes, if any -- and for reasons explained in the NOTE\r\n              //  above related to `firstDomTabbable` and `lastDomTabbable` properties, we fall back to\r\n              //  basic DOM order\r\n              if (forward) {\r\n                return focusableNodes.slice(focusableNodes.indexOf(node) + 1).find(function (el) {\r\n                  return tabbable.isTabbable(el);\r\n                });\r\n              }\r\n              return focusableNodes.slice(0, focusableNodes.indexOf(node)).reverse().find(function (el) {\r\n                return tabbable.isTabbable(el);\r\n              });\r\n            }\r\n            return tabbableNodes[nodeIdx + (forward ? 1 : -1)];\r\n          }\r\n        };\r\n      });\r\n      state.tabbableGroups = state.containerGroups.filter(function (group) {\r\n        return group.tabbableNodes.length > 0;\r\n      });\r\n\r\n      // throw if no groups have tabbable nodes and we don't have a fallback focus node either\r\n      if (state.tabbableGroups.length <= 0 && !getNodeForOption('fallbackFocus') // returning false not supported for this option\r\n      ) {\r\n        throw new Error('Your focus-trap must have at least one container with at least one tabbable node in it at all times');\r\n      }\r\n\r\n      // NOTE: Positive tabindexes are only properly supported in single-container traps because\r\n      //  doing it across multiple containers where tabindexes could be all over the place\r\n      //  would require Tabbable to support multiple containers, would require additional\r\n      //  specialized Shadow DOM support, and would require Tabbable's multi-container support\r\n      //  to look at those containers in document position order rather than user-provided\r\n      //  order (as they are treated in Focus-trap, for legacy reasons). See discussion on\r\n      //  https://github.com/focus-trap/focus-trap/issues/375 for more details.\r\n      if (state.containerGroups.find(function (g) {\r\n        return g.posTabIndexesFound;\r\n      }) && state.containerGroups.length > 1) {\r\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.\");\r\n      }\r\n    };\r\n\r\n    /**\r\n     * Gets the current activeElement. If it's a web-component and has open shadow-root\r\n     * it will recursively search inside shadow roots for the \"true\" activeElement.\r\n     *\r\n     * @param {Document | ShadowRoot} el\r\n     *\r\n     * @returns {HTMLElement} The element that currently has the focus\r\n     **/\r\n    var _getActiveElement = function getActiveElement(el) {\r\n      var activeElement = el.activeElement;\r\n      if (!activeElement) {\r\n        return;\r\n      }\r\n      if (activeElement.shadowRoot && activeElement.shadowRoot.activeElement !== null) {\r\n        return _getActiveElement(activeElement.shadowRoot);\r\n      }\r\n      return activeElement;\r\n    };\r\n    var _tryFocus = function tryFocus(node) {\r\n      if (node === false) {\r\n        return;\r\n      }\r\n      if (node === _getActiveElement(document)) {\r\n        return;\r\n      }\r\n      if (!node || !node.focus) {\r\n        _tryFocus(getInitialFocusNode());\r\n        return;\r\n      }\r\n      node.focus({\r\n        preventScroll: !!config.preventScroll\r\n      });\r\n      // NOTE: focus() API does not trigger focusIn event so set MRU node manually\r\n      state.mostRecentlyFocusedNode = node;\r\n      if (isSelectableInput(node)) {\r\n        node.select();\r\n      }\r\n    };\r\n    var getReturnFocusNode = function getReturnFocusNode(previousActiveElement) {\r\n      var node = getNodeForOption('setReturnFocus', {\r\n        params: [previousActiveElement]\r\n      });\r\n      return node ? node : node === false ? false : previousActiveElement;\r\n    };\r\n\r\n    /**\r\n     * Finds the next node (in either direction) where focus should move according to a\r\n     *  keyboard focus-in event.\r\n     * @param {Object} params\r\n     * @param {Node} [params.target] Known target __from which__ to navigate, if any.\r\n     * @param {KeyboardEvent|FocusEvent} [params.event] Event to use if `target` isn't known (event\r\n     *  will be used to determine the `target`). Ignored if `target` is specified.\r\n     * @param {boolean} [params.isBackward] True if focus should move backward.\r\n     * @returns {Node|undefined} The next node, or `undefined` if a next node couldn't be\r\n     *  determined given the current state of the trap.\r\n     */\r\n    var findNextNavNode = function findNextNavNode(_ref3) {\r\n      var target = _ref3.target,\r\n        event = _ref3.event,\r\n        _ref3$isBackward = _ref3.isBackward,\r\n        isBackward = _ref3$isBackward === void 0 ? false : _ref3$isBackward;\r\n      target = target || getActualTarget(event);\r\n      updateTabbableNodes();\r\n      var destinationNode = null;\r\n      if (state.tabbableGroups.length > 0) {\r\n        // make sure the target is actually contained in a group\r\n        // NOTE: the target may also be the container itself if it's focusable\r\n        //  with tabIndex='-1' and was given initial focus\r\n        var containerIndex = findContainerIndex(target, event);\r\n        var containerGroup = containerIndex >= 0 ? state.containerGroups[containerIndex] : undefined;\r\n        if (containerIndex < 0) {\r\n          // target not found in any group: quite possible focus has escaped the trap,\r\n          //  so bring it back into...\r\n          if (isBackward) {\r\n            // ...the last node in the last group\r\n            destinationNode = state.tabbableGroups[state.tabbableGroups.length - 1].lastTabbableNode;\r\n          } else {\r\n            // ...the first node in the first group\r\n            destinationNode = state.tabbableGroups[0].firstTabbableNode;\r\n          }\r\n        } else if (isBackward) {\r\n          // REVERSE\r\n\r\n          // is the target the first tabbable node in a group?\r\n          var startOfGroupIndex = findIndex(state.tabbableGroups, function (_ref4) {\r\n            var firstTabbableNode = _ref4.firstTabbableNode;\r\n            return target === firstTabbableNode;\r\n          });\r\n          if (startOfGroupIndex < 0 && (containerGroup.container === target || tabbable.isFocusable(target, config.tabbableOptions) && !tabbable.isTabbable(target, config.tabbableOptions) && !containerGroup.nextTabbableNode(target, false))) {\r\n            // an exception case where the target is either the container itself, or\r\n            //  a non-tabbable node that was given focus (i.e. tabindex is negative\r\n            //  and user clicked on it or node was programmatically given focus)\r\n            //  and is not followed by any other tabbable node, in which\r\n            //  case, we should handle shift+tab as if focus were on the container's\r\n            //  first tabbable node, and go to the last tabbable node of the LAST group\r\n            startOfGroupIndex = containerIndex;\r\n          }\r\n          if (startOfGroupIndex >= 0) {\r\n            // YES: then shift+tab should go to the last tabbable node in the\r\n            //  previous group (and wrap around to the last tabbable node of\r\n            //  the LAST group if it's the first tabbable node of the FIRST group)\r\n            var destinationGroupIndex = startOfGroupIndex === 0 ? state.tabbableGroups.length - 1 : startOfGroupIndex - 1;\r\n            var destinationGroup = state.tabbableGroups[destinationGroupIndex];\r\n            destinationNode = tabbable.getTabIndex(target) >= 0 ? destinationGroup.lastTabbableNode : destinationGroup.lastDomTabbableNode;\r\n          } else if (!isTabEvent(event)) {\r\n            // user must have customized the nav keys so we have to move focus manually _within_\r\n            //  the active group: do this based on the order determined by tabbable()\r\n            destinationNode = containerGroup.nextTabbableNode(target, false);\r\n          }\r\n        } else {\r\n          // FORWARD\r\n\r\n          // is the target the last tabbable node in a group?\r\n          var lastOfGroupIndex = findIndex(state.tabbableGroups, function (_ref5) {\r\n            var lastTabbableNode = _ref5.lastTabbableNode;\r\n            return target === lastTabbableNode;\r\n          });\r\n          if (lastOfGroupIndex < 0 && (containerGroup.container === target || tabbable.isFocusable(target, config.tabbableOptions) && !tabbable.isTabbable(target, config.tabbableOptions) && !containerGroup.nextTabbableNode(target))) {\r\n            // an exception case where the target is the container itself, or\r\n            //  a non-tabbable node that was given focus (i.e. tabindex is negative\r\n            //  and user clicked on it or node was programmatically given focus)\r\n            //  and is not followed by any other tabbable node, in which\r\n            //  case, we should handle tab as if focus were on the container's\r\n            //  last tabbable node, and go to the first tabbable node of the FIRST group\r\n            lastOfGroupIndex = containerIndex;\r\n          }\r\n          if (lastOfGroupIndex >= 0) {\r\n            // YES: then tab should go to the first tabbable node in the next\r\n            //  group (and wrap around to the first tabbable node of the FIRST\r\n            //  group if it's the last tabbable node of the LAST group)\r\n            var _destinationGroupIndex = lastOfGroupIndex === state.tabbableGroups.length - 1 ? 0 : lastOfGroupIndex + 1;\r\n            var _destinationGroup = state.tabbableGroups[_destinationGroupIndex];\r\n            destinationNode = tabbable.getTabIndex(target) >= 0 ? _destinationGroup.firstTabbableNode : _destinationGroup.firstDomTabbableNode;\r\n          } else if (!isTabEvent(event)) {\r\n            // user must have customized the nav keys so we have to move focus manually _within_\r\n            //  the active group: do this based on the order determined by tabbable()\r\n            destinationNode = containerGroup.nextTabbableNode(target);\r\n          }\r\n        }\r\n      } else {\r\n        // no groups available\r\n        // NOTE: the fallbackFocus option does not support returning false to opt-out\r\n        destinationNode = getNodeForOption('fallbackFocus');\r\n      }\r\n      return destinationNode;\r\n    };\r\n\r\n    // This needs to be done on mousedown and touchstart instead of click\r\n    // so that it precedes the focus event.\r\n    var checkPointerDown = function checkPointerDown(e) {\r\n      var target = getActualTarget(e);\r\n      if (findContainerIndex(target, e) >= 0) {\r\n        // allow the click since it ocurred inside the trap\r\n        return;\r\n      }\r\n      if (valueOrHandler(config.clickOutsideDeactivates, e)) {\r\n        // immediately deactivate the trap\r\n        trap.deactivate({\r\n          // NOTE: by setting `returnFocus: false`, deactivate() will do nothing,\r\n          //  which will result in the outside click setting focus to the node\r\n          //  that was clicked (and if not focusable, to \"nothing\"); by setting\r\n          //  `returnFocus: true`, we'll attempt to re-focus the node originally-focused\r\n          //  on activation (or the configured `setReturnFocus` node), whether the\r\n          //  outside click was on a focusable node or not\r\n          returnFocus: config.returnFocusOnDeactivate\r\n        });\r\n        return;\r\n      }\r\n\r\n      // This is needed for mobile devices.\r\n      // (If we'll only let `click` events through,\r\n      // then on mobile they will be blocked anyways if `touchstart` is blocked.)\r\n      if (valueOrHandler(config.allowOutsideClick, e)) {\r\n        // allow the click outside the trap to take place\r\n        return;\r\n      }\r\n\r\n      // otherwise, prevent the click\r\n      e.preventDefault();\r\n    };\r\n\r\n    // In case focus escapes the trap for some strange reason, pull it back in.\r\n    // NOTE: the focusIn event is NOT cancelable, so if focus escapes, it may cause unexpected\r\n    //  scrolling if the node that got focused was out of view; there's nothing we can do to\r\n    //  prevent that from happening by the time we discover that focus escaped\r\n    var checkFocusIn = function checkFocusIn(event) {\r\n      var target = getActualTarget(event);\r\n      var targetContained = findContainerIndex(target, event) >= 0;\r\n\r\n      // In Firefox when you Tab out of an iframe the Document is briefly focused.\r\n      if (targetContained || target instanceof Document) {\r\n        if (targetContained) {\r\n          state.mostRecentlyFocusedNode = target;\r\n        }\r\n      } else {\r\n        // escaped! pull it back in to where it just left\r\n        event.stopImmediatePropagation();\r\n\r\n        // focus will escape if the MRU node had a positive tab index and user tried to nav forward;\r\n        //  it will also escape if the MRU node had a 0 tab index and user tried to nav backward\r\n        //  toward a node with a positive tab index\r\n        var nextNode; // next node to focus, if we find one\r\n        var navAcrossContainers = true;\r\n        if (state.mostRecentlyFocusedNode) {\r\n          if (tabbable.getTabIndex(state.mostRecentlyFocusedNode) > 0) {\r\n            // MRU container index must be >=0 otherwise we wouldn't have it as an MRU node...\r\n            var mruContainerIdx = findContainerIndex(state.mostRecentlyFocusedNode);\r\n            // there MAY not be any tabbable nodes in the container if there are at least 2 containers\r\n            //  and the MRU node is focusable but not tabbable (focus-trap requires at least 1 container\r\n            //  with at least one tabbable node in order to function, so this could be the other container\r\n            //  with nothing tabbable in it)\r\n            var tabbableNodes = state.containerGroups[mruContainerIdx].tabbableNodes;\r\n            if (tabbableNodes.length > 0) {\r\n              // MRU tab index MAY not be found if the MRU node is focusable but not tabbable\r\n              var mruTabIdx = tabbableNodes.findIndex(function (node) {\r\n                return node === state.mostRecentlyFocusedNode;\r\n              });\r\n              if (mruTabIdx >= 0) {\r\n                if (config.isKeyForward(state.recentNavEvent)) {\r\n                  if (mruTabIdx + 1 < tabbableNodes.length) {\r\n                    nextNode = tabbableNodes[mruTabIdx + 1];\r\n                    navAcrossContainers = false;\r\n                  }\r\n                  // else, don't wrap within the container as focus should move to next/previous\r\n                  //  container\r\n                } else {\r\n                  if (mruTabIdx - 1 >= 0) {\r\n                    nextNode = tabbableNodes[mruTabIdx - 1];\r\n                    navAcrossContainers = false;\r\n                  }\r\n                  // else, don't wrap within the container as focus should move to next/previous\r\n                  //  container\r\n                }\r\n                // else, don't find in container order without considering direction too\r\n              }\r\n            }\r\n            // else, no tabbable nodes in that container (which means we must have at least one other\r\n            //  container with at least one tabbable node in it, otherwise focus-trap would've thrown\r\n            //  an error the last time updateTabbableNodes() was run): find next node among all known\r\n            //  containers\r\n          } else {\r\n            // check to see if there's at least one tabbable node with a positive tab index inside\r\n            //  the trap because focus seems to escape when navigating backward from a tabbable node\r\n            //  with tabindex=0 when this is the case (instead of wrapping to the tabbable node with\r\n            //  the greatest positive tab index like it should)\r\n            if (!state.containerGroups.some(function (g) {\r\n              return g.tabbableNodes.some(function (n) {\r\n                return tabbable.getTabIndex(n) > 0;\r\n              });\r\n            })) {\r\n              // no containers with tabbable nodes with positive tab indexes which means the focus\r\n              //  escaped for some other reason and we should just execute the fallback to the\r\n              //  MRU node or initial focus node, if any\r\n              navAcrossContainers = false;\r\n            }\r\n          }\r\n        } else {\r\n          // no MRU node means we're likely in some initial condition when the trap has just\r\n          //  been activated and initial focus hasn't been given yet, in which case we should\r\n          //  fall through to trying to focus the initial focus node, which is what should\r\n          //  happen below at this point in the logic\r\n          navAcrossContainers = false;\r\n        }\r\n        if (navAcrossContainers) {\r\n          nextNode = findNextNavNode({\r\n            // move FROM the MRU node, not event-related node (which will be the node that is\r\n            //  outside the trap causing the focus escape we're trying to fix)\r\n            target: state.mostRecentlyFocusedNode,\r\n            isBackward: config.isKeyBackward(state.recentNavEvent)\r\n          });\r\n        }\r\n        if (nextNode) {\r\n          _tryFocus(nextNode);\r\n        } else {\r\n          _tryFocus(state.mostRecentlyFocusedNode || getInitialFocusNode());\r\n        }\r\n      }\r\n      state.recentNavEvent = undefined; // clear\r\n    };\r\n\r\n    // Hijack key nav events on the first and last focusable nodes of the trap,\r\n    // in order to prevent focus from escaping. If it escapes for even a\r\n    // moment it can end up scrolling the page and causing confusion so we\r\n    // kind of need to capture the action at the keydown phase.\r\n    var checkKeyNav = function checkKeyNav(event) {\r\n      var isBackward = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\r\n      state.recentNavEvent = event;\r\n      var destinationNode = findNextNavNode({\r\n        event: event,\r\n        isBackward: isBackward\r\n      });\r\n      if (destinationNode) {\r\n        if (isTabEvent(event)) {\r\n          // since tab natively moves focus, we wouldn't have a destination node unless we\r\n          //  were on the edge of a container and had to move to the next/previous edge, in\r\n          //  which case we want to prevent default to keep the browser from moving focus\r\n          //  to where it normally would\r\n          event.preventDefault();\r\n        }\r\n        _tryFocus(destinationNode);\r\n      }\r\n      // else, let the browser take care of [shift+]tab and move the focus\r\n    };\r\n    var checkTabKey = function checkTabKey(event) {\r\n      if (config.isKeyForward(event) || config.isKeyBackward(event)) {\r\n        checkKeyNav(event, config.isKeyBackward(event));\r\n      }\r\n    };\r\n\r\n    // we use a different event phase for the Escape key to allow canceling the event and checking for this in escapeDeactivates\r\n    var checkEscapeKey = function checkEscapeKey(event) {\r\n      if (isEscapeEvent(event) && valueOrHandler(config.escapeDeactivates, event) !== false) {\r\n        event.preventDefault();\r\n        trap.deactivate();\r\n      }\r\n    };\r\n    var checkClick = function checkClick(e) {\r\n      var target = getActualTarget(e);\r\n      if (findContainerIndex(target, e) >= 0) {\r\n        return;\r\n      }\r\n      if (valueOrHandler(config.clickOutsideDeactivates, e)) {\r\n        return;\r\n      }\r\n      if (valueOrHandler(config.allowOutsideClick, e)) {\r\n        return;\r\n      }\r\n      e.preventDefault();\r\n      e.stopImmediatePropagation();\r\n    };\r\n\r\n    //\r\n    // EVENT LISTENERS\r\n    //\r\n\r\n    var addListeners = function addListeners() {\r\n      if (!state.active) {\r\n        return;\r\n      }\r\n\r\n      // There can be only one listening focus trap at a time\r\n      activeFocusTraps.activateTrap(trapStack, trap);\r\n\r\n      // Delay ensures that the focused element doesn't capture the event\r\n      // that caused the focus trap activation.\r\n      state.delayInitialFocusTimer = config.delayInitialFocus ? delay(function () {\r\n        _tryFocus(getInitialFocusNode());\r\n      }) : _tryFocus(getInitialFocusNode());\r\n      doc.addEventListener('focusin', checkFocusIn, true);\r\n      doc.addEventListener('mousedown', checkPointerDown, {\r\n        capture: true,\r\n        passive: false\r\n      });\r\n      doc.addEventListener('touchstart', checkPointerDown, {\r\n        capture: true,\r\n        passive: false\r\n      });\r\n      doc.addEventListener('click', checkClick, {\r\n        capture: true,\r\n        passive: false\r\n      });\r\n      doc.addEventListener('keydown', checkTabKey, {\r\n        capture: true,\r\n        passive: false\r\n      });\r\n      doc.addEventListener('keydown', checkEscapeKey);\r\n      return trap;\r\n    };\r\n    var removeListeners = function removeListeners() {\r\n      if (!state.active) {\r\n        return;\r\n      }\r\n      doc.removeEventListener('focusin', checkFocusIn, true);\r\n      doc.removeEventListener('mousedown', checkPointerDown, true);\r\n      doc.removeEventListener('touchstart', checkPointerDown, true);\r\n      doc.removeEventListener('click', checkClick, true);\r\n      doc.removeEventListener('keydown', checkTabKey, true);\r\n      doc.removeEventListener('keydown', checkEscapeKey);\r\n      return trap;\r\n    };\r\n\r\n    //\r\n    // MUTATION OBSERVER\r\n    //\r\n\r\n    var checkDomRemoval = function checkDomRemoval(mutations) {\r\n      var isFocusedNodeRemoved = mutations.some(function (mutation) {\r\n        var removedNodes = Array.from(mutation.removedNodes);\r\n        return removedNodes.some(function (node) {\r\n          return node === state.mostRecentlyFocusedNode;\r\n        });\r\n      });\r\n\r\n      // If the currently focused is removed then browsers will move focus to the\r\n      // <body> element. If this happens, try to move focus back into the trap.\r\n      if (isFocusedNodeRemoved) {\r\n        _tryFocus(getInitialFocusNode());\r\n      }\r\n    };\r\n\r\n    // Use MutationObserver - if supported - to detect if focused node is removed\r\n    // from the DOM.\r\n    var mutationObserver = typeof window !== 'undefined' && 'MutationObserver' in window ? new MutationObserver(checkDomRemoval) : undefined;\r\n    var updateObservedNodes = function updateObservedNodes() {\r\n      if (!mutationObserver) {\r\n        return;\r\n      }\r\n      mutationObserver.disconnect();\r\n      if (state.active && !state.paused) {\r\n        state.containers.map(function (container) {\r\n          mutationObserver.observe(container, {\r\n            subtree: true,\r\n            childList: true\r\n          });\r\n        });\r\n      }\r\n    };\r\n\r\n    //\r\n    // TRAP DEFINITION\r\n    //\r\n\r\n    trap = {\r\n      get active() {\r\n        return state.active;\r\n      },\r\n      get paused() {\r\n        return state.paused;\r\n      },\r\n      activate: function activate(activateOptions) {\r\n        if (state.active) {\r\n          return this;\r\n        }\r\n        var onActivate = getOption(activateOptions, 'onActivate');\r\n        var onPostActivate = getOption(activateOptions, 'onPostActivate');\r\n        var checkCanFocusTrap = getOption(activateOptions, 'checkCanFocusTrap');\r\n        if (!checkCanFocusTrap) {\r\n          updateTabbableNodes();\r\n        }\r\n        state.active = true;\r\n        state.paused = false;\r\n        state.nodeFocusedBeforeActivation = doc.activeElement;\r\n        onActivate === null || onActivate === void 0 || onActivate();\r\n        var finishActivation = function finishActivation() {\r\n          if (checkCanFocusTrap) {\r\n            updateTabbableNodes();\r\n          }\r\n          addListeners();\r\n          updateObservedNodes();\r\n          onPostActivate === null || onPostActivate === void 0 || onPostActivate();\r\n        };\r\n        if (checkCanFocusTrap) {\r\n          checkCanFocusTrap(state.containers.concat()).then(finishActivation, finishActivation);\r\n          return this;\r\n        }\r\n        finishActivation();\r\n        return this;\r\n      },\r\n      deactivate: function deactivate(deactivateOptions) {\r\n        if (!state.active) {\r\n          return this;\r\n        }\r\n        var options = _objectSpread2({\r\n          onDeactivate: config.onDeactivate,\r\n          onPostDeactivate: config.onPostDeactivate,\r\n          checkCanReturnFocus: config.checkCanReturnFocus\r\n        }, deactivateOptions);\r\n        clearTimeout(state.delayInitialFocusTimer); // noop if undefined\r\n        state.delayInitialFocusTimer = undefined;\r\n        removeListeners();\r\n        state.active = false;\r\n        state.paused = false;\r\n        updateObservedNodes();\r\n        activeFocusTraps.deactivateTrap(trapStack, trap);\r\n        var onDeactivate = getOption(options, 'onDeactivate');\r\n        var onPostDeactivate = getOption(options, 'onPostDeactivate');\r\n        var checkCanReturnFocus = getOption(options, 'checkCanReturnFocus');\r\n        var returnFocus = getOption(options, 'returnFocus', 'returnFocusOnDeactivate');\r\n        onDeactivate === null || onDeactivate === void 0 || onDeactivate();\r\n        var finishDeactivation = function finishDeactivation() {\r\n          delay(function () {\r\n            if (returnFocus) {\r\n              _tryFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation));\r\n            }\r\n            onPostDeactivate === null || onPostDeactivate === void 0 || onPostDeactivate();\r\n          });\r\n        };\r\n        if (returnFocus && checkCanReturnFocus) {\r\n          checkCanReturnFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation)).then(finishDeactivation, finishDeactivation);\r\n          return this;\r\n        }\r\n        finishDeactivation();\r\n        return this;\r\n      },\r\n      pause: function pause(pauseOptions) {\r\n        if (state.paused || !state.active) {\r\n          return this;\r\n        }\r\n        var onPause = getOption(pauseOptions, 'onPause');\r\n        var onPostPause = getOption(pauseOptions, 'onPostPause');\r\n        state.paused = true;\r\n        onPause === null || onPause === void 0 || onPause();\r\n        removeListeners();\r\n        updateObservedNodes();\r\n        onPostPause === null || onPostPause === void 0 || onPostPause();\r\n        return this;\r\n      },\r\n      unpause: function unpause(unpauseOptions) {\r\n        if (!state.paused || !state.active) {\r\n          return this;\r\n        }\r\n        var onUnpause = getOption(unpauseOptions, 'onUnpause');\r\n        var onPostUnpause = getOption(unpauseOptions, 'onPostUnpause');\r\n        state.paused = false;\r\n        onUnpause === null || onUnpause === void 0 || onUnpause();\r\n        updateTabbableNodes();\r\n        addListeners();\r\n        updateObservedNodes();\r\n        onPostUnpause === null || onPostUnpause === void 0 || onPostUnpause();\r\n        return this;\r\n      },\r\n      updateContainerElements: function updateContainerElements(containerElements) {\r\n        var elementsAsArray = [].concat(containerElements).filter(Boolean);\r\n        state.containers = elementsAsArray.map(function (element) {\r\n          return typeof element === 'string' ? doc.querySelector(element) : element;\r\n        });\r\n        if (state.active) {\r\n          updateTabbableNodes();\r\n        }\r\n        updateObservedNodes();\r\n        return this;\r\n      }\r\n    };\r\n\r\n    // initialize container elements\r\n    trap.updateContainerElements(elements);\r\n    return trap;\r\n  };\r\n\r\n  exports.createFocusTrap = createFocusTrap;\r\n\r\n}));\r\n//# sourceMappingURL=focus-trap.umd.js.map\r\n","const Panel = function panel(name, container, options = null) {\r\n\r\n    if (container) container.classList.remove('nojs');\r\n\r\n    const settings = {\r\n        name: name,\r\n        container: container,\r\n        panel: undefined,\r\n        closeBtns: undefined,\r\n        openBtns: undefined,\r\n        trap: undefined,\r\n        onopen: undefined,\r\n        onclose: undefined,\r\n        instance: undefined,\r\n        onready: undefined,\r\n        dismissible: true,\r\n        unobstrusive: false,\r\n        initialFocus: undefined,\r\n        get fallbackFocus() {\r\n            return panelInstance.el.panel.querySelector('[data-panel-content]');\r\n        },\r\n        get focusTrapConfig() {\r\n            return {\r\n                initialFocus: settings.initialFocus,\r\n                fallbackFocus: settings.fallbackFocus,\r\n                escapeDeactivates: () => {\r\n                    if (settings.dismissible) panelInstance.close();\r\n                    return false;\r\n                },\r\n                clickOutsideDeactivates: () => {\r\n                    if (settings.dismissible) panelInstance.close();\r\n                    return false;\r\n                }\r\n            }\r\n        }\r\n    };\r\n    const focusTrapSettings = {\r\n        get initialFocus() { return settings.initialFocus },\r\n        get fallbackFocus() { return settings.fallbackFocus },\r\n        get escapeDeactivates() {\r\n            if (settings.dismissible) panelInstance.close();\r\n            return false;\r\n        },\r\n        get clickOutsideDeactivates() {\r\n            if (settings.dismissible) panelInstance.close();\r\n            return false;\r\n        }\r\n    };\r\n    const self = this;\r\n    const ext = {\r\n        get settings() { return settings; },\r\n        get instance() { return panelInstance; },\r\n        el: {\r\n            get container() {\r\n                return settings.container\r\n            },\r\n            get panel() {\r\n                return settings.panel\r\n            }\r\n        },\r\n        registerCallback(evnt, instance, func) {\r\n            settings.instance = panelInstance;\r\n            settings[evnt] = func;\r\n        },\r\n        registerOnOpenCallback(instance, func) {\r\n            ext.registerCallback(\"onopen\", instance, func)\r\n        },\r\n        registerOnCloseCallback(instance, func) {\r\n            ext.registerCallback(\"onclose\", instance, func)\r\n        },\r\n        registerOnReadyCallback(instance, func) {\r\n            ext.registerCallback(\"onready\", instance, func)\r\n        }\r\n    };\r\n\r\n    const status = {\r\n        open: false\r\n    };\r\n    const isOpen = () => {\r\n        return settings.panel.classList.contains('active');\r\n    };\r\n\r\n\r\n    const init = (name, container, _this)=> {\r\n        settings.container = container;\r\n        settings.panel = container.querySelector('.panel');\r\n        settings.closeBtns = container.querySelectorAll('[data-panel-close]');\r\n        settings.openBtns = document.querySelectorAll(`[data-panel-open=\"${name}\"]`);\r\n        settings.openBtns.forEach(b => {\r\n            b.removeEventListener('click', handleOpen);\r\n            b.addEventListener('click', handleOpen.bind(panelInstance));\r\n        });\r\n        settings.initialFocus = settings.initialFocus || panelInstance.el.panel.querySelector('[data-panel-content]');\r\n        if (container.dataset.dismissible == \"false\") settings.dismissible = false;\r\n        //settings.trap = focusTrap.createFocusTrap(settings.container, {\r\n        //    initialFocus: settings.initialFocus,\r\n        //    escapeDeactivates: () => {\r\n        //        if (settings.dismissible) close();\r\n        //        return false;\r\n        //    },\r\n        //    clickOutsideDeactivates: () => {\r\n        //        if (settings.dismissible) close();\r\n        //        return false;\r\n        //    }\r\n        //});\r\n        settings.trap = focusTrap.createFocusTrap(settings.container, settings.focusTrapConfig );\r\n        if (typeof (settings.onready) == \"function\") {\r\n            ext.registerOnReadyCallback(panelInstance, settings.onready);\r\n        }\r\n        if (typeof (settings.onopen) == \"function\") {\r\n            ext.registerOnOpenCallback(panelInstance, settings.onopen);\r\n        }\r\n        if (typeof (settings.onclose) == \"function\") {\r\n            ext.registerOnCloseCallback(panelInstance, settings.onclose);\r\n        }\r\n        return _this;\r\n    }\r\n    const open = (replacing = false) => {\r\n        const historyHasState = history.state && history.state.modalOpen && history.state.modelName == settings.name;\r\n        windowTop = window.scrollY;\r\n\r\n        if (!settings.unobstrusive) {\r\n            document.querySelector('html').style.setProperty(\"--body-top\", -windowTop + \"px\")\r\n            document.body.classList.add('no-scroll');\r\n            //settings.trap.activate();\r\n        }\r\n        if (typeof (settings.onopen) == \"function\") {\r\n            settings.onopen(panelInstance);\r\n        }\r\n        settings.container.classList.add('active');\r\n        settings.panel.classList.add('active');\r\n        addEventListeners(this);\r\n\r\n        if (!settings.unobstrusive) {\r\n            settings.trap.activate();\r\n        }\r\n        if (replacing) {\r\n            history.replaceState({ modalOpen: true, modelName: settings.name }, 'Modal open', '#' + settings.panel.id);\r\n        }\r\n        if (!historyHasState) {\r\n            history.pushState({ modalOpen: true, modelName: settings.name }, 'Modal open', '#' + settings.panel.id);\r\n        }\r\n        status.open = true;\r\n    };\r\n    const close = (replaced = false) => {\r\n        settings.container.classList.remove('active');\r\n        settings.panel.classList.remove('active');\r\n        removeEventListeners();\r\n        if (!settings.unobstrusive) {\r\n            document.body.classList.remove('no-scroll');\r\n            document.querySelector('html').style.scrollBehavior = \"auto\"\r\n            window.scrollTo(0, windowTop);\r\n        }\r\n        if (typeof (settings.onclose) == \"function\") {\r\n            settings.onclose(panelInstance);\r\n        }\r\n        if (!settings.unobstrusive) {\r\n            settings.trap.deactivate();\r\n            document.querySelector('html').style.scrollBehavior = \"smooth\"\r\n        }\r\n        if (replaced) {\r\n            status.open = false;\r\n        }\r\n        else if (history.state && history.state.modalOpen && history.state.modelName == settings.name) {\r\n            history.back();  // This removes the modal from the history stack\r\n        }\r\n    };\r\n    const handleOpen = (e) => {\r\n        e.preventDefault();\r\n        open();\r\n    };\r\n    const handleClose = (e) => {\r\n        e.preventDefault();\r\n        close();\r\n    };\r\n    const handleContainerClick = (e) => {\r\n        if (e.target.matches('[data-panel-overlay]')) {\r\n            e.preventDefault();\r\n            if (settings.dismissible) close();\r\n        }\r\n    };\r\n\r\n    const addEventListeners = (_this) => {\r\n        //const _this = this;\r\n        settings.closeBtns.forEach(b => {\r\n            b.addEventListener('click', handleClose);\r\n        });\r\n        settings.container.addEventListener('click', handleContainerClick);\r\n\r\n    };\r\n    const removeEventListeners = () => {\r\n        settings.closeBtns.forEach(b => {\r\n            b.removeEventListener('click', handleClose);\r\n        })\r\n        settings.container.removeEventListener('click', handleClose);\r\n    };\r\n\r\n    const create = (instance, options = null) => {\r\n        if (options != null) {\r\n            Object.entries(options).forEach(([key, val]) => {\r\n                //console.log(`${key}:${val}`);\r\n                if (settings.hasOwnProperty(key)) {\r\n                    if (settings[key] != val) {\r\n                        Reflect.set(settings, key, val);\r\n                    }\r\n                }\r\n            });\r\n        }\r\n        init(name, container, instance);\r\n        if (typeof (settings.onready) == \"function\") {\r\n            settings.onready(panelInstance);\r\n        }\r\n    };\r\n\r\n    //const _this = init(name, container);\r\n   \r\n    const panelInstance = {\r\n        openHandler: handleOpen,\r\n        closeHandler: handleClose,\r\n        open: open,\r\n        close: close,\r\n        onopen: ext.registerOnOpenCallback,\r\n        onclose: ext.registerOnCloseCallback,\r\n        onready: ext.registerOnReadyCallback,\r\n        registerCallback: ext.registerCallback,\r\n        init: create,\r\n        el: ext.el,\r\n        settings: ext.settings,\r\n        get isOpen() { return isOpen }\r\n    };\r\n    create(panel, options);\r\n\r\n    const logPopstate = (state, modelName) => {\r\n        if (state != null) {\r\n            console.log('========================');\r\n            console.log('popstate');\r\n            console.log('name: ' + settings.name);\r\n            console.log('state.modelName: ' + modelName);\r\n            console.log('isOpen: ' + status.open);\r\n            console.log('------------------------');\r\n        }\r\n\r\n    };\r\n    // Handle back button navigation (or forward)\r\n    const handlePopstate = (event) => {\r\n        var modelName = event.state != null ? event.state.modelName : '';\r\n        logPopstate(event.state, modelName);\r\n\r\n        //const shouldOpen = isOpen() != true;\r\n        const shouldOpen = status.open == false;\r\n        if (event.state && event.state.modelName != settings.name) {\r\n            return;\r\n        }\r\n        if (event.state && event.state.modalOpen && event.state.modelName == settings.name) {\r\n            if (shouldOpen) {\r\n                // If the state is related to the modal being open, show the modal\r\n                open();\r\n            }\r\n            else {\r\n                close();\r\n                status.open = false;\r\n            }\r\n        } else if (status.open) {\r\n            // If no modal-related state, ensure it's closed\r\n            close();\r\n            status.open = false;\r\n        }\r\n\r\n    }\r\n    const addHistoryListener = () => {\r\n        window.addEventListener(\"popstate\", handlePopstate);\r\n    }\r\n    const removeHistoryListener = () => {\r\n        window.removeEventListener(\"popstate\", handlePopstate);\r\n    }\r\n\r\n    settings.instance = panelInstance;\r\n    addHistoryListener();\r\n\r\n    return panelInstance;\r\n}\r\nif (history.scrollRestoration) {\r\n    history.scrollRestoration = \"manual\";\r\n}\r\nfunction PanelEnquiryObject(containerElement) {\r\n    const\r\n        container = containerElement.querySelector('.enquiry-object'),\r\n        view = {\r\n            img: {\r\n                data: '',\r\n                get elem() { return container.querySelector('.enquiry-object-img') },\r\n                update: function (val) { data = val; this.elem.src = data; }\r\n            },\r\n            name: {\r\n                data: '',\r\n                get elem() { return container.querySelector('.enquiry-object-name') },\r\n                update: function (val) { data = val; this.elem.textContent = data; }\r\n            },\r\n            description: {\r\n                data: '',\r\n                get elem() { return container.querySelector('.enquiry-object-desc') },\r\n                update: function (val) { data = val; this.elem.textContent = data; }\r\n            },\r\n            value: {\r\n                data: '',\r\n                get elem() { return container.querySelector('.enquiry-object-value') },\r\n                update: function (val) { data = val; this.elem.innerHTML = data; }\r\n            }\r\n        },\r\n        update = function (updateData) {\r\n            Object.entries(updateData).forEach(([key, value]) => { if (key in view) view[key].update(value) });\r\n        };\r\n\r\n    return { update: update };\r\n        \r\n}","cac_data.openingHours = function () {\r\n    cac_data.panels = cac_data.panels || {};\r\n    cac_data.panels.openingHours = { panel: new Panel('openingHours', document.querySelector('.panel-container[data-panel-opening-hours]')) };\r\n}\r\ndocument.addEventListener(\"DOMContentLoaded\", function (e) { cac_data.openingHours(); });"]}