{"version":3,"file":"js/main.361bc06479343f4c011c.js","mappings":"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","sources":["webpack://microsite/./src/scripts/util/scrolling.js","webpack://microsite/./node_modules/tabbable/dist/index.esm.js","webpack://microsite/./node_modules/focus-trap/dist/focus-trap.esm.js","webpack://microsite/./src/scripts/menu.js","webpack://microsite/./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","webpack://microsite/./node_modules/@babel/runtime/helpers/esm/slicedToArray.js","webpack://microsite/./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","webpack://microsite/./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","webpack://microsite/./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","webpack://microsite/./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","webpack://microsite/./src/scripts/sidebar.js","webpack://microsite/./node_modules/@babel/runtime/helpers/esm/typeof.js","webpack://microsite/./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js","webpack://microsite/./src/scripts/util/create-article-card.js","webpack://microsite/./src/scripts/listing.js","webpack://microsite/./src/index.js","webpack://microsite/./src/scripts/forms.js","webpack://microsite/./src/scripts/tab-slider.js","webpack://microsite/./node_modules/@babel/runtime/helpers/regeneratorRuntime.js","webpack://microsite/./node_modules/@babel/runtime/helpers/typeof.js","webpack://microsite/./node_modules/@babel/runtime/regenerator/index.js"],"sourcesContent":["const scrollbarWidth = getScrollbarWidth();\r\nconst header = document.querySelector('#header, .header-section');\r\nconst hasStickyHeader =\r\n  header?.id === 'header' || header?.classList.contains('fixed-header');\r\n\r\nlet scrollPosition = 0;\r\n\r\nexport function getScrollbarWidth() {\r\n  const outer = document.createElement('div');\r\n  outer.style.visibility = 'hidden';\r\n  outer.style.overflow = 'scroll';\r\n  outer.style.msOverflowStyle = 'scrollbar';\r\n  document.body.appendChild(outer);\r\n\r\n  const inner = document.createElement('div');\r\n  outer.appendChild(inner);\r\n\r\n  const scrollbarWidth = outer.offsetWidth - inner.offsetWidth;\r\n  outer.parentNode.removeChild(outer);\r\n\r\n  return scrollbarWidth;\r\n}\r\n\r\nexport function disableScroll() {\r\n  if (document.documentElement.classList.contains('disable-scroll')) {\r\n    return;\r\n  }\r\n\r\n  scrollPosition = window.pageYOffset;\r\n  document.documentElement.classList.add('disable-scroll');\r\n  document.body.classList.add('disable-scroll');\r\n  document.body.style.top = `-${scrollPosition}px`;\r\n\r\n  if (scrollbarWidth) {\r\n    document.body.style.paddingRight = `${scrollbarWidth}px`;\r\n\r\n    if (header && hasStickyHeader) {\r\n      header.style.right = `${scrollbarWidth}px`;\r\n    }\r\n  }\r\n}\r\n\r\nexport function enableScroll() {\r\n  document.body.classList.remove('disable-scroll');\r\n  document.documentElement.classList.remove('disable-scroll');\r\n  document.body.style.top = null;\r\n  document.body.style.paddingRight = null;\r\n  document.body.style.height = null;\r\n\r\n  if (header) {\r\n    header.style.right = null;\r\n  }\r\n\r\n  window.scrollTo({ top: scrollPosition });\r\n  scrollPosition = 0;\r\n}\r\n","/*!\n* tabbable 6.2.0\n* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE\n*/\n// NOTE: separate `:not()` selectors has broader browser support than the newer\n//  `:not([inert], [inert] *)` (Feb 2023)\n// CAREFUL: JSDom does not support `:not([inert] *)` as a selector; using it causes\n//  the entire query to fail, resulting in no nodes found, which will break a lot\n//  of things... so we have to rely on JS to identify nodes inside an inert container\nvar candidateSelectors = ['input:not([inert])', 'select:not([inert])', 'textarea:not([inert])', 'a[href]:not([inert])', 'button:not([inert])', '[tabindex]:not(slot):not([inert])', 'audio[controls]:not([inert])', 'video[controls]:not([inert])', '[contenteditable]:not([contenteditable=\"false\"]):not([inert])', 'details>summary:first-of-type:not([inert])', 'details:not([inert])'];\nvar candidateSelector = /* #__PURE__ */candidateSelectors.join(',');\nvar NoElement = typeof Element === 'undefined';\nvar matches = NoElement ? function () {} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;\nvar getRootNode = !NoElement && Element.prototype.getRootNode ? function (element) {\n  var _element$getRootNode;\n  return element === null || element === void 0 ? void 0 : (_element$getRootNode = element.getRootNode) === null || _element$getRootNode === void 0 ? void 0 : _element$getRootNode.call(element);\n} : function (element) {\n  return element === null || element === void 0 ? void 0 : element.ownerDocument;\n};\n\n/**\n * Determines if a node is inert or in an inert ancestor.\n * @param {Element} [node]\n * @param {boolean} [lookUp] If true and `node` is not inert, looks up at ancestors to\n *  see if any of them are inert. If false, only `node` itself is considered.\n * @returns {boolean} True if inert itself or by way of being in an inert ancestor.\n *  False if `node` is falsy.\n */\nvar isInert = function isInert(node, lookUp) {\n  var _node$getAttribute;\n  if (lookUp === void 0) {\n    lookUp = true;\n  }\n  // CAREFUL: JSDom does not support inert at all, so we can't use the `HTMLElement.inert`\n  //  JS API property; we have to check the attribute, which can either be empty or 'true';\n  //  if it's `null` (not specified) or 'false', it's an active element\n  var inertAtt = node === null || node === void 0 ? void 0 : (_node$getAttribute = node.getAttribute) === null || _node$getAttribute === void 0 ? void 0 : _node$getAttribute.call(node, 'inert');\n  var inert = inertAtt === '' || inertAtt === 'true';\n\n  // NOTE: this could also be handled with `node.matches('[inert], :is([inert] *)')`\n  //  if it weren't for `matches()` not being a function on shadow roots; the following\n  //  code works for any kind of node\n  // CAREFUL: JSDom does not appear to support certain selectors like `:not([inert] *)`\n  //  so it likely would not support `:is([inert] *)` either...\n  var result = inert || lookUp && node && isInert(node.parentNode); // recursive\n\n  return result;\n};\n\n/**\n * Determines if a node's content is editable.\n * @param {Element} [node]\n * @returns True if it's content-editable; false if it's not or `node` is falsy.\n */\nvar isContentEditable = function isContentEditable(node) {\n  var _node$getAttribute2;\n  // CAREFUL: JSDom does not support the `HTMLElement.isContentEditable` API so we have\n  //  to use the attribute directly to check for this, which can either be empty or 'true';\n  //  if it's `null` (not specified) or 'false', it's a non-editable element\n  var attValue = node === null || node === void 0 ? void 0 : (_node$getAttribute2 = node.getAttribute) === null || _node$getAttribute2 === void 0 ? void 0 : _node$getAttribute2.call(node, 'contenteditable');\n  return attValue === '' || attValue === 'true';\n};\n\n/**\n * @param {Element} el container to check in\n * @param {boolean} includeContainer add container to check\n * @param {(node: Element) => boolean} filter filter candidates\n * @returns {Element[]}\n */\nvar getCandidates = function getCandidates(el, includeContainer, filter) {\n  // even if `includeContainer=false`, we still have to check it for inertness because\n  //  if it's inert, all its children are inert\n  if (isInert(el)) {\n    return [];\n  }\n  var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));\n  if (includeContainer && matches.call(el, candidateSelector)) {\n    candidates.unshift(el);\n  }\n  candidates = candidates.filter(filter);\n  return candidates;\n};\n\n/**\n * @callback GetShadowRoot\n * @param {Element} element to check for shadow root\n * @returns {ShadowRoot|boolean} ShadowRoot if available or boolean indicating if a shadowRoot is attached but not available.\n */\n\n/**\n * @callback ShadowRootFilter\n * @param {Element} shadowHostNode the element which contains shadow content\n * @returns {boolean} true if a shadow root could potentially contain valid candidates.\n */\n\n/**\n * @typedef {Object} CandidateScope\n * @property {Element} scopeParent contains inner candidates\n * @property {Element[]} candidates list of candidates found in the scope parent\n */\n\n/**\n * @typedef {Object} IterativeOptions\n * @property {GetShadowRoot|boolean} getShadowRoot true if shadow support is enabled; falsy if not;\n *  if a function, implies shadow support is enabled and either returns the shadow root of an element\n *  or a boolean stating if it has an undisclosed shadow root\n * @property {(node: Element) => boolean} filter filter candidates\n * @property {boolean} flatten if true then result will flatten any CandidateScope into the returned list\n * @property {ShadowRootFilter} shadowRootFilter filter shadow roots;\n */\n\n/**\n * @param {Element[]} elements list of element containers to match candidates from\n * @param {boolean} includeContainer add container list to check\n * @param {IterativeOptions} options\n * @returns {Array.<Element|CandidateScope>}\n */\nvar getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {\n  var candidates = [];\n  var elementsToCheck = Array.from(elements);\n  while (elementsToCheck.length) {\n    var element = elementsToCheck.shift();\n    if (isInert(element, false)) {\n      // no need to look up since we're drilling down\n      // anything inside this container will also be inert\n      continue;\n    }\n    if (element.tagName === 'SLOT') {\n      // add shadow dom slot scope (slot itself cannot be focusable)\n      var assigned = element.assignedElements();\n      var content = assigned.length ? assigned : element.children;\n      var nestedCandidates = getCandidatesIteratively(content, true, options);\n      if (options.flatten) {\n        candidates.push.apply(candidates, nestedCandidates);\n      } else {\n        candidates.push({\n          scopeParent: element,\n          candidates: nestedCandidates\n        });\n      }\n    } else {\n      // check candidate element\n      var validCandidate = matches.call(element, candidateSelector);\n      if (validCandidate && options.filter(element) && (includeContainer || !elements.includes(element))) {\n        candidates.push(element);\n      }\n\n      // iterate over shadow content if possible\n      var shadowRoot = element.shadowRoot ||\n      // check for an undisclosed shadow\n      typeof options.getShadowRoot === 'function' && options.getShadowRoot(element);\n\n      // no inert look up because we're already drilling down and checking for inertness\n      //  on the way down, so all containers to this root node should have already been\n      //  vetted as non-inert\n      var validShadowRoot = !isInert(shadowRoot, false) && (!options.shadowRootFilter || options.shadowRootFilter(element));\n      if (shadowRoot && validShadowRoot) {\n        // add shadow dom scope IIF a shadow root node was given; otherwise, an undisclosed\n        //  shadow exists, so look at light dom children as fallback BUT create a scope for any\n        //  child candidates found because they're likely slotted elements (elements that are\n        //  children of the web component element (which has the shadow), in the light dom, but\n        //  slotted somewhere _inside_ the undisclosed shadow) -- the scope is created below,\n        //  _after_ we return from this recursive call\n        var _nestedCandidates = getCandidatesIteratively(shadowRoot === true ? element.children : shadowRoot.children, true, options);\n        if (options.flatten) {\n          candidates.push.apply(candidates, _nestedCandidates);\n        } else {\n          candidates.push({\n            scopeParent: element,\n            candidates: _nestedCandidates\n          });\n        }\n      } else {\n        // there's not shadow so just dig into the element's (light dom) children\n        //  __without__ giving the element special scope treatment\n        elementsToCheck.unshift.apply(elementsToCheck, element.children);\n      }\n    }\n  }\n  return candidates;\n};\n\n/**\n * @private\n * Determines if the node has an explicitly specified `tabindex` attribute.\n * @param {HTMLElement} node\n * @returns {boolean} True if so; false if not.\n */\nvar hasTabIndex = function hasTabIndex(node) {\n  return !isNaN(parseInt(node.getAttribute('tabindex'), 10));\n};\n\n/**\n * Determine the tab index of a given node.\n * @param {HTMLElement} node\n * @returns {number} Tab order (negative, 0, or positive number).\n * @throws {Error} If `node` is falsy.\n */\nvar getTabIndex = function getTabIndex(node) {\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (node.tabIndex < 0) {\n    // in Chrome, <details/>, <audio controls/> and <video controls/> elements get a default\n    // `tabIndex` of -1 when the 'tabindex' attribute isn't specified in the DOM,\n    // yet they are still part of the regular tab order; in FF, they get a default\n    // `tabIndex` of 0; since Chrome still puts those elements in the regular tab\n    // order, consider their tab index to be 0.\n    // Also browsers do not return `tabIndex` correctly for contentEditable nodes;\n    // so if they don't have a tabindex attribute specifically set, assume it's 0.\n    if ((/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || isContentEditable(node)) && !hasTabIndex(node)) {\n      return 0;\n    }\n  }\n  return node.tabIndex;\n};\n\n/**\n * Determine the tab index of a given node __for sort order purposes__.\n * @param {HTMLElement} node\n * @param {boolean} [isScope] True for a custom element with shadow root or slot that, by default,\n *  has tabIndex -1, but needs to be sorted by document order in order for its content to be\n *  inserted into the correct sort position.\n * @returns {number} Tab order (negative, 0, or positive number).\n */\nvar getSortOrderTabIndex = function getSortOrderTabIndex(node, isScope) {\n  var tabIndex = getTabIndex(node);\n  if (tabIndex < 0 && isScope && !hasTabIndex(node)) {\n    return 0;\n  }\n  return tabIndex;\n};\nvar sortOrderedTabbables = function sortOrderedTabbables(a, b) {\n  return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;\n};\nvar isInput = function isInput(node) {\n  return node.tagName === 'INPUT';\n};\nvar isHiddenInput = function isHiddenInput(node) {\n  return isInput(node) && node.type === 'hidden';\n};\nvar isDetailsWithSummary = function isDetailsWithSummary(node) {\n  var r = node.tagName === 'DETAILS' && Array.prototype.slice.apply(node.children).some(function (child) {\n    return child.tagName === 'SUMMARY';\n  });\n  return r;\n};\nvar getCheckedRadio = function getCheckedRadio(nodes, form) {\n  for (var i = 0; i < nodes.length; i++) {\n    if (nodes[i].checked && nodes[i].form === form) {\n      return nodes[i];\n    }\n  }\n};\nvar isTabbableRadio = function isTabbableRadio(node) {\n  if (!node.name) {\n    return true;\n  }\n  var radioScope = node.form || getRootNode(node);\n  var queryRadios = function queryRadios(name) {\n    return radioScope.querySelectorAll('input[type=\"radio\"][name=\"' + name + '\"]');\n  };\n  var radioSet;\n  if (typeof window !== 'undefined' && typeof window.CSS !== 'undefined' && typeof window.CSS.escape === 'function') {\n    radioSet = queryRadios(window.CSS.escape(node.name));\n  } else {\n    try {\n      radioSet = queryRadios(node.name);\n    } catch (err) {\n      // eslint-disable-next-line no-console\n      console.error('Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s', err.message);\n      return false;\n    }\n  }\n  var checked = getCheckedRadio(radioSet, node.form);\n  return !checked || checked === node;\n};\nvar isRadio = function isRadio(node) {\n  return isInput(node) && node.type === 'radio';\n};\nvar isNonTabbableRadio = function isNonTabbableRadio(node) {\n  return isRadio(node) && !isTabbableRadio(node);\n};\n\n// determines if a node is ultimately attached to the window's document\nvar isNodeAttached = function isNodeAttached(node) {\n  var _nodeRoot;\n  // The root node is the shadow root if the node is in a shadow DOM; some document otherwise\n  //  (but NOT _the_ document; see second 'If' comment below for more).\n  // If rootNode is shadow root, it'll have a host, which is the element to which the shadow\n  //  is attached, and the one we need to check if it's in the document or not (because the\n  //  shadow, and all nodes it contains, is never considered in the document since shadows\n  //  behave like self-contained DOMs; but if the shadow's HOST, which is part of the document,\n  //  is hidden, or is not in the document itself but is detached, it will affect the shadow's\n  //  visibility, including all the nodes it contains). The host could be any normal node,\n  //  or a custom element (i.e. web component). Either way, that's the one that is considered\n  //  part of the document, not the shadow root, nor any of its children (i.e. the node being\n  //  tested).\n  // To further complicate things, we have to look all the way up until we find a shadow HOST\n  //  that is attached (or find none) because the node might be in nested shadows...\n  // If rootNode is not a shadow root, it won't have a host, and so rootNode should be the\n  //  document (per the docs) and while it's a Document-type object, that document does not\n  //  appear to be the same as the node's `ownerDocument` for some reason, so it's safer\n  //  to ignore the rootNode at this point, and use `node.ownerDocument`. Otherwise,\n  //  using `rootNode.contains(node)` will _always_ be true we'll get false-positives when\n  //  node is actually detached.\n  // NOTE: If `nodeRootHost` or `node` happens to be the `document` itself (which is possible\n  //  if a tabbable/focusable node was quickly added to the DOM, focused, and then removed\n  //  from the DOM as in https://github.com/focus-trap/focus-trap-react/issues/905), then\n  //  `ownerDocument` will be `null`, hence the optional chaining on it.\n  var nodeRoot = node && getRootNode(node);\n  var nodeRootHost = (_nodeRoot = nodeRoot) === null || _nodeRoot === void 0 ? void 0 : _nodeRoot.host;\n\n  // in some cases, a detached node will return itself as the root instead of a document or\n  //  shadow root object, in which case, we shouldn't try to look further up the host chain\n  var attached = false;\n  if (nodeRoot && nodeRoot !== node) {\n    var _nodeRootHost, _nodeRootHost$ownerDo, _node$ownerDocument;\n    attached = !!((_nodeRootHost = nodeRootHost) !== null && _nodeRootHost !== void 0 && (_nodeRootHost$ownerDo = _nodeRootHost.ownerDocument) !== null && _nodeRootHost$ownerDo !== void 0 && _nodeRootHost$ownerDo.contains(nodeRootHost) || node !== null && node !== void 0 && (_node$ownerDocument = node.ownerDocument) !== null && _node$ownerDocument !== void 0 && _node$ownerDocument.contains(node));\n    while (!attached && nodeRootHost) {\n      var _nodeRoot2, _nodeRootHost2, _nodeRootHost2$ownerD;\n      // since it's not attached and we have a root host, the node MUST be in a nested shadow DOM,\n      //  which means we need to get the host's host and check if that parent host is contained\n      //  in (i.e. attached to) the document\n      nodeRoot = getRootNode(nodeRootHost);\n      nodeRootHost = (_nodeRoot2 = nodeRoot) === null || _nodeRoot2 === void 0 ? void 0 : _nodeRoot2.host;\n      attached = !!((_nodeRootHost2 = nodeRootHost) !== null && _nodeRootHost2 !== void 0 && (_nodeRootHost2$ownerD = _nodeRootHost2.ownerDocument) !== null && _nodeRootHost2$ownerD !== void 0 && _nodeRootHost2$ownerD.contains(nodeRootHost));\n    }\n  }\n  return attached;\n};\nvar isZeroArea = function isZeroArea(node) {\n  var _node$getBoundingClie = node.getBoundingClientRect(),\n    width = _node$getBoundingClie.width,\n    height = _node$getBoundingClie.height;\n  return width === 0 && height === 0;\n};\nvar isHidden = function isHidden(node, _ref) {\n  var displayCheck = _ref.displayCheck,\n    getShadowRoot = _ref.getShadowRoot;\n  // NOTE: visibility will be `undefined` if node is detached from the document\n  //  (see notes about this further down), which means we will consider it visible\n  //  (this is legacy behavior from a very long way back)\n  // NOTE: we check this regardless of `displayCheck=\"none\"` because this is a\n  //  _visibility_ check, not a _display_ check\n  if (getComputedStyle(node).visibility === 'hidden') {\n    return true;\n  }\n  var isDirectSummary = matches.call(node, 'details>summary:first-of-type');\n  var nodeUnderDetails = isDirectSummary ? node.parentElement : node;\n  if (matches.call(nodeUnderDetails, 'details:not([open]) *')) {\n    return true;\n  }\n  if (!displayCheck || displayCheck === 'full' || displayCheck === 'legacy-full') {\n    if (typeof getShadowRoot === 'function') {\n      // figure out if we should consider the node to be in an undisclosed shadow and use the\n      //  'non-zero-area' fallback\n      var originalNode = node;\n      while (node) {\n        var parentElement = node.parentElement;\n        var rootNode = getRootNode(node);\n        if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true // check if there's an undisclosed shadow\n        ) {\n          // node has an undisclosed shadow which means we can only treat it as a black box, so we\n          //  fall back to a non-zero-area test\n          return isZeroArea(node);\n        } else if (node.assignedSlot) {\n          // iterate up slot\n          node = node.assignedSlot;\n        } else if (!parentElement && rootNode !== node.ownerDocument) {\n          // cross shadow boundary\n          node = rootNode.host;\n        } else {\n          // iterate up normal dom\n          node = parentElement;\n        }\n      }\n      node = originalNode;\n    }\n    // else, `getShadowRoot` might be true, but all that does is enable shadow DOM support\n    //  (i.e. it does not also presume that all nodes might have undisclosed shadows); or\n    //  it might be a falsy value, which means shadow DOM support is disabled\n\n    // Since we didn't find it sitting in an undisclosed shadow (or shadows are disabled)\n    //  now we can just test to see if it would normally be visible or not, provided it's\n    //  attached to the main document.\n    // NOTE: We must consider case where node is inside a shadow DOM and given directly to\n    //  `isTabbable()` or `isFocusable()` -- regardless of `getShadowRoot` option setting.\n\n    if (isNodeAttached(node)) {\n      // this works wherever the node is: if there's at least one client rect, it's\n      //  somehow displayed; it also covers the CSS 'display: contents' case where the\n      //  node itself is hidden in place of its contents; and there's no need to search\n      //  up the hierarchy either\n      return !node.getClientRects().length;\n    }\n\n    // Else, the node isn't attached to the document, which means the `getClientRects()`\n    //  API will __always__ return zero rects (this can happen, for example, if React\n    //  is used to render nodes onto a detached tree, as confirmed in this thread:\n    //  https://github.com/facebook/react/issues/9117#issuecomment-284228870)\n    //\n    // It also means that even window.getComputedStyle(node).display will return `undefined`\n    //  because styles are only computed for nodes that are in the document.\n    //\n    // NOTE: THIS HAS BEEN THE CASE FOR YEARS. It is not new, nor is it caused by tabbable\n    //  somehow. Though it was never stated officially, anyone who has ever used tabbable\n    //  APIs on nodes in detached containers has actually implicitly used tabbable in what\n    //  was later (as of v5.2.0 on Apr 9, 2021) called `displayCheck=\"none\"` mode -- essentially\n    //  considering __everything__ to be visible because of the innability to determine styles.\n    //\n    // v6.0.0: As of this major release, the default 'full' option __no longer treats detached\n    //  nodes as visible with the 'none' fallback.__\n    if (displayCheck !== 'legacy-full') {\n      return true; // hidden\n    }\n    // else, fallback to 'none' mode and consider the node visible\n  } else if (displayCheck === 'non-zero-area') {\n    // NOTE: Even though this tests that the node's client rect is non-zero to determine\n    //  whether it's displayed, and that a detached node will __always__ have a zero-area\n    //  client rect, we don't special-case for whether the node is attached or not. In\n    //  this mode, we do want to consider nodes that have a zero area to be hidden at all\n    //  times, and that includes attached or not.\n    return isZeroArea(node);\n  }\n\n  // visible, as far as we can tell, or per current `displayCheck=none` mode, we assume\n  //  it's visible\n  return false;\n};\n\n// form fields (nested) inside a disabled fieldset are not focusable/tabbable\n//  unless they are in the _first_ <legend> element of the top-most disabled\n//  fieldset\nvar isDisabledFromFieldset = function isDisabledFromFieldset(node) {\n  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {\n    var parentNode = node.parentElement;\n    // check if `node` is contained in a disabled <fieldset>\n    while (parentNode) {\n      if (parentNode.tagName === 'FIELDSET' && parentNode.disabled) {\n        // look for the first <legend> among the children of the disabled <fieldset>\n        for (var i = 0; i < parentNode.children.length; i++) {\n          var child = parentNode.children.item(i);\n          // when the first <legend> (in document order) is found\n          if (child.tagName === 'LEGEND') {\n            // if its parent <fieldset> is not nested in another disabled <fieldset>,\n            // return whether `node` is a descendant of its first <legend>\n            return matches.call(parentNode, 'fieldset[disabled] *') ? true : !child.contains(node);\n          }\n        }\n        // the disabled <fieldset> containing `node` has no <legend>\n        return true;\n      }\n      parentNode = parentNode.parentElement;\n    }\n  }\n\n  // else, node's tabbable/focusable state should not be affected by a fieldset's\n  //  enabled/disabled state\n  return false;\n};\nvar isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable(options, node) {\n  if (node.disabled ||\n  // we must do an inert look up to filter out any elements inside an inert ancestor\n  //  because we're limited in the type of selectors we can use in JSDom (see related\n  //  note related to `candidateSelectors`)\n  isInert(node) || isHiddenInput(node) || isHidden(node, options) ||\n  // For a details element with a summary, the summary element gets the focus\n  isDetailsWithSummary(node) || isDisabledFromFieldset(node)) {\n    return false;\n  }\n  return true;\n};\nvar isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable(options, node) {\n  if (isNonTabbableRadio(node) || getTabIndex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) {\n    return false;\n  }\n  return true;\n};\nvar isValidShadowRootTabbable = function isValidShadowRootTabbable(shadowHostNode) {\n  var tabIndex = parseInt(shadowHostNode.getAttribute('tabindex'), 10);\n  if (isNaN(tabIndex) || tabIndex >= 0) {\n    return true;\n  }\n  // If a custom element has an explicit negative tabindex,\n  // browsers will not allow tab targeting said element's children.\n  return false;\n};\n\n/**\n * @param {Array.<Element|CandidateScope>} candidates\n * @returns Element[]\n */\nvar sortByOrder = function sortByOrder(candidates) {\n  var regularTabbables = [];\n  var orderedTabbables = [];\n  candidates.forEach(function (item, i) {\n    var isScope = !!item.scopeParent;\n    var element = isScope ? item.scopeParent : item;\n    var candidateTabindex = getSortOrderTabIndex(element, isScope);\n    var elements = isScope ? sortByOrder(item.candidates) : element;\n    if (candidateTabindex === 0) {\n      isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element);\n    } else {\n      orderedTabbables.push({\n        documentOrder: i,\n        tabIndex: candidateTabindex,\n        item: item,\n        isScope: isScope,\n        content: elements\n      });\n    }\n  });\n  return orderedTabbables.sort(sortOrderedTabbables).reduce(function (acc, sortable) {\n    sortable.isScope ? acc.push.apply(acc, sortable.content) : acc.push(sortable.content);\n    return acc;\n  }, []).concat(regularTabbables);\n};\nvar tabbable = function tabbable(container, options) {\n  options = options || {};\n  var candidates;\n  if (options.getShadowRoot) {\n    candidates = getCandidatesIteratively([container], options.includeContainer, {\n      filter: isNodeMatchingSelectorTabbable.bind(null, options),\n      flatten: false,\n      getShadowRoot: options.getShadowRoot,\n      shadowRootFilter: isValidShadowRootTabbable\n    });\n  } else {\n    candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));\n  }\n  return sortByOrder(candidates);\n};\nvar focusable = function focusable(container, options) {\n  options = options || {};\n  var candidates;\n  if (options.getShadowRoot) {\n    candidates = getCandidatesIteratively([container], options.includeContainer, {\n      filter: isNodeMatchingSelectorFocusable.bind(null, options),\n      flatten: true,\n      getShadowRoot: options.getShadowRoot\n    });\n  } else {\n    candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));\n  }\n  return candidates;\n};\nvar isTabbable = function isTabbable(node, options) {\n  options = options || {};\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (matches.call(node, candidateSelector) === false) {\n    return false;\n  }\n  return isNodeMatchingSelectorTabbable(options, node);\n};\nvar focusableCandidateSelector = /* #__PURE__ */candidateSelectors.concat('iframe').join(',');\nvar isFocusable = function isFocusable(node, options) {\n  options = options || {};\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (matches.call(node, focusableCandidateSelector) === false) {\n    return false;\n  }\n  return isNodeMatchingSelectorFocusable(options, node);\n};\n\nexport { focusable, getTabIndex, isFocusable, isTabbable, tabbable };\n//# sourceMappingURL=index.esm.js.map\n","/*!\n* focus-trap 7.5.4\n* @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE\n*/\nimport { isFocusable, tabbable, focusable, isTabbable, getTabIndex } from 'tabbable';\n\nfunction ownKeys(e, r) {\n  var t = Object.keys(e);\n  if (Object.getOwnPropertySymbols) {\n    var o = Object.getOwnPropertySymbols(e);\n    r && (o = o.filter(function (r) {\n      return Object.getOwnPropertyDescriptor(e, r).enumerable;\n    })), t.push.apply(t, o);\n  }\n  return t;\n}\nfunction _objectSpread2(e) {\n  for (var r = 1; r < arguments.length; r++) {\n    var t = null != arguments[r] ? arguments[r] : {};\n    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {\n      _defineProperty(e, r, t[r]);\n    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {\n      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));\n    });\n  }\n  return e;\n}\nfunction _defineProperty(obj, key, value) {\n  key = _toPropertyKey(key);\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}\nfunction _toPrimitive(input, hint) {\n  if (typeof input !== \"object\" || input === null) return input;\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (typeof res !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}\nfunction _toPropertyKey(arg) {\n  var key = _toPrimitive(arg, \"string\");\n  return typeof key === \"symbol\" ? key : String(key);\n}\n\nvar activeFocusTraps = {\n  activateTrap: function activateTrap(trapStack, trap) {\n    if (trapStack.length > 0) {\n      var activeTrap = trapStack[trapStack.length - 1];\n      if (activeTrap !== trap) {\n        activeTrap.pause();\n      }\n    }\n    var trapIndex = trapStack.indexOf(trap);\n    if (trapIndex === -1) {\n      trapStack.push(trap);\n    } else {\n      // move this existing trap to the front of the queue\n      trapStack.splice(trapIndex, 1);\n      trapStack.push(trap);\n    }\n  },\n  deactivateTrap: function deactivateTrap(trapStack, trap) {\n    var trapIndex = trapStack.indexOf(trap);\n    if (trapIndex !== -1) {\n      trapStack.splice(trapIndex, 1);\n    }\n    if (trapStack.length > 0) {\n      trapStack[trapStack.length - 1].unpause();\n    }\n  }\n};\nvar isSelectableInput = function isSelectableInput(node) {\n  return node.tagName && node.tagName.toLowerCase() === 'input' && typeof node.select === 'function';\n};\nvar isEscapeEvent = function isEscapeEvent(e) {\n  return (e === null || e === void 0 ? void 0 : e.key) === 'Escape' || (e === null || e === void 0 ? void 0 : e.key) === 'Esc' || (e === null || e === void 0 ? void 0 : e.keyCode) === 27;\n};\nvar isTabEvent = function isTabEvent(e) {\n  return (e === null || e === void 0 ? void 0 : e.key) === 'Tab' || (e === null || e === void 0 ? void 0 : e.keyCode) === 9;\n};\n\n// checks for TAB by default\nvar isKeyForward = function isKeyForward(e) {\n  return isTabEvent(e) && !e.shiftKey;\n};\n\n// checks for SHIFT+TAB by default\nvar isKeyBackward = function isKeyBackward(e) {\n  return isTabEvent(e) && e.shiftKey;\n};\nvar delay = function delay(fn) {\n  return setTimeout(fn, 0);\n};\n\n// Array.find/findIndex() are not supported on IE; this replicates enough\n//  of Array.findIndex() for our needs\nvar findIndex = function findIndex(arr, fn) {\n  var idx = -1;\n  arr.every(function (value, i) {\n    if (fn(value)) {\n      idx = i;\n      return false; // break\n    }\n\n    return true; // next\n  });\n\n  return idx;\n};\n\n/**\n * Get an option's value when it could be a plain value, or a handler that provides\n *  the value.\n * @param {*} value Option's value to check.\n * @param {...*} [params] Any parameters to pass to the handler, if `value` is a function.\n * @returns {*} The `value`, or the handler's returned value.\n */\nvar valueOrHandler = function valueOrHandler(value) {\n  for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    params[_key - 1] = arguments[_key];\n  }\n  return typeof value === 'function' ? value.apply(void 0, params) : value;\n};\nvar getActualTarget = function getActualTarget(event) {\n  // NOTE: If the trap is _inside_ a shadow DOM, event.target will always be the\n  //  shadow host. However, event.target.composedPath() will be an array of\n  //  nodes \"clicked\" from inner-most (the actual element inside the shadow) to\n  //  outer-most (the host HTML document). If we have access to composedPath(),\n  //  then use its first element; otherwise, fall back to event.target (and\n  //  this only works for an _open_ shadow DOM; otherwise,\n  //  composedPath()[0] === event.target always).\n  return event.target.shadowRoot && typeof event.composedPath === 'function' ? event.composedPath()[0] : event.target;\n};\n\n// NOTE: this must be _outside_ `createFocusTrap()` to make sure all traps in this\n//  current instance use the same stack if `userOptions.trapStack` isn't specified\nvar internalTrapStack = [];\nvar createFocusTrap = function createFocusTrap(elements, userOptions) {\n  // SSR: a live trap shouldn't be created in this type of environment so this\n  //  should be safe code to execute if the `document` option isn't specified\n  var doc = (userOptions === null || userOptions === void 0 ? void 0 : userOptions.document) || document;\n  var trapStack = (userOptions === null || userOptions === void 0 ? void 0 : userOptions.trapStack) || internalTrapStack;\n  var config = _objectSpread2({\n    returnFocusOnDeactivate: true,\n    escapeDeactivates: true,\n    delayInitialFocus: true,\n    isKeyForward: isKeyForward,\n    isKeyBackward: isKeyBackward\n  }, userOptions);\n  var state = {\n    // containers given to createFocusTrap()\n    // @type {Array<HTMLElement>}\n    containers: [],\n    // list of objects identifying tabbable nodes in `containers` in the trap\n    // NOTE: it's possible that a group has no tabbable nodes if nodes get removed while the trap\n    //  is active, but the trap should never get to a state where there isn't at least one group\n    //  with at least one tabbable node in it (that would lead to an error condition that would\n    //  result in an error being thrown)\n    // @type {Array<{\n    //   container: HTMLElement,\n    //   tabbableNodes: Array<HTMLElement>, // empty if none\n    //   focusableNodes: Array<HTMLElement>, // empty if none\n    //   posTabIndexesFound: boolean,\n    //   firstTabbableNode: HTMLElement|undefined,\n    //   lastTabbableNode: HTMLElement|undefined,\n    //   firstDomTabbableNode: HTMLElement|undefined,\n    //   lastDomTabbableNode: HTMLElement|undefined,\n    //   nextTabbableNode: (node: HTMLElement, forward: boolean) => HTMLElement|undefined\n    // }>}\n    containerGroups: [],\n    // same order/length as `containers` list\n\n    // references to objects in `containerGroups`, but only those that actually have\n    //  tabbable nodes in them\n    // NOTE: same order as `containers` and `containerGroups`, but __not necessarily__\n    //  the same length\n    tabbableGroups: [],\n    nodeFocusedBeforeActivation: null,\n    mostRecentlyFocusedNode: null,\n    active: false,\n    paused: false,\n    // timer ID for when delayInitialFocus is true and initial focus in this trap\n    //  has been delayed during activation\n    delayInitialFocusTimer: undefined,\n    // the most recent KeyboardEvent for the configured nav key (typically [SHIFT+]TAB), if any\n    recentNavEvent: undefined\n  };\n  var trap; // eslint-disable-line prefer-const -- some private functions reference it, and its methods reference private functions, so we must declare here and define later\n\n  /**\n   * Gets a configuration option value.\n   * @param {Object|undefined} configOverrideOptions If true, and option is defined in this set,\n   *  value will be taken from this object. Otherwise, value will be taken from base configuration.\n   * @param {string} optionName Name of the option whose value is sought.\n   * @param {string|undefined} [configOptionName] Name of option to use __instead of__ `optionName`\n   *  IIF `configOverrideOptions` is not defined. Otherwise, `optionName` is used.\n   */\n  var getOption = function getOption(configOverrideOptions, optionName, configOptionName) {\n    return configOverrideOptions && configOverrideOptions[optionName] !== undefined ? configOverrideOptions[optionName] : config[configOptionName || optionName];\n  };\n\n  /**\n   * Finds the index of the container that contains the element.\n   * @param {HTMLElement} element\n   * @param {Event} [event] If available, and `element` isn't directly found in any container,\n   *  the event's composed path is used to see if includes any known trap containers in the\n   *  case where the element is inside a Shadow DOM.\n   * @returns {number} Index of the container in either `state.containers` or\n   *  `state.containerGroups` (the order/length of these lists are the same); -1\n   *  if the element isn't found.\n   */\n  var findContainerIndex = function findContainerIndex(element, event) {\n    var composedPath = typeof (event === null || event === void 0 ? void 0 : event.composedPath) === 'function' ? event.composedPath() : undefined;\n    // NOTE: search `containerGroups` because it's possible a group contains no tabbable\n    //  nodes, but still contains focusable nodes (e.g. if they all have `tabindex=-1`)\n    //  and we still need to find the element in there\n    return state.containerGroups.findIndex(function (_ref) {\n      var container = _ref.container,\n        tabbableNodes = _ref.tabbableNodes;\n      return container.contains(element) || ( // fall back to explicit tabbable search which will take into consideration any\n      //  web components if the `tabbableOptions.getShadowRoot` option was used for\n      //  the trap, enabling shadow DOM support in tabbable (`Node.contains()` doesn't\n      //  look inside web components even if open)\n      composedPath === null || composedPath === void 0 ? void 0 : composedPath.includes(container)) || tabbableNodes.find(function (node) {\n        return node === element;\n      });\n    });\n  };\n\n  /**\n   * Gets the node for the given option, which is expected to be an option that\n   *  can be either a DOM node, a string that is a selector to get a node, `false`\n   *  (if a node is explicitly NOT given), or a function that returns any of these\n   *  values.\n   * @param {string} optionName\n   * @returns {undefined | false | HTMLElement | SVGElement} Returns\n   *  `undefined` if the option is not specified; `false` if the option\n   *  resolved to `false` (node explicitly not given); otherwise, the resolved\n   *  DOM node.\n   * @throws {Error} If the option is set, not `false`, and is not, or does not\n   *  resolve to a node.\n   */\n  var getNodeForOption = function getNodeForOption(optionName) {\n    var optionValue = config[optionName];\n    if (typeof optionValue === 'function') {\n      for (var _len2 = arguments.length, params = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n        params[_key2 - 1] = arguments[_key2];\n      }\n      optionValue = optionValue.apply(void 0, params);\n    }\n    if (optionValue === true) {\n      optionValue = undefined; // use default value\n    }\n\n    if (!optionValue) {\n      if (optionValue === undefined || optionValue === false) {\n        return optionValue;\n      }\n      // else, empty string (invalid), null (invalid), 0 (invalid)\n\n      throw new Error(\"`\".concat(optionName, \"` was specified but was not a node, or did not return a node\"));\n    }\n    var node = optionValue; // could be HTMLElement, SVGElement, or non-empty string at this point\n\n    if (typeof optionValue === 'string') {\n      node = doc.querySelector(optionValue); // resolve to node, or null if fails\n      if (!node) {\n        throw new Error(\"`\".concat(optionName, \"` as selector refers to no known node\"));\n      }\n    }\n    return node;\n  };\n  var getInitialFocusNode = function getInitialFocusNode() {\n    var node = getNodeForOption('initialFocus');\n\n    // false explicitly indicates we want no initialFocus at all\n    if (node === false) {\n      return false;\n    }\n    if (node === undefined || !isFocusable(node, config.tabbableOptions)) {\n      // option not specified nor focusable: use fallback options\n      if (findContainerIndex(doc.activeElement) >= 0) {\n        node = doc.activeElement;\n      } else {\n        var firstTabbableGroup = state.tabbableGroups[0];\n        var firstTabbableNode = firstTabbableGroup && firstTabbableGroup.firstTabbableNode;\n\n        // NOTE: `fallbackFocus` option function cannot return `false` (not supported)\n        node = firstTabbableNode || getNodeForOption('fallbackFocus');\n      }\n    }\n    if (!node) {\n      throw new Error('Your focus-trap needs to have at least one focusable element');\n    }\n    return node;\n  };\n  var updateTabbableNodes = function updateTabbableNodes() {\n    state.containerGroups = state.containers.map(function (container) {\n      var tabbableNodes = tabbable(container, config.tabbableOptions);\n\n      // NOTE: if we have tabbable nodes, we must have focusable nodes; focusable nodes\n      //  are a superset of tabbable nodes since nodes with negative `tabindex` attributes\n      //  are focusable but not tabbable\n      var focusableNodes = focusable(container, config.tabbableOptions);\n      var firstTabbableNode = tabbableNodes.length > 0 ? tabbableNodes[0] : undefined;\n      var lastTabbableNode = tabbableNodes.length > 0 ? tabbableNodes[tabbableNodes.length - 1] : undefined;\n      var firstDomTabbableNode = focusableNodes.find(function (node) {\n        return isTabbable(node);\n      });\n      var lastDomTabbableNode = focusableNodes.slice().reverse().find(function (node) {\n        return isTabbable(node);\n      });\n      var posTabIndexesFound = !!tabbableNodes.find(function (node) {\n        return getTabIndex(node) > 0;\n      });\n      return {\n        container: container,\n        tabbableNodes: tabbableNodes,\n        focusableNodes: focusableNodes,\n        /** True if at least one node with positive `tabindex` was found in this container. */\n        posTabIndexesFound: posTabIndexesFound,\n        /** First tabbable node in container, __tabindex__ order; `undefined` if none. */\n        firstTabbableNode: firstTabbableNode,\n        /** Last tabbable node in container, __tabindex__ order; `undefined` if none. */\n        lastTabbableNode: lastTabbableNode,\n        // NOTE: DOM order is NOT NECESSARILY \"document position\" order, but figuring that out\n        //  would require more than just https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition\n        //  because that API doesn't work with Shadow DOM as well as it should (@see\n        //  https://github.com/whatwg/dom/issues/320) and since this first/last is only needed, so far,\n        //  to address an edge case related to positive tabindex support, this seems like a much easier,\n        //  \"close enough most of the time\" alternative for positive tabindexes which should generally\n        //  be avoided anyway...\n        /** First tabbable node in container, __DOM__ order; `undefined` if none. */\n        firstDomTabbableNode: firstDomTabbableNode,\n        /** Last tabbable node in container, __DOM__ order; `undefined` if none. */\n        lastDomTabbableNode: lastDomTabbableNode,\n        /**\n         * Finds the __tabbable__ node that follows the given node in the specified direction,\n         *  in this container, if any.\n         * @param {HTMLElement} node\n         * @param {boolean} [forward] True if going in forward tab order; false if going\n         *  in reverse.\n         * @returns {HTMLElement|undefined} The next tabbable node, if any.\n         */\n        nextTabbableNode: function nextTabbableNode(node) {\n          var forward = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n          var nodeIdx = tabbableNodes.indexOf(node);\n          if (nodeIdx < 0) {\n            // either not tabbable nor focusable, or was focused but not tabbable (negative tabindex):\n            //  since `node` should at least have been focusable, we assume that's the case and mimic\n            //  what browsers do, which is set focus to the next node in __document position order__,\n            //  regardless of positive tabindexes, if any -- and for reasons explained in the NOTE\n            //  above related to `firstDomTabbable` and `lastDomTabbable` properties, we fall back to\n            //  basic DOM order\n            if (forward) {\n              return focusableNodes.slice(focusableNodes.indexOf(node) + 1).find(function (el) {\n                return isTabbable(el);\n              });\n            }\n            return focusableNodes.slice(0, focusableNodes.indexOf(node)).reverse().find(function (el) {\n              return isTabbable(el);\n            });\n          }\n          return tabbableNodes[nodeIdx + (forward ? 1 : -1)];\n        }\n      };\n    });\n    state.tabbableGroups = state.containerGroups.filter(function (group) {\n      return group.tabbableNodes.length > 0;\n    });\n\n    // throw if no groups have tabbable nodes and we don't have a fallback focus node either\n    if (state.tabbableGroups.length <= 0 && !getNodeForOption('fallbackFocus') // returning false not supported for this option\n    ) {\n      throw new Error('Your focus-trap must have at least one container with at least one tabbable node in it at all times');\n    }\n\n    // NOTE: Positive tabindexes are only properly supported in single-container traps because\n    //  doing it across multiple containers where tabindexes could be all over the place\n    //  would require Tabbable to support multiple containers, would require additional\n    //  specialized Shadow DOM support, and would require Tabbable's multi-container support\n    //  to look at those containers in document position order rather than user-provided\n    //  order (as they are treated in Focus-trap, for legacy reasons). See discussion on\n    //  https://github.com/focus-trap/focus-trap/issues/375 for more details.\n    if (state.containerGroups.find(function (g) {\n      return g.posTabIndexesFound;\n    }) && state.containerGroups.length > 1) {\n      throw new Error(\"At least one node with a positive tabindex was found in one of your focus-trap's multiple containers. Positive tabindexes are only supported in single-container focus-traps.\");\n    }\n  };\n\n  /**\n   * Gets the current activeElement. If it's a web-component and has open shadow-root\n   * it will recursively search inside shadow roots for the \"true\" activeElement.\n   *\n   * @param {Document | ShadowRoot} el\n   *\n   * @returns {HTMLElement} The element that currently has the focus\n   **/\n  var getActiveElement = function getActiveElement(el) {\n    var activeElement = el.activeElement;\n    if (!activeElement) {\n      return;\n    }\n    if (activeElement.shadowRoot && activeElement.shadowRoot.activeElement !== null) {\n      return getActiveElement(activeElement.shadowRoot);\n    }\n    return activeElement;\n  };\n  var tryFocus = function tryFocus(node) {\n    if (node === false) {\n      return;\n    }\n    if (node === getActiveElement(document)) {\n      return;\n    }\n    if (!node || !node.focus) {\n      tryFocus(getInitialFocusNode());\n      return;\n    }\n    node.focus({\n      preventScroll: !!config.preventScroll\n    });\n    // NOTE: focus() API does not trigger focusIn event so set MRU node manually\n    state.mostRecentlyFocusedNode = node;\n    if (isSelectableInput(node)) {\n      node.select();\n    }\n  };\n  var getReturnFocusNode = function getReturnFocusNode(previousActiveElement) {\n    var node = getNodeForOption('setReturnFocus', previousActiveElement);\n    return node ? node : node === false ? false : previousActiveElement;\n  };\n\n  /**\n   * Finds the next node (in either direction) where focus should move according to a\n   *  keyboard focus-in event.\n   * @param {Object} params\n   * @param {Node} [params.target] Known target __from which__ to navigate, if any.\n   * @param {KeyboardEvent|FocusEvent} [params.event] Event to use if `target` isn't known (event\n   *  will be used to determine the `target`). Ignored if `target` is specified.\n   * @param {boolean} [params.isBackward] True if focus should move backward.\n   * @returns {Node|undefined} The next node, or `undefined` if a next node couldn't be\n   *  determined given the current state of the trap.\n   */\n  var findNextNavNode = function findNextNavNode(_ref2) {\n    var target = _ref2.target,\n      event = _ref2.event,\n      _ref2$isBackward = _ref2.isBackward,\n      isBackward = _ref2$isBackward === void 0 ? false : _ref2$isBackward;\n    target = target || getActualTarget(event);\n    updateTabbableNodes();\n    var destinationNode = null;\n    if (state.tabbableGroups.length > 0) {\n      // make sure the target is actually contained in a group\n      // NOTE: the target may also be the container itself if it's focusable\n      //  with tabIndex='-1' and was given initial focus\n      var containerIndex = findContainerIndex(target, event);\n      var containerGroup = containerIndex >= 0 ? state.containerGroups[containerIndex] : undefined;\n      if (containerIndex < 0) {\n        // target not found in any group: quite possible focus has escaped the trap,\n        //  so bring it back into...\n        if (isBackward) {\n          // ...the last node in the last group\n          destinationNode = state.tabbableGroups[state.tabbableGroups.length - 1].lastTabbableNode;\n        } else {\n          // ...the first node in the first group\n          destinationNode = state.tabbableGroups[0].firstTabbableNode;\n        }\n      } else if (isBackward) {\n        // REVERSE\n\n        // is the target the first tabbable node in a group?\n        var startOfGroupIndex = findIndex(state.tabbableGroups, function (_ref3) {\n          var firstTabbableNode = _ref3.firstTabbableNode;\n          return target === firstTabbableNode;\n        });\n        if (startOfGroupIndex < 0 && (containerGroup.container === target || isFocusable(target, config.tabbableOptions) && !isTabbable(target, config.tabbableOptions) && !containerGroup.nextTabbableNode(target, false))) {\n          // an exception case where the target is either the container itself, or\n          //  a non-tabbable node that was given focus (i.e. tabindex is negative\n          //  and user clicked on it or node was programmatically given focus)\n          //  and is not followed by any other tabbable node, in which\n          //  case, we should handle shift+tab as if focus were on the container's\n          //  first tabbable node, and go to the last tabbable node of the LAST group\n          startOfGroupIndex = containerIndex;\n        }\n        if (startOfGroupIndex >= 0) {\n          // YES: then shift+tab should go to the last tabbable node in the\n          //  previous group (and wrap around to the last tabbable node of\n          //  the LAST group if it's the first tabbable node of the FIRST group)\n          var destinationGroupIndex = startOfGroupIndex === 0 ? state.tabbableGroups.length - 1 : startOfGroupIndex - 1;\n          var destinationGroup = state.tabbableGroups[destinationGroupIndex];\n          destinationNode = getTabIndex(target) >= 0 ? destinationGroup.lastTabbableNode : destinationGroup.lastDomTabbableNode;\n        } else if (!isTabEvent(event)) {\n          // user must have customized the nav keys so we have to move focus manually _within_\n          //  the active group: do this based on the order determined by tabbable()\n          destinationNode = containerGroup.nextTabbableNode(target, false);\n        }\n      } else {\n        // FORWARD\n\n        // is the target the last tabbable node in a group?\n        var lastOfGroupIndex = findIndex(state.tabbableGroups, function (_ref4) {\n          var lastTabbableNode = _ref4.lastTabbableNode;\n          return target === lastTabbableNode;\n        });\n        if (lastOfGroupIndex < 0 && (containerGroup.container === target || isFocusable(target, config.tabbableOptions) && !isTabbable(target, config.tabbableOptions) && !containerGroup.nextTabbableNode(target))) {\n          // an exception case where the target is the container itself, or\n          //  a non-tabbable node that was given focus (i.e. tabindex is negative\n          //  and user clicked on it or node was programmatically given focus)\n          //  and is not followed by any other tabbable node, in which\n          //  case, we should handle tab as if focus were on the container's\n          //  last tabbable node, and go to the first tabbable node of the FIRST group\n          lastOfGroupIndex = containerIndex;\n        }\n        if (lastOfGroupIndex >= 0) {\n          // YES: then tab should go to the first tabbable node in the next\n          //  group (and wrap around to the first tabbable node of the FIRST\n          //  group if it's the last tabbable node of the LAST group)\n          var _destinationGroupIndex = lastOfGroupIndex === state.tabbableGroups.length - 1 ? 0 : lastOfGroupIndex + 1;\n          var _destinationGroup = state.tabbableGroups[_destinationGroupIndex];\n          destinationNode = getTabIndex(target) >= 0 ? _destinationGroup.firstTabbableNode : _destinationGroup.firstDomTabbableNode;\n        } else if (!isTabEvent(event)) {\n          // user must have customized the nav keys so we have to move focus manually _within_\n          //  the active group: do this based on the order determined by tabbable()\n          destinationNode = containerGroup.nextTabbableNode(target);\n        }\n      }\n    } else {\n      // no groups available\n      // NOTE: the fallbackFocus option does not support returning false to opt-out\n      destinationNode = getNodeForOption('fallbackFocus');\n    }\n    return destinationNode;\n  };\n\n  // This needs to be done on mousedown and touchstart instead of click\n  // so that it precedes the focus event.\n  var checkPointerDown = function checkPointerDown(e) {\n    var target = getActualTarget(e);\n    if (findContainerIndex(target, e) >= 0) {\n      // allow the click since it ocurred inside the trap\n      return;\n    }\n    if (valueOrHandler(config.clickOutsideDeactivates, e)) {\n      // immediately deactivate the trap\n      trap.deactivate({\n        // NOTE: by setting `returnFocus: false`, deactivate() will do nothing,\n        //  which will result in the outside click setting focus to the node\n        //  that was clicked (and if not focusable, to \"nothing\"); by setting\n        //  `returnFocus: true`, we'll attempt to re-focus the node originally-focused\n        //  on activation (or the configured `setReturnFocus` node), whether the\n        //  outside click was on a focusable node or not\n        returnFocus: config.returnFocusOnDeactivate\n      });\n      return;\n    }\n\n    // This is needed for mobile devices.\n    // (If we'll only let `click` events through,\n    // then on mobile they will be blocked anyways if `touchstart` is blocked.)\n    if (valueOrHandler(config.allowOutsideClick, e)) {\n      // allow the click outside the trap to take place\n      return;\n    }\n\n    // otherwise, prevent the click\n    e.preventDefault();\n  };\n\n  // In case focus escapes the trap for some strange reason, pull it back in.\n  // NOTE: the focusIn event is NOT cancelable, so if focus escapes, it may cause unexpected\n  //  scrolling if the node that got focused was out of view; there's nothing we can do to\n  //  prevent that from happening by the time we discover that focus escaped\n  var checkFocusIn = function checkFocusIn(event) {\n    var target = getActualTarget(event);\n    var targetContained = findContainerIndex(target, event) >= 0;\n\n    // In Firefox when you Tab out of an iframe the Document is briefly focused.\n    if (targetContained || target instanceof Document) {\n      if (targetContained) {\n        state.mostRecentlyFocusedNode = target;\n      }\n    } else {\n      // escaped! pull it back in to where it just left\n      event.stopImmediatePropagation();\n\n      // focus will escape if the MRU node had a positive tab index and user tried to nav forward;\n      //  it will also escape if the MRU node had a 0 tab index and user tried to nav backward\n      //  toward a node with a positive tab index\n      var nextNode; // next node to focus, if we find one\n      var navAcrossContainers = true;\n      if (state.mostRecentlyFocusedNode) {\n        if (getTabIndex(state.mostRecentlyFocusedNode) > 0) {\n          // MRU container index must be >=0 otherwise we wouldn't have it as an MRU node...\n          var mruContainerIdx = findContainerIndex(state.mostRecentlyFocusedNode);\n          // there MAY not be any tabbable nodes in the container if there are at least 2 containers\n          //  and the MRU node is focusable but not tabbable (focus-trap requires at least 1 container\n          //  with at least one tabbable node in order to function, so this could be the other container\n          //  with nothing tabbable in it)\n          var tabbableNodes = state.containerGroups[mruContainerIdx].tabbableNodes;\n          if (tabbableNodes.length > 0) {\n            // MRU tab index MAY not be found if the MRU node is focusable but not tabbable\n            var mruTabIdx = tabbableNodes.findIndex(function (node) {\n              return node === state.mostRecentlyFocusedNode;\n            });\n            if (mruTabIdx >= 0) {\n              if (config.isKeyForward(state.recentNavEvent)) {\n                if (mruTabIdx + 1 < tabbableNodes.length) {\n                  nextNode = tabbableNodes[mruTabIdx + 1];\n                  navAcrossContainers = false;\n                }\n                // else, don't wrap within the container as focus should move to next/previous\n                //  container\n              } else {\n                if (mruTabIdx - 1 >= 0) {\n                  nextNode = tabbableNodes[mruTabIdx - 1];\n                  navAcrossContainers = false;\n                }\n                // else, don't wrap within the container as focus should move to next/previous\n                //  container\n              }\n              // else, don't find in container order without considering direction too\n            }\n          }\n          // else, no tabbable nodes in that container (which means we must have at least one other\n          //  container with at least one tabbable node in it, otherwise focus-trap would've thrown\n          //  an error the last time updateTabbableNodes() was run): find next node among all known\n          //  containers\n        } else {\n          // check to see if there's at least one tabbable node with a positive tab index inside\n          //  the trap because focus seems to escape when navigating backward from a tabbable node\n          //  with tabindex=0 when this is the case (instead of wrapping to the tabbable node with\n          //  the greatest positive tab index like it should)\n          if (!state.containerGroups.some(function (g) {\n            return g.tabbableNodes.some(function (n) {\n              return getTabIndex(n) > 0;\n            });\n          })) {\n            // no containers with tabbable nodes with positive tab indexes which means the focus\n            //  escaped for some other reason and we should just execute the fallback to the\n            //  MRU node or initial focus node, if any\n            navAcrossContainers = false;\n          }\n        }\n      } else {\n        // no MRU node means we're likely in some initial condition when the trap has just\n        //  been activated and initial focus hasn't been given yet, in which case we should\n        //  fall through to trying to focus the initial focus node, which is what should\n        //  happen below at this point in the logic\n        navAcrossContainers = false;\n      }\n      if (navAcrossContainers) {\n        nextNode = findNextNavNode({\n          // move FROM the MRU node, not event-related node (which will be the node that is\n          //  outside the trap causing the focus escape we're trying to fix)\n          target: state.mostRecentlyFocusedNode,\n          isBackward: config.isKeyBackward(state.recentNavEvent)\n        });\n      }\n      if (nextNode) {\n        tryFocus(nextNode);\n      } else {\n        tryFocus(state.mostRecentlyFocusedNode || getInitialFocusNode());\n      }\n    }\n    state.recentNavEvent = undefined; // clear\n  };\n\n  // Hijack key nav events on the first and last focusable nodes of the trap,\n  // in order to prevent focus from escaping. If it escapes for even a\n  // moment it can end up scrolling the page and causing confusion so we\n  // kind of need to capture the action at the keydown phase.\n  var checkKeyNav = function checkKeyNav(event) {\n    var isBackward = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n    state.recentNavEvent = event;\n    var destinationNode = findNextNavNode({\n      event: event,\n      isBackward: isBackward\n    });\n    if (destinationNode) {\n      if (isTabEvent(event)) {\n        // since tab natively moves focus, we wouldn't have a destination node unless we\n        //  were on the edge of a container and had to move to the next/previous edge, in\n        //  which case we want to prevent default to keep the browser from moving focus\n        //  to where it normally would\n        event.preventDefault();\n      }\n      tryFocus(destinationNode);\n    }\n    // else, let the browser take care of [shift+]tab and move the focus\n  };\n\n  var checkKey = function checkKey(event) {\n    if (isEscapeEvent(event) && valueOrHandler(config.escapeDeactivates, event) !== false) {\n      event.preventDefault();\n      trap.deactivate();\n      return;\n    }\n    if (config.isKeyForward(event) || config.isKeyBackward(event)) {\n      checkKeyNav(event, config.isKeyBackward(event));\n    }\n  };\n  var checkClick = function checkClick(e) {\n    var target = getActualTarget(e);\n    if (findContainerIndex(target, e) >= 0) {\n      return;\n    }\n    if (valueOrHandler(config.clickOutsideDeactivates, e)) {\n      return;\n    }\n    if (valueOrHandler(config.allowOutsideClick, e)) {\n      return;\n    }\n    e.preventDefault();\n    e.stopImmediatePropagation();\n  };\n\n  //\n  // EVENT LISTENERS\n  //\n\n  var addListeners = function addListeners() {\n    if (!state.active) {\n      return;\n    }\n\n    // There can be only one listening focus trap at a time\n    activeFocusTraps.activateTrap(trapStack, trap);\n\n    // Delay ensures that the focused element doesn't capture the event\n    // that caused the focus trap activation.\n    state.delayInitialFocusTimer = config.delayInitialFocus ? delay(function () {\n      tryFocus(getInitialFocusNode());\n    }) : tryFocus(getInitialFocusNode());\n    doc.addEventListener('focusin', checkFocusIn, true);\n    doc.addEventListener('mousedown', checkPointerDown, {\n      capture: true,\n      passive: false\n    });\n    doc.addEventListener('touchstart', checkPointerDown, {\n      capture: true,\n      passive: false\n    });\n    doc.addEventListener('click', checkClick, {\n      capture: true,\n      passive: false\n    });\n    doc.addEventListener('keydown', checkKey, {\n      capture: true,\n      passive: false\n    });\n    return trap;\n  };\n  var removeListeners = function removeListeners() {\n    if (!state.active) {\n      return;\n    }\n    doc.removeEventListener('focusin', checkFocusIn, true);\n    doc.removeEventListener('mousedown', checkPointerDown, true);\n    doc.removeEventListener('touchstart', checkPointerDown, true);\n    doc.removeEventListener('click', checkClick, true);\n    doc.removeEventListener('keydown', checkKey, true);\n    return trap;\n  };\n\n  //\n  // MUTATION OBSERVER\n  //\n\n  var checkDomRemoval = function checkDomRemoval(mutations) {\n    var isFocusedNodeRemoved = mutations.some(function (mutation) {\n      var removedNodes = Array.from(mutation.removedNodes);\n      return removedNodes.some(function (node) {\n        return node === state.mostRecentlyFocusedNode;\n      });\n    });\n\n    // If the currently focused is removed then browsers will move focus to the\n    // <body> element. If this happens, try to move focus back into the trap.\n    if (isFocusedNodeRemoved) {\n      tryFocus(getInitialFocusNode());\n    }\n  };\n\n  // Use MutationObserver - if supported - to detect if focused node is removed\n  // from the DOM.\n  var mutationObserver = typeof window !== 'undefined' && 'MutationObserver' in window ? new MutationObserver(checkDomRemoval) : undefined;\n  var updateObservedNodes = function updateObservedNodes() {\n    if (!mutationObserver) {\n      return;\n    }\n    mutationObserver.disconnect();\n    if (state.active && !state.paused) {\n      state.containers.map(function (container) {\n        mutationObserver.observe(container, {\n          subtree: true,\n          childList: true\n        });\n      });\n    }\n  };\n\n  //\n  // TRAP DEFINITION\n  //\n\n  trap = {\n    get active() {\n      return state.active;\n    },\n    get paused() {\n      return state.paused;\n    },\n    activate: function activate(activateOptions) {\n      if (state.active) {\n        return this;\n      }\n      var onActivate = getOption(activateOptions, 'onActivate');\n      var onPostActivate = getOption(activateOptions, 'onPostActivate');\n      var checkCanFocusTrap = getOption(activateOptions, 'checkCanFocusTrap');\n      if (!checkCanFocusTrap) {\n        updateTabbableNodes();\n      }\n      state.active = true;\n      state.paused = false;\n      state.nodeFocusedBeforeActivation = doc.activeElement;\n      onActivate === null || onActivate === void 0 || onActivate();\n      var finishActivation = function finishActivation() {\n        if (checkCanFocusTrap) {\n          updateTabbableNodes();\n        }\n        addListeners();\n        updateObservedNodes();\n        onPostActivate === null || onPostActivate === void 0 || onPostActivate();\n      };\n      if (checkCanFocusTrap) {\n        checkCanFocusTrap(state.containers.concat()).then(finishActivation, finishActivation);\n        return this;\n      }\n      finishActivation();\n      return this;\n    },\n    deactivate: function deactivate(deactivateOptions) {\n      if (!state.active) {\n        return this;\n      }\n      var options = _objectSpread2({\n        onDeactivate: config.onDeactivate,\n        onPostDeactivate: config.onPostDeactivate,\n        checkCanReturnFocus: config.checkCanReturnFocus\n      }, deactivateOptions);\n      clearTimeout(state.delayInitialFocusTimer); // noop if undefined\n      state.delayInitialFocusTimer = undefined;\n      removeListeners();\n      state.active = false;\n      state.paused = false;\n      updateObservedNodes();\n      activeFocusTraps.deactivateTrap(trapStack, trap);\n      var onDeactivate = getOption(options, 'onDeactivate');\n      var onPostDeactivate = getOption(options, 'onPostDeactivate');\n      var checkCanReturnFocus = getOption(options, 'checkCanReturnFocus');\n      var returnFocus = getOption(options, 'returnFocus', 'returnFocusOnDeactivate');\n      onDeactivate === null || onDeactivate === void 0 || onDeactivate();\n      var finishDeactivation = function finishDeactivation() {\n        delay(function () {\n          if (returnFocus) {\n            tryFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation));\n          }\n          onPostDeactivate === null || onPostDeactivate === void 0 || onPostDeactivate();\n        });\n      };\n      if (returnFocus && checkCanReturnFocus) {\n        checkCanReturnFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation)).then(finishDeactivation, finishDeactivation);\n        return this;\n      }\n      finishDeactivation();\n      return this;\n    },\n    pause: function pause(pauseOptions) {\n      if (state.paused || !state.active) {\n        return this;\n      }\n      var onPause = getOption(pauseOptions, 'onPause');\n      var onPostPause = getOption(pauseOptions, 'onPostPause');\n      state.paused = true;\n      onPause === null || onPause === void 0 || onPause();\n      removeListeners();\n      updateObservedNodes();\n      onPostPause === null || onPostPause === void 0 || onPostPause();\n      return this;\n    },\n    unpause: function unpause(unpauseOptions) {\n      if (!state.paused || !state.active) {\n        return this;\n      }\n      var onUnpause = getOption(unpauseOptions, 'onUnpause');\n      var onPostUnpause = getOption(unpauseOptions, 'onPostUnpause');\n      state.paused = false;\n      onUnpause === null || onUnpause === void 0 || onUnpause();\n      updateTabbableNodes();\n      addListeners();\n      updateObservedNodes();\n      onPostUnpause === null || onPostUnpause === void 0 || onPostUnpause();\n      return this;\n    },\n    updateContainerElements: function updateContainerElements(containerElements) {\n      var elementsAsArray = [].concat(containerElements).filter(Boolean);\n      state.containers = elementsAsArray.map(function (element) {\n        return typeof element === 'string' ? doc.querySelector(element) : element;\n      });\n      if (state.active) {\n        updateTabbableNodes();\n      }\n      updateObservedNodes();\n      return this;\n    }\n  };\n\n  // initialize container elements\n  trap.updateContainerElements(elements);\n  return trap;\n};\n\nexport { createFocusTrap };\n//# sourceMappingURL=focus-trap.esm.js.map\n","import { disableScroll, enableScroll } from '@util/scrolling';\r\nimport { createFocusTrap } from 'focus-trap';\r\n\r\nconst mainNavWrapper = document.querySelector('#main-nav-wrapper');\r\nconst mainNav = document.querySelector('#main-nav');\r\nconst mainNavContent = document.querySelector('#main-nav-content');\r\n\r\nconst isPageBuilder = document.body.classList.contains(\r\n  'KenticoAdminPageBuilder'\r\n);\r\n\r\nif (mainNavWrapper && mainNav) {\r\n  let menuIsOpen = false;\r\n  let searchIsOpen = false;\r\n\r\n  const openButton = document.querySelector('#menu-toggle');\r\n  const closeButton = mainNavWrapper.querySelector('#close-main-nav');\r\n\r\n  const focusTrap = createFocusTrap(mainNavWrapper, {\r\n    initialFocus: mainNav,\r\n    fallbackFocus: mainNav,\r\n    preventScroll: true\r\n  });\r\n\r\n  const openMenu = () => {\r\n    menuIsOpen = true;\r\n    mainNavContent?.scrollTo(0, 0);\r\n    mainNavWrapper.classList.add('menu-open', 'initialized');\r\n\r\n    disableScroll();\r\n\r\n    if (!isPageBuilder) focusTrap.activate();\r\n  };\r\n\r\n  const closeMenu = () => {\r\n    menuIsOpen = false;\r\n    mainNavWrapper.classList.remove('menu-open');\r\n\r\n    focusTrap.deactivate();\r\n    enableScroll();\r\n    setTimeout(() => openButton?.blur(), 0);\r\n  };\r\n\r\n  // Open and close the menu\r\n  openButton?.addEventListener('click', e => {\r\n    e.preventDefault();\r\n    openMenu();\r\n  });\r\n\r\n  closeButton?.addEventListener('click', closeMenu);\r\n\r\n  mainNavWrapper.addEventListener('click', e => {\r\n    if (!e.target.closest('#main-nav')) closeMenu();\r\n  });\r\n\r\n  if (!isPageBuilder) {\r\n    window.addEventListener('keydown', e => {\r\n      if (e.key === 'Escape' && !searchIsOpen) {\r\n        closeMenu();\r\n      }\r\n    });\r\n  }\r\n\r\n  let searchOpenTimer;\r\n\r\n  window.addEventListener('globalsearchopen', () => {\r\n    clearTimeout(searchOpenTimer);\r\n    searchIsOpen = true;\r\n    if (menuIsOpen) focusTrap.deactivate();\r\n  });\r\n\r\n  window.addEventListener('globalsearchclose', () => {\r\n    clearTimeout(searchOpenTimer);\r\n\r\n    if (menuIsOpen) {\r\n      focusTrap.activate();\r\n\r\n      searchOpenTimer = setTimeout(() => {\r\n        searchIsOpen = false;\r\n      }, 200);\r\n    } else {\r\n      searchIsOpen = false;\r\n    }\r\n  });\r\n}\r\n","export default function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n  return arr2;\n}","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nexport default function _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}","export default function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}","export default function _iterableToArrayLimit(r, l) {\n  var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"];\n  if (null != t) {\n    var e,\n      n,\n      i,\n      u,\n      a = [],\n      f = !0,\n      o = !1;\n    try {\n      if (i = (t = t.call(r)).next, 0 === l) {\n        if (Object(t) !== t) return;\n        f = !1;\n      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);\n    } catch (r) {\n      o = !0, n = r;\n    } finally {\n      try {\n        if (!f && null != t[\"return\"] && (u = t[\"return\"](), Object(u) !== u)) return;\n      } finally {\n        if (o) throw n;\n      }\n    }\n    return a;\n  }\n}","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nexport default function _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}","export default function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","const sidebar = document.querySelector('#article-sidebar');\r\n\r\nif (sidebar && !document.body.classList.contains('KenticoAdminPageBuilder')) {\r\n  const sidebarContent = sidebar.querySelector('#article-sidebar-content');\r\n\r\n  // Disable sticky sidebar if it's taller than the viewport\r\n  if (sidebarContent) {\r\n    const setStickySidebar = () => {\r\n      sidebarContent.classList.toggle(\r\n        'disable-sticky',\r\n        sidebarContent.offsetHeight >= window.innerHeight\r\n      );\r\n    };\r\n\r\n    setStickySidebar();\r\n\r\n    window.addEventListener('resize', setStickySidebar);\r\n  }\r\n\r\n  const tableOfContents = sidebar.querySelector('.table-of-contents');\r\n\r\n  if (tableOfContents) {\r\n    // Highlight the current section in the table of contents\r\n    const sections = document.querySelectorAll(\r\n      '.article-section[data-table-of-contents=\"true\"]'\r\n    );\r\n\r\n    if (window.IntersectionObserver && sections.length) {\r\n      const sentinel = document.querySelector('.sidebar-sentinel');\r\n\r\n      if (sentinel) {\r\n        const sentinelObserver = new IntersectionObserver(([entry]) => {\r\n          tableOfContents.classList.toggle(\r\n            'show-active',\r\n            !entry.isIntersecting\r\n          );\r\n        });\r\n\r\n        sentinelObserver.observe(sentinel);\r\n      }\r\n\r\n      const intersectionData = {};\r\n      window.intersectionData = intersectionData;\r\n\r\n      let isScrollingToSection = false;\r\n      let scrollTimer = null;\r\n      let intersectionTimer = null;\r\n\r\n      // Smooth scroll to section and don't change page URL\r\n      tableOfContents.querySelectorAll('a').forEach(link => {\r\n        link.addEventListener('click', e => {\r\n          if (!link.hash) return;\r\n\r\n          const section = document.querySelector(link.hash);\r\n          if (!section || !intersectionData[section.id]) return;\r\n\r\n          e.preventDefault();\r\n\r\n          const { listItem } = intersectionData[section.id];\r\n\r\n          if (listItem) {\r\n            isScrollingToSection = true;\r\n\r\n            clearTimeout(scrollTimer);\r\n            clearTimeout(intersectionTimer);\r\n\r\n            tableOfContents\r\n              .querySelectorAll('li.current')\r\n              .forEach(el => el.classList.remove('current'));\r\n\r\n            listItem.classList.add('current');\r\n          }\r\n\r\n          section.scrollIntoView({ behavior: 'smooth' });\r\n        });\r\n      });\r\n\r\n      const enableIntersectionChecks = () => {\r\n        if (!isScrollingToSection) return;\r\n\r\n        clearTimeout(scrollTimer);\r\n        isScrollingToSection = false;\r\n        handleIntersection();\r\n      };\r\n\r\n      window.addEventListener('scroll', () => {\r\n        if (!isScrollingToSection) return;\r\n\r\n        clearTimeout(scrollTimer);\r\n        scrollTimer = setTimeout(enableIntersectionChecks, 100);\r\n      });\r\n\r\n      window.addEventListener('wheel', enableIntersectionChecks);\r\n      window.addEventListener('touchmove', enableIntersectionChecks);\r\n\r\n      const handleIntersection = () => {\r\n        clearTimeout(intersectionTimer);\r\n\r\n        if (isScrollingToSection) return;\r\n\r\n        intersectionTimer = setTimeout(() => {\r\n          if (isScrollingToSection) return;\r\n          let currentSectionId = null;\r\n\r\n          Object.keys(intersectionData).forEach(id => {\r\n            const { ratio, index } = intersectionData[id];\r\n\r\n            if (ratio <= 0) return;\r\n            if (currentSectionId === null) {\r\n              currentSectionId = id;\r\n            } else {\r\n              const currentSection = intersectionData[currentSectionId];\r\n\r\n              if (\r\n                ratio > currentSection.ratio ||\r\n                (ratio === currentSection.ratio && index < currentSection.index)\r\n              ) {\r\n                currentSectionId = id;\r\n              }\r\n            }\r\n          });\r\n\r\n          tableOfContents\r\n            .querySelectorAll('li.current')\r\n            .forEach(el => el.classList.remove('current'));\r\n\r\n          if (currentSectionId === null) return;\r\n\r\n          const { listItem } = intersectionData[currentSectionId];\r\n          if (!listItem) return;\r\n\r\n          listItem?.classList.add('current');\r\n        }, 5);\r\n      };\r\n\r\n      const sectionObserver = new IntersectionObserver(\r\n        entries => {\r\n          let entry = null;\r\n\r\n          entries.forEach(item => {\r\n            if (!entry || item.intersectionRatio > entry.intersectionRatio) {\r\n              entry = item;\r\n            }\r\n          });\r\n\r\n          if (!entry) return;\r\n\r\n          const { target, intersectionRatio } = entry;\r\n\r\n          if (intersectionData[entry.target.id]) {\r\n            intersectionData[target.id].ratio = Math.round(\r\n              intersectionRatio * 10\r\n            );\r\n\r\n            intersectionData[target.id].entry = entry;\r\n          }\r\n\r\n          handleIntersection();\r\n        },\r\n        {\r\n          threshold: [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]\r\n        }\r\n      );\r\n\r\n      sections.forEach((section, index) => {\r\n        if (!section.id) return;\r\n        const link = tableOfContents.querySelector(`a[href=\"#${section.id}\"]`);\r\n        const listItem = link?.closest('li');\r\n        if (!listItem) return;\r\n\r\n        intersectionData[section.id] = { section, listItem, index, ratio: 0 };\r\n        sectionObserver.observe(section);\r\n      });\r\n    }\r\n  }\r\n}\r\n","export default function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, _typeof(o);\n}","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\nexport default function _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n      args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n      _next(undefined);\n    });\n  };\n}","const dateFormatter = new Intl.DateTimeFormat('en-US', {\r\n  month: 'short',\r\n  day: 'numeric',\r\n  year: 'numeric'\r\n});\r\n\r\nexport default function createArticleCard(\r\n  data,\r\n  tagName = 'li',\r\n  className = 'article-card',\r\n  headlineTagName = 'h2'\r\n) {\r\n  if (!data?.headline || !data?.url) return null;\r\n\r\n  const { headline, url, image, tags, postDate, timeToRead } = data;\r\n\r\n  // Wrapper\r\n  const wrapper = document.createElement(tagName);\r\n  wrapper.className = className;\r\n\r\n  // Thumbnail\r\n  if (image) {\r\n    const imgLink = document.createElement('a');\r\n    imgLink.className = 'article-thumb';\r\n    imgLink.href = url;\r\n\r\n    const img = document.createElement('img');\r\n    img.src = image;\r\n    img.alt = '';\r\n\r\n    imgLink.append(img);\r\n    wrapper.append(imgLink);\r\n  }\r\n\r\n  // Tags\r\n  if (Array.isArray(tags) && tags.length) {\r\n    const tagsList = document.createElement('ul');\r\n    tagsList.className = 'article-tags';\r\n\r\n    tags.forEach(tag => {\r\n      if (!tag.name) return;\r\n\r\n      const tagWrapper = document.createElement('li');\r\n\r\n      const tagEl = document.createElement(tag.url ? 'a' : 'span');\r\n      tagEl.className = 'tag';\r\n      tagEl.innerText = tag.name;\r\n\r\n      if (tag.url) tagEl.href = tag.url;\r\n      if (tag.isMainCategory) tagEl.classList.add('primary');\r\n      if (tag.isHighlighted) tagEl.classList.add('highlight');\r\n\r\n      tagWrapper.append(tagEl);\r\n      tagsList.append(tagWrapper);\r\n    });\r\n\r\n    wrapper.append(tagsList);\r\n  }\r\n\r\n  // Headline\r\n  const headlineLink = document.createElement('a');\r\n  headlineLink.href = url;\r\n\r\n  const headlineEl = document.createElement(headlineTagName);\r\n  headlineEl.innerText = headline;\r\n\r\n  headlineLink.append(headlineEl);\r\n  wrapper.append(headlineLink);\r\n\r\n  // Metadata\r\n  const date = !postDate ? null : new Date(postDate);\r\n  const hasDate = date && !isNaN(date) && date.getFullYear() > 1970;\r\n\r\n  if (hasDate || timeToRead) {\r\n    const meta = document.createElement('div');\r\n    meta.className = 'article-meta';\r\n\r\n    if (hasDate) {\r\n      const dateEl = document.createElement('time');\r\n      dateEl.dateTime = date.toISOString();\r\n      dateEl.innerText = dateFormatter.format(date);\r\n\r\n      meta.append(dateEl);\r\n    }\r\n\r\n    if (timeToRead) {\r\n      const timeToReadEl = document.createElement('span');\r\n      timeToReadEl.innerText = `${timeToRead} min read`;\r\n\r\n      meta.append(timeToReadEl);\r\n    }\r\n\r\n    wrapper.append(meta);\r\n  }\r\n\r\n  return wrapper;\r\n}\r\n","import createArticleCard from './util/create-article-card';\r\n\r\nconst wrapper = document.querySelector('#article-listing');\r\nconst listing = wrapper?.querySelector('.post-listing');\r\n\r\nif (wrapper && listing) {\r\n  // The listing pages can support filtering by multiple tags, but\r\n  // it can often lead to no results when multiple tags are selected.\r\n  // By default we disable this feature, but it can be enabled by\r\n  // setting a global variable on the window object\r\n  const supportMultipleTags = () => window.supportMultipleTags ?? false;\r\n\r\n  const endpoint = '/apis/micrositeapi/getarticlecards';\r\n  const filterWrapper = wrapper.querySelector('.article-tag-filters');\r\n  const allTagsButton = filterWrapper?.querySelector('.all-tags');\r\n  const tagButtons = Array.from(\r\n    filterWrapper?.querySelectorAll('.tag:not(.all-tags)') ?? []\r\n  );\r\n\r\n  const loadMoreWrapper = wrapper.querySelector('#listing-load-more');\r\n  const loadMoreButton = loadMoreWrapper.querySelector('.load-more');\r\n  const noPostsMessage = wrapper.querySelector('#listing-no-posts');\r\n  const errorMessage = wrapper.querySelector('#listing-error');\r\n\r\n  const rootId = wrapper.dataset.root;\r\n  const categoryId = wrapper.dataset.category || 0;\r\n\r\n  let currentPage = 0;\r\n  let isLoading = false;\r\n  let canLoadMore = !loadMoreWrapper.classList.contains('hidden');\r\n  const loadMoreText = loadMoreButton.innerText;\r\n\r\n  const toggleButton = (button, isActive) => {\r\n    if (!button) return;\r\n    button.classList.toggle('active', isActive);\r\n    button.setAttribute('aria-pressed', isActive);\r\n  };\r\n\r\n  const getSelectedTags = () => {\r\n    return tagButtons\r\n      .filter(b => b.classList.contains('active'))\r\n      .map(b => b.dataset.tag)\r\n      .filter(id => id && id !== categoryId);\r\n  };\r\n\r\n  const getCurrentFiltersKey = () => {\r\n    return `${categoryId}-${currentPage}-${getSelectedTags().join('-')}`;\r\n  };\r\n\r\n  let currentFiltersKey = getCurrentFiltersKey();\r\n  const cachedData = {};\r\n\r\n  const setPostsFocusable = canFocus => {\r\n    listing.querySelectorAll('a').forEach(link => {\r\n      if (canFocus) {\r\n        link.removeAttribute('tabindex');\r\n      } else {\r\n        link.tabIndex = -1;\r\n      }\r\n    });\r\n\r\n    if (document.activeElement?.closest('.post-listing')) {\r\n      document.activeElement.blur();\r\n      listing.tabIndex = -1;\r\n      setTimeout(() => listing.focus());\r\n    }\r\n  };\r\n\r\n  const fetchPosts = async isLoadMore => {\r\n    currentPage = isLoadMore ? currentPage + 1 : 0;\r\n\r\n    // If a subsequent request finishes before this one,\r\n    // we dont update the UI with the stale data\r\n    const filtersKey = getCurrentFiltersKey();\r\n    currentFiltersKey = filtersKey;\r\n\r\n    const tags = getSelectedTags();\r\n\r\n    if (cachedData[filtersKey]) {\r\n      refreshPostListing(cachedData[filtersKey], tags, isLoadMore);\r\n      return;\r\n    }\r\n\r\n    isLoading = true;\r\n\r\n    const url = new URL(endpoint, window.location.origin);\r\n    const minLoadingUiDelay = window.minLoadingUiDelay ?? 100;\r\n    const minLoadingUiDuration = window.minLoadingUiDuration ?? 350;\r\n\r\n    url.searchParams.set('root', rootId);\r\n    url.searchParams.set('category', categoryId);\r\n    url.searchParams.set('page', currentPage);\r\n    if (tags.length) url.searchParams.set('tags', tags.join('-'));\r\n\r\n    // Wait for a minimum delay before showing the loading UI, and\r\n    // keep it visibile for a minimum duration to avoid flickering\r\n    // let canShowNewPosts = true;\r\n    let loadingUiPromise = Promise.resolve();\r\n\r\n    loadMoreButton.disabled = true;\r\n    if (isLoadMore) loadMoreButton.innerText = 'Loading articles…';\r\n\r\n    const loadingUiTimeout = setTimeout(() => {\r\n      if (!isLoadMore && filtersKey === currentFiltersKey) {\r\n        listing.classList.add('loading');\r\n        setPostsFocusable(false);\r\n      }\r\n\r\n      loadingUiPromise = new Promise(resolve => {\r\n        setTimeout(resolve, minLoadingUiDuration);\r\n      });\r\n    }, minLoadingUiDelay);\r\n\r\n    try {\r\n      const res = await fetch(url);\r\n      const data = (await res.json()) ?? {};\r\n\r\n      if ('posts' in data && 'areMorePostsAvailable' in data) {\r\n        cachedData[filtersKey] = data;\r\n      }\r\n\r\n      clearTimeout(loadingUiTimeout);\r\n      await loadingUiPromise;\r\n\r\n      if (filtersKey !== currentFiltersKey) return;\r\n\r\n      if (typeof data !== 'object' || !Array.isArray(data.posts)) {\r\n        throw new Error('Invalid response');\r\n      }\r\n\r\n      refreshPostListing(data, tags, isLoadMore);\r\n    } catch (error) {\r\n      console.error('Failed to fetch posts', error);\r\n\r\n      if (filtersKey !== currentFiltersKey) return;\r\n\r\n      isLoading = false;\r\n      canLoadMore = false;\r\n      loadMoreButton.disabled = false;\r\n      loadMoreButton.innerText = loadMoreText;\r\n      listing.classList.remove('loading');\r\n      errorMessage.classList.remove('hidden');\r\n      listing.classList.add('hidden');\r\n      noPostsMessage.classList.add('hidden');\r\n      loadMoreWrapper.classList.add('hidden');\r\n      setPostsFocusable(true);\r\n    }\r\n  };\r\n\r\n  const refreshPostListing = (data, tags, isLoadMore) => {\r\n    const { posts, areMorePostsAvailable } = data;\r\n\r\n    isLoading = false;\r\n    loadMoreButton.disabled = false;\r\n    loadMoreButton.innerText = loadMoreText;\r\n    listing.classList.remove('loading');\r\n    errorMessage.classList.add('hidden');\r\n    canLoadMore = posts.length && areMorePostsAvailable;\r\n    loadMoreWrapper.classList.toggle('hidden', !canLoadMore);\r\n\r\n    if (!posts.length) {\r\n      if (!isLoadMore) listing.innerText = '';\r\n\r\n      noPostsMessage\r\n        .querySelector('.has-tags')\r\n        ?.classList.toggle('hidden', !!tags.length);\r\n      noPostsMessage\r\n        .querySelector('.no-tags')\r\n        ?.classList.toggle('hidden', !tags.length);\r\n      noPostsMessage.classList.remove('hidden');\r\n\r\n      return;\r\n    }\r\n\r\n    listing.classList.remove('hidden');\r\n    noPostsMessage.classList.add('hidden');\r\n\r\n    const fragment = document.createDocumentFragment();\r\n\r\n    posts.forEach(post => {\r\n      const card = createArticleCard(post);\r\n      if (card) fragment.append(card);\r\n    });\r\n\r\n    if (!isLoadMore) listing.innerText = '';\r\n\r\n    listing.append(fragment);\r\n\r\n    setPostsFocusable(true);\r\n  };\r\n\r\n  // Select individual tag\r\n  tagButtons.forEach(button => {\r\n    button.addEventListener('click', () => {\r\n      const isActive = button.classList.contains('active');\r\n\r\n      if (isActive) {\r\n        if (!supportMultipleTags()) return;\r\n\r\n        toggleButton(button, false);\r\n\r\n        if (!tagButtons.some(b => b.classList.contains('active'))) {\r\n          toggleButton(allTagsButton, true);\r\n        }\r\n      } else {\r\n        if (!supportMultipleTags()) {\r\n          tagButtons.forEach(b => toggleButton(b, false));\r\n        }\r\n\r\n        toggleButton(button, true);\r\n        toggleButton(allTagsButton, false);\r\n      }\r\n\r\n      fetchPosts();\r\n    });\r\n  });\r\n\r\n  // Select all tags\r\n  allTagsButton?.addEventListener('click', () => {\r\n    const isActive = allTagsButton.classList.contains('active');\r\n\r\n    if (isActive) {\r\n      if (!getSelectedTags().length) return;\r\n      toggleButton(allTagsButton, false);\r\n    } else {\r\n      toggleButton(allTagsButton, true);\r\n      tagButtons.forEach(b => toggleButton(b, false));\r\n    }\r\n\r\n    fetchPosts();\r\n  });\r\n\r\n  // Show more tags\r\n  wrapper.querySelectorAll('.show-more-tags').forEach(showMoreTagsButton => {\r\n    showMoreTagsButton.addEventListener('click', () => {\r\n      showMoreTagsButton\r\n        .closest('.article-tags')\r\n        ?.querySelectorAll('li')\r\n        .forEach(li => li.classList.remove('hidden'));\r\n\r\n      showMoreTagsButton.closest('li')?.classList.add('hidden');\r\n    });\r\n  });\r\n\r\n  // Load more posts\r\n  loadMoreButton.addEventListener('click', () => {\r\n    if (!canLoadMore || isLoading) return;\r\n    fetchPosts(true);\r\n  });\r\n\r\n  // Disable clicking on articles while loading\r\n  listing.addEventListener(\r\n    'click',\r\n    e => {\r\n      if (isLoading) e.preventDefault();\r\n    },\r\n    { capture: true }\r\n  );\r\n}\r\n","import './styles/main.scss';\r\nimport './scripts/menu';\r\nimport './scripts/sidebar';\r\nimport './scripts/listing';\r\nimport './scripts/tab-slider';\r\nimport './scripts/forms';\r\n\r\n// Disable animations while resizing\r\nlet resizeTimer = null;\r\n\r\nwindow.addEventListener('resize', () => {\r\n  if (!resizeTimer) document.body.classList.add('resizing');\r\n  clearTimeout(resizeTimer);\r\n  resizeTimer = setTimeout(() => {\r\n    document.body.classList.remove('resizing');\r\n    resizeTimer = null;\r\n  }, 500);\r\n});\r\n\r\nif (import.meta.webpackHot) {\r\n  import.meta.webpackHot.accept();\r\n}\r\n","function getFormParent(el) {\r\n  return el?.closest('.form-widget-form')?.parentElement;\r\n}\r\n\r\nfunction refreshSelectBox(select) {\r\n  if (!select?.tagName === 'SELECT') return;\r\n\r\n  let isActive = true;\r\n\r\n  const placeholderOption = select.querySelector(\r\n    'option:first-child[value=\"\"]'\r\n  );\r\n\r\n  if (placeholderOption) {\r\n    if (select.required) placeholderOption.disabled = true;\r\n    if (!select.value) isActive = false;\r\n  }\r\n\r\n  if (isActive) {\r\n    select.classList.add('active');\r\n    select.classList.remove('inactive');\r\n  } else {\r\n    select.classList.add('inactive');\r\n    select.classList.remove('active');\r\n  }\r\n}\r\n\r\nfunction handleSelectChange(e) {\r\n  refreshSelectBox(e.target);\r\n}\r\n\r\nfunction initSelectBoxes(form) {\r\n  form.querySelectorAll('select').forEach(refreshSelectBox);\r\n\r\n  // Clean up any potential existing event listeners\r\n  form.removeEventListener('change', handleSelectChange);\r\n  form.addEventListener('change', handleSelectChange);\r\n}\r\n\r\ndocument.querySelectorAll('.form-widget-form form').forEach(form => {\r\n  form.noValidate = true;\r\n\r\n  form.addEventListener('submit', e => {\r\n    getFormParent(e.target)?.classList.add('form-initializing');\r\n  });\r\n\r\n  initSelectBoxes(form);\r\n});\r\n\r\n// Callback that runs every time Fremont Form Widget is rendered/updated\r\nconst prevInitFormCallback = window.__initForm;\r\n\r\nwindow.__initForm = form => {\r\n  form.noValidate = true;\r\n\r\n  initSelectBoxes(form);\r\n\r\n  const parentElement = getFormParent(form);\r\n\r\n  if (parentElement) {\r\n    parentElement.classList.remove('form-initializing');\r\n\r\n    if (\r\n      document.activeElement &&\r\n      parentElement.contains(document.activeElement)\r\n    ) {\r\n      document.activeElement.blur();\r\n    }\r\n  }\r\n\r\n  prevInitFormCallback?.(form);\r\n};\r\n","const isPageBuilder = document.body.classList.contains(\r\n  'KenticoAdminPageBuilder'\r\n);\r\n\r\n// On mobile the slider switches to a scrollable list\r\nconst isDesktopQuery = window.matchMedia('(min-width: 601px)');\r\n\r\n// Store event handlers outside of init function\r\n// so that we can properly reset everything when\r\n// slides are added/removed inside Page Builder\r\nlet count = 0;\r\nlet eventListeners = [];\r\n\r\nfunction initSliders() {\r\n  if (eventListeners.length) {\r\n    document.querySelectorAll('.tab-button').forEach(button => {\r\n      eventListeners.forEach(listener =>\r\n        button.removeEventListener('click', listener)\r\n      );\r\n    });\r\n  }\r\n\r\n  count = 0;\r\n  eventListeners = [];\r\n\r\n  document.querySelectorAll('.tab-slider').forEach(slider => {\r\n    slider.classList.add('no-animation');\r\n\r\n    const slides = Array.from(slider.querySelectorAll('.tab-wrapper'));\r\n\r\n    if (slides.length <= 1) {\r\n      if (slides.length === 1) slides[0].classList.add('open');\r\n      setTimeout(() => slider.classList.remove('no-animation'), 100);\r\n      return;\r\n    }\r\n\r\n    slider.style.setProperty('--tab-count', slides.length);\r\n\r\n    const buttons = slider.querySelectorAll('.tab-button');\r\n\r\n    const setAccessibilityAttributes = () => {\r\n      if (isDesktopQuery.matches) {\r\n        const buttonIds = [];\r\n\r\n        buttons.forEach(el => {\r\n          const slide = el.closest('.tab-wrapper');\r\n          const isActive = slide?.classList.contains('open') ?? false;\r\n\r\n          if (el.id) buttonIds.push(el.id);\r\n\r\n          el.setAttribute('aria-selected', isActive);\r\n          el.tabIndex = isActive ? -1 : 0;\r\n          el.disabled = isActive;\r\n        });\r\n\r\n        slider.setAttribute('role', 'tablist');\r\n\r\n        if (buttonIds.length) {\r\n          slider.setAttribute('aria-owns', buttonIds.join(' '));\r\n        }\r\n\r\n        slider.querySelectorAll('.tab-content-wrapper').forEach(el => {\r\n          el.setAttribute('role', 'tabpanel');\r\n        });\r\n      } else {\r\n        slider.removeAttribute('role');\r\n        slider.removeAttribute('aria-owns');\r\n        slider.querySelectorAll('.tab-content-wrapper').forEach(el => {\r\n          el.removeAttribute('role');\r\n        });\r\n      }\r\n    };\r\n\r\n    // Add or remove accessibility attributes based on desktop/mobile\r\n    if (isDesktopQuery.addEventListener) {\r\n      isDesktopQuery.addEventListener('change', setAccessibilityAttributes);\r\n    } else if (isDesktopQuery.addListener) {\r\n      isDesktopQuery.addListener(setAccessibilityAttributes);\r\n    }\r\n\r\n    const setCurrentSlide = (slide, button) => {\r\n      slide ??= button?.closest('.tab-wrapper');\r\n      button ??= slide?.querySelector('.tab-button');\r\n\r\n      if (!button || !slide) return;\r\n\r\n      slides.forEach(el => el.classList.toggle('open', el === slide));\r\n\r\n      setAccessibilityAttributes();\r\n\r\n      if (isPageBuilder) {\r\n        slider.dataset.activeTab = slides.indexOf(slide);\r\n      }\r\n    };\r\n\r\n    const handleButtonClick = e => {\r\n      const button = e.target;\r\n      const slide = button?.closest('.tab-wrapper');\r\n\r\n      if (!button || !slide || slide.classList.contains('open')) return;\r\n\r\n      setCurrentSlide(slide, button);\r\n\r\n      // If clicked from keyboard, blur the button\r\n      // to remove the focus outline when active\r\n      if (e.detail === 0) setTimeout(() => button.blur(), 5);\r\n    };\r\n\r\n    eventListeners.push(handleButtonClick);\r\n\r\n    let hasOpenSlide = false;\r\n\r\n    buttons.forEach(button => {\r\n      const wrapper = button.closest('.tab-wrapper');\r\n      if (!wrapper) return;\r\n\r\n      const isOpen = wrapper.classList.contains('open');\r\n\r\n      if (isOpen) hasOpenSlide = true;\r\n\r\n      button.addEventListener('click', handleButtonClick);\r\n      button.tabIndex = isOpen ? -1 : 0;\r\n      button.disabled = button.setAttribute('aria-selected', isOpen);\r\n\r\n      // Set accessibility items\r\n      count++;\r\n\r\n      const content = wrapper.querySelector('.tab-content-wrapper');\r\n\r\n      button.id ||= `tab-button-${count}`;\r\n\r\n      if (content) {\r\n        const id = `tab-${count}`;\r\n\r\n        content.id = id;\r\n        button.setAttribute('aria-controls', id);\r\n      }\r\n    });\r\n\r\n    setAccessibilityAttributes();\r\n\r\n    if (!hasOpenSlide) {\r\n      slider.classList.add('no-animation');\r\n\r\n      const activeTab = isPageBuilder\r\n        ? parseInt(slider.dataset.activeTab) || 0\r\n        : 0;\r\n\r\n      setCurrentSlide(slides[activeTab] ?? slides[0]);\r\n    }\r\n\r\n    setTimeout(() => slider.classList.remove('no-animation'), 100);\r\n  });\r\n}\r\n\r\ninitSliders();\r\n\r\nif (isPageBuilder) {\r\n  let pageBuilderTimer = null;\r\n\r\n  window.addEventListener('fremont:tab-slider-change', () => {\r\n    clearTimeout(pageBuilderTimer);\r\n    pageBuilderTimer = setTimeout(initSliders, 100);\r\n  });\r\n}\r\n","var _typeof = require(\"./typeof.js\")[\"default\"];\nfunction _regeneratorRuntime() {\n  \"use strict\"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */\n  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {\n    return e;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  var t,\n    e = {},\n    r = Object.prototype,\n    n = r.hasOwnProperty,\n    o = Object.defineProperty || function (t, e, r) {\n      t[e] = r.value;\n    },\n    i = \"function\" == typeof Symbol ? Symbol : {},\n    a = i.iterator || \"@@iterator\",\n    c = i.asyncIterator || \"@@asyncIterator\",\n    u = i.toStringTag || \"@@toStringTag\";\n  function define(t, e, r) {\n    return Object.defineProperty(t, e, {\n      value: r,\n      enumerable: !0,\n      configurable: !0,\n      writable: !0\n    }), t[e];\n  }\n  try {\n    define({}, \"\");\n  } catch (t) {\n    define = function define(t, e, r) {\n      return t[e] = r;\n    };\n  }\n  function wrap(t, e, r, n) {\n    var i = e && e.prototype instanceof Generator ? e : Generator,\n      a = Object.create(i.prototype),\n      c = new Context(n || []);\n    return o(a, \"_invoke\", {\n      value: makeInvokeMethod(t, r, c)\n    }), a;\n  }\n  function tryCatch(t, e, r) {\n    try {\n      return {\n        type: \"normal\",\n        arg: t.call(e, r)\n      };\n    } catch (t) {\n      return {\n        type: \"throw\",\n        arg: t\n      };\n    }\n  }\n  e.wrap = wrap;\n  var h = \"suspendedStart\",\n    l = \"suspendedYield\",\n    f = \"executing\",\n    s = \"completed\",\n    y = {};\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n  var p = {};\n  define(p, a, function () {\n    return this;\n  });\n  var d = Object.getPrototypeOf,\n    v = d && d(d(values([])));\n  v && v !== r && n.call(v, a) && (p = v);\n  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);\n  function defineIteratorMethods(t) {\n    [\"next\", \"throw\", \"return\"].forEach(function (e) {\n      define(t, e, function (t) {\n        return this._invoke(e, t);\n      });\n    });\n  }\n  function AsyncIterator(t, e) {\n    function invoke(r, o, i, a) {\n      var c = tryCatch(t[r], t, o);\n      if (\"throw\" !== c.type) {\n        var u = c.arg,\n          h = u.value;\n        return h && \"object\" == _typeof(h) && n.call(h, \"__await\") ? e.resolve(h.__await).then(function (t) {\n          invoke(\"next\", t, i, a);\n        }, function (t) {\n          invoke(\"throw\", t, i, a);\n        }) : e.resolve(h).then(function (t) {\n          u.value = t, i(u);\n        }, function (t) {\n          return invoke(\"throw\", t, i, a);\n        });\n      }\n      a(c.arg);\n    }\n    var r;\n    o(this, \"_invoke\", {\n      value: function value(t, n) {\n        function callInvokeWithMethodAndArg() {\n          return new e(function (e, r) {\n            invoke(t, n, e, r);\n          });\n        }\n        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();\n      }\n    });\n  }\n  function makeInvokeMethod(e, r, n) {\n    var o = h;\n    return function (i, a) {\n      if (o === f) throw new Error(\"Generator is already running\");\n      if (o === s) {\n        if (\"throw\" === i) throw a;\n        return {\n          value: t,\n          done: !0\n        };\n      }\n      for (n.method = i, n.arg = a;;) {\n        var c = n.delegate;\n        if (c) {\n          var u = maybeInvokeDelegate(c, n);\n          if (u) {\n            if (u === y) continue;\n            return u;\n          }\n        }\n        if (\"next\" === n.method) n.sent = n._sent = n.arg;else if (\"throw\" === n.method) {\n          if (o === h) throw o = s, n.arg;\n          n.dispatchException(n.arg);\n        } else \"return\" === n.method && n.abrupt(\"return\", n.arg);\n        o = f;\n        var p = tryCatch(e, r, n);\n        if (\"normal\" === p.type) {\n          if (o = n.done ? s : l, p.arg === y) continue;\n          return {\n            value: p.arg,\n            done: n.done\n          };\n        }\n        \"throw\" === p.type && (o = s, n.method = \"throw\", n.arg = p.arg);\n      }\n    };\n  }\n  function maybeInvokeDelegate(e, r) {\n    var n = r.method,\n      o = e.iterator[n];\n    if (o === t) return r.delegate = null, \"throw\" === n && e.iterator[\"return\"] && (r.method = \"return\", r.arg = t, maybeInvokeDelegate(e, r), \"throw\" === r.method) || \"return\" !== n && (r.method = \"throw\", r.arg = new TypeError(\"The iterator does not provide a '\" + n + \"' method\")), y;\n    var i = tryCatch(o, e.iterator, r.arg);\n    if (\"throw\" === i.type) return r.method = \"throw\", r.arg = i.arg, r.delegate = null, y;\n    var a = i.arg;\n    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, \"return\" !== r.method && (r.method = \"next\", r.arg = t), r.delegate = null, y) : a : (r.method = \"throw\", r.arg = new TypeError(\"iterator result is not an object\"), r.delegate = null, y);\n  }\n  function pushTryEntry(t) {\n    var e = {\n      tryLoc: t[0]\n    };\n    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);\n  }\n  function resetTryEntry(t) {\n    var e = t.completion || {};\n    e.type = \"normal\", delete e.arg, t.completion = e;\n  }\n  function Context(t) {\n    this.tryEntries = [{\n      tryLoc: \"root\"\n    }], t.forEach(pushTryEntry, this), this.reset(!0);\n  }\n  function values(e) {\n    if (e || \"\" === e) {\n      var r = e[a];\n      if (r) return r.call(e);\n      if (\"function\" == typeof e.next) return e;\n      if (!isNaN(e.length)) {\n        var o = -1,\n          i = function next() {\n            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;\n            return next.value = t, next.done = !0, next;\n          };\n        return i.next = i;\n      }\n    }\n    throw new TypeError(_typeof(e) + \" is not iterable\");\n  }\n  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, \"constructor\", {\n    value: GeneratorFunctionPrototype,\n    configurable: !0\n  }), o(GeneratorFunctionPrototype, \"constructor\", {\n    value: GeneratorFunction,\n    configurable: !0\n  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, \"GeneratorFunction\"), e.isGeneratorFunction = function (t) {\n    var e = \"function\" == typeof t && t.constructor;\n    return !!e && (e === GeneratorFunction || \"GeneratorFunction\" === (e.displayName || e.name));\n  }, e.mark = function (t) {\n    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, \"GeneratorFunction\")), t.prototype = Object.create(g), t;\n  }, e.awrap = function (t) {\n    return {\n      __await: t\n    };\n  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {\n    return this;\n  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {\n    void 0 === i && (i = Promise);\n    var a = new AsyncIterator(wrap(t, r, n, o), i);\n    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {\n      return t.done ? t.value : a.next();\n    });\n  }, defineIteratorMethods(g), define(g, u, \"Generator\"), define(g, a, function () {\n    return this;\n  }), define(g, \"toString\", function () {\n    return \"[object Generator]\";\n  }), e.keys = function (t) {\n    var e = Object(t),\n      r = [];\n    for (var n in e) r.push(n);\n    return r.reverse(), function next() {\n      for (; r.length;) {\n        var t = r.pop();\n        if (t in e) return next.value = t, next.done = !1, next;\n      }\n      return next.done = !0, next;\n    };\n  }, e.values = values, Context.prototype = {\n    constructor: Context,\n    reset: function reset(e) {\n      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = \"next\", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) \"t\" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);\n    },\n    stop: function stop() {\n      this.done = !0;\n      var t = this.tryEntries[0].completion;\n      if (\"throw\" === t.type) throw t.arg;\n      return this.rval;\n    },\n    dispatchException: function dispatchException(e) {\n      if (this.done) throw e;\n      var r = this;\n      function handle(n, o) {\n        return a.type = \"throw\", a.arg = e, r.next = n, o && (r.method = \"next\", r.arg = t), !!o;\n      }\n      for (var o = this.tryEntries.length - 1; o >= 0; --o) {\n        var i = this.tryEntries[o],\n          a = i.completion;\n        if (\"root\" === i.tryLoc) return handle(\"end\");\n        if (i.tryLoc <= this.prev) {\n          var c = n.call(i, \"catchLoc\"),\n            u = n.call(i, \"finallyLoc\");\n          if (c && u) {\n            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);\n            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);\n          } else if (c) {\n            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);\n          } else {\n            if (!u) throw new Error(\"try statement without catch or finally\");\n            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);\n          }\n        }\n      }\n    },\n    abrupt: function abrupt(t, e) {\n      for (var r = this.tryEntries.length - 1; r >= 0; --r) {\n        var o = this.tryEntries[r];\n        if (o.tryLoc <= this.prev && n.call(o, \"finallyLoc\") && this.prev < o.finallyLoc) {\n          var i = o;\n          break;\n        }\n      }\n      i && (\"break\" === t || \"continue\" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);\n      var a = i ? i.completion : {};\n      return a.type = t, a.arg = e, i ? (this.method = \"next\", this.next = i.finallyLoc, y) : this.complete(a);\n    },\n    complete: function complete(t, e) {\n      if (\"throw\" === t.type) throw t.arg;\n      return \"break\" === t.type || \"continue\" === t.type ? this.next = t.arg : \"return\" === t.type ? (this.rval = this.arg = t.arg, this.method = \"return\", this.next = \"end\") : \"normal\" === t.type && e && (this.next = e), y;\n    },\n    finish: function finish(t) {\n      for (var e = this.tryEntries.length - 1; e >= 0; --e) {\n        var r = this.tryEntries[e];\n        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;\n      }\n    },\n    \"catch\": function _catch(t) {\n      for (var e = this.tryEntries.length - 1; e >= 0; --e) {\n        var r = this.tryEntries[e];\n        if (r.tryLoc === t) {\n          var n = r.completion;\n          if (\"throw\" === n.type) {\n            var o = n.arg;\n            resetTryEntry(r);\n          }\n          return o;\n        }\n      }\n      throw new Error(\"illegal catch attempt\");\n    },\n    delegateYield: function delegateYield(e, r, n) {\n      return this.delegate = {\n        iterator: values(e),\n        resultName: r,\n        nextLoc: n\n      }, \"next\" === this.method && (this.arg = t), y;\n    }\n  }, e;\n}\nmodule.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return (module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports), _typeof(o);\n}\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","// TODO(Babel 8): Remove this file.\n\nvar runtime = require(\"../helpers/regeneratorRuntime\")();\nmodule.exports = runtime;\n\n// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  if (typeof globalThis === \"object\") {\n    globalThis.regeneratorRuntime = runtime;\n  } else {\n    Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n  }\n}\n"],"names":["scrollbarWidth","outer","document","createElement","style","visibility","overflow","msOverflowStyle","body","appendChild","inner","offsetWidth","parentNode","removeChild","getScrollbarWidth","header","querySelector","hasStickyHeader","id","classList","contains","scrollPosition","candidateSelectors","candidateSelector","join","NoElement","Element","matches","prototype","msMatchesSelector","webkitMatchesSelector","getRootNode","element","_element$getRootNode","call","ownerDocument","isInert","node","lookUp","_node$getAttribute","inertAtt","getAttribute","getCandidates","el","includeContainer","filter","candidates","Array","slice","apply","querySelectorAll","unshift","getCandidatesIteratively","elements","options","elementsToCheck","from","length","shift","tagName","assigned","assignedElements","nestedCandidates","children","flatten","push","scopeParent","includes","shadowRoot","getShadowRoot","validShadowRoot","shadowRootFilter","_nestedCandidates","hasTabIndex","isNaN","parseInt","getTabIndex","Error","tabIndex","test","_node$getAttribute2","attValue","isContentEditable","sortOrderedTabbables","a","b","documentOrder","isInput","isNonTabbableRadio","type","isRadio","name","radioSet","radioScope","form","queryRadios","window","CSS","escape","err","console","error","message","checked","nodes","i","getCheckedRadio","isTabbableRadio","isZeroArea","_node$getBoundingClie","getBoundingClientRect","width","height","isHidden","_ref","displayCheck","getComputedStyle","nodeUnderDetails","parentElement","originalNode","rootNode","assignedSlot","host","_nodeRoot","_nodeRootHost","_nodeRootHost$ownerDo","_node$ownerDocument","nodeRoot","nodeRootHost","attached","_nodeRoot2","_nodeRootHost2","_nodeRootHost2$ownerD","isNodeAttached","getClientRects","isNodeMatchingSelectorFocusable","disabled","isHiddenInput","some","child","isDetailsWithSummary","item","isDisabledFromFieldset","isNodeMatchingSelectorTabbable","isValidShadowRootTabbable","shadowHostNode","sortByOrder","regularTabbables","orderedTabbables","forEach","isScope","candidateTabindex","getSortOrderTabIndex","content","sort","reduce","acc","sortable","concat","isTabbable","focusableCandidateSelector","isFocusable","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","getOwnPropertyDescriptor","enumerable","_objectSpread2","arguments","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","obj","key","value","arg","input","hint","prim","Symbol","toPrimitive","undefined","res","TypeError","String","Number","_toPrimitive","_toPropertyKey","configurable","writable","userOptions","trap","doc","trapStack","config","state","getOption","findContainerIndex","getNodeForOption","getInitialFocusNode","updateTabbableNodes","getActiveElement","tryFocus","getReturnFocusNode","findNextNavNode","checkPointerDown","checkFocusIn","checkKey","checkClick","addListeners","removeListeners","mutationObserver","updateObservedNodes","activeFocusTraps","activeTrap","pause","trapIndex","indexOf","splice","unpause","isTabEvent","keyCode","isKeyForward","shiftKey","isKeyBackward","delay","fn","setTimeout","findIndex","arr","idx","every","valueOrHandler","_len","params","_key","getActualTarget","event","target","composedPath","internalTrapStack","mainNavWrapper","mainNav","mainNavContent","isPageBuilder","searchOpenTimer","menuIsOpen","searchIsOpen","openButton","closeButton","focusTrap","initialFocus","fallbackFocus","preventScroll","returnFocusOnDeactivate","escapeDeactivates","delayInitialFocus","containers","containerGroups","tabbableGroups","nodeFocusedBeforeActivation","mostRecentlyFocusedNode","active","paused","delayInitialFocusTimer","recentNavEvent","configOverrideOptions","optionName","configOptionName","container","tabbableNodes","find","optionValue","_len2","_key2","tabbableOptions","activeElement","firstTabbableGroup","firstTabbableNode","map","bind","tabbable","focusableNodes","focusable","lastTabbableNode","firstDomTabbableNode","lastDomTabbableNode","reverse","posTabIndexesFound","nextTabbableNode","forward","nodeIdx","group","g","focus","toLowerCase","select","isSelectableInput","previousActiveElement","_ref2","_ref2$isBackward","isBackward","destinationNode","containerIndex","containerGroup","startOfGroupIndex","_ref3","destinationGroupIndex","destinationGroup","lastOfGroupIndex","_ref4","_destinationGroupIndex","_destinationGroup","clickOutsideDeactivates","deactivate","returnFocus","allowOutsideClick","preventDefault","targetContained","Document","nextNode","stopImmediatePropagation","navAcrossContainers","mruContainerIdx","mruTabIdx","n","checkKeyNav","addEventListener","capture","passive","removeEventListener","MutationObserver","mutations","mutation","removedNodes","disconnect","observe","subtree","childList","activate","activateOptions","this","onActivate","onPostActivate","checkCanFocusTrap","finishActivation","then","deactivateOptions","onDeactivate","onPostDeactivate","checkCanReturnFocus","clearTimeout","finishDeactivation","pauseOptions","onPause","onPostPause","unpauseOptions","onUnpause","onPostUnpause","updateContainerElements","containerElements","elementsAsArray","Boolean","openMenu","scrollTo","add","documentElement","pageYOffset","top","paddingRight","right","closeMenu","remove","blur","closest","_arrayLikeToArray","len","arr2","_slicedToArray","isArray","l","iterator","u","f","next","done","minLen","toString","constructor","sidebar","sidebarContent","setStickySidebar","toggle","offsetHeight","innerHeight","tableOfContents","sections","IntersectionObserver","sentinel","entry","isIntersecting","intersectionData","isScrollingToSection","scrollTimer","intersectionTimer","link","hash","section","listItem","scrollIntoView","behavior","enableIntersectionChecks","handleIntersection","currentSectionId","_intersectionData$id","ratio","index","currentSection","sectionObserver","entries","intersectionRatio","_entry","Math","round","threshold","_typeof","asyncGeneratorStep","gen","resolve","reject","_next","_throw","info","Promise","dateFormatter","Intl","DateTimeFormat","month","day","year","wrapper","listing","_filterWrapper$queryS","supportMultipleTags","_window$supportMultip","filterWrapper","allTagsButton","tagButtons","loadMoreWrapper","loadMoreButton","noPostsMessage","errorMessage","rootId","dataset","root","categoryId","category","currentPage","isLoading","canLoadMore","loadMoreText","innerText","toggleButton","button","isActive","setAttribute","getSelectedTags","tag","getCurrentFiltersKey","currentFiltersKey","cachedData","setPostsFocusable","canFocus","_document$activeEleme","removeAttribute","fetchPosts","_regeneratorRuntime","_callee","isLoadMore","_window$minLoadingUiD","_window$minLoadingUiD2","filtersKey","tags","url","minLoadingUiDelay","minLoadingUiDuration","loadingUiPromise","loadingUiTimeout","_yield$res$json","data","_context","prev","refreshPostListing","abrupt","URL","location","origin","searchParams","set","fetch","sent","json","t1","t0","t2","posts","t3","stop","self","args","_x","_noPostsMessage$query","_noPostsMessage$query2","areMorePostsAvailable","fragment","createDocumentFragment","post","card","className","headlineTagName","headline","image","postDate","timeToRead","imgLink","href","img","src","alt","append","tagsList","tagWrapper","tagEl","isMainCategory","isHighlighted","headlineLink","headlineEl","date","Date","hasDate","getFullYear","meta","dateEl","dateTime","toISOString","format","timeToReadEl","createArticleCard","showMoreTagsButton","_showMoreTagsButton$c","_showMoreTagsButton$c2","li","resizeTimer","getFormParent","_el$closest","refreshSelectBox","placeholderOption","required","handleSelectChange","initSelectBoxes","noValidate","_getFormParent","prevInitFormCallback","__initForm","isDesktopQuery","matchMedia","count","eventListeners","initSliders","listener","slider","slides","setProperty","buttons","setAccessibilityAttributes","buttonIds","_slide$classList$cont","slide","addListener","setCurrentSlide","_slide","_button","_button2","_slide2","activeTab","handleButtonClick","detail","hasOpenSlide","isOpen","_slides$activeTab","pageBuilderTimer","module","exports","__esModule","hasOwnProperty","c","asyncIterator","toStringTag","define","wrap","Generator","create","Context","makeInvokeMethod","tryCatch","h","s","y","GeneratorFunction","GeneratorFunctionPrototype","p","d","getPrototypeOf","v","values","defineIteratorMethods","_invoke","AsyncIterator","invoke","__await","callInvokeWithMethodAndArg","method","delegate","maybeInvokeDelegate","_sent","dispatchException","resultName","nextLoc","pushTryEntry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","displayName","isGeneratorFunction","mark","setPrototypeOf","__proto__","awrap","async","pop","charAt","rval","handle","complete","finish","delegateYield","runtime","regeneratorRuntime","accidentalStrictMode","globalThis","Function"],"sourceRoot":""}