{"version":3,"file":"js/wsumApp.js","mappings":"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","sources":["webpack://golf-wp/./wp-content/mu-plugins/wsum-user-manager/resources/js/constants.js","webpack://golf-wp/webpack/bootstrap","webpack://golf-wp/./wp-content/mu-plugins/wsum-user-manager/resources/js/utils/getCachedRequest.js","webpack://golf-wp/./wp-content/mu-plugins/wsum-user-manager/resources/js/utils/API.js","webpack://golf-wp/./wp-content/mu-plugins/wsum-user-manager/resources/js/modules/bookmark.js","webpack://golf-wp/./wp-content/mu-plugins/wsum-user-manager/resources/js/modules/bookmarks.js","webpack://golf-wp/./wp-content/mu-plugins/wsum-user-manager/resources/js/utils/cookie.js","webpack://golf-wp/./wp-content/mu-plugins/wsum-user-manager/resources/js/modules/logout.js","webpack://golf-wp/./node_modules/tabbable/dist/index.esm.js","webpack://golf-wp/./node_modules/focus-trap/dist/focus-trap.esm.js","webpack://golf-wp/./wp-content/mu-plugins/wsum-user-manager/resources/js/modules/gated-content.js","webpack://golf-wp/./wp-content/themes/golf/src/js/utils/inViewPort.js","webpack://golf-wp/./wp-content/mu-plugins/wsum-user-manager/resources/js/modules/promotion-link.js","webpack://golf-wp/./wp-content/mu-plugins/wsum-user-manager/resources/js/modules/notice-pop-up.js","webpack://golf-wp/./wp-content/mu-plugins/wsum-user-manager/resources/js/modules/tracking.js","webpack://golf-wp/./wp-content/mu-plugins/wsum-user-manager/resources/js/modules/utm-parameters.js","webpack://golf-wp/./wp-content/mu-plugins/wsum-user-manager/resources/js/utils/DOMReady.js","webpack://golf-wp/./wp-content/mu-plugins/wsum-user-manager/resources/js/wsum-app.js"],"sourcesContent":["module.exports = {\n  API_ROOT: window.wsum ? window.wsum.api : '',\n  NOTICE_POPUP_COOKIE: '__wsum-notice',\n  ADWALLET_BOT_COOKIE: 'adwalletBot',\n  GATED_CONTENT_COOKIE: '__wsum-session',\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","/**\n * Helper function for fetching and caching with sessionStorage.\n *\n * @param {String} key id for session storage\n * @param {Array} fetchProps values passes to fetch function\n * @param {Boolean} bypassSessionStorageCache Whether to ignore cache\n *\n * @returns {Promise<unknown>} The Request Promise\n */\nconst getCachedRequest = (key, fetchProps, bypassSessionStorageCache = false) =>\n  new Promise((resolve, reject) => {\n    // check cache\n    if (window.sessionStorage.getItem(key) && !bypassSessionStorageCache) {\n      const cache = JSON.parse(window.sessionStorage.getItem(key))\n      // use if not expired\n      if (cache.expire === null || cache.expire > Date.now()) {\n        resolve(cache[key])\n        return // don't continue\n      }\n    }\n    // make requests\n    fetch(...fetchProps)\n      .then(async res => {\n        const json = await res.json()\n        return { success: res.status === 200, json }\n      })\n      .then(({ success, json }) => {\n        if (success) {\n          const cache = {\n            [key]: json,\n            expire: Date.now() + 300 * 1000,\n          }\n          window.sessionStorage.setItem(key, JSON.stringify(cache))\n          resolve(json)\n        } else {\n          reject(json)\n        }\n      })\n      .catch(err => {\n        reject(err)\n      })\n  })\n\nexport default getCachedRequest\n","import getCachedRequest from './getCachedRequest'\n\nconst API = {\n  /**\n   * Gets from the API\n   *\n   * @param {String} url The endpoint URL\n   * @returns {Object} API Response Object\n   * @param {Object} fetchProps fetch props\n   */\n  async get(url, fetchProps = {}) {\n    const response = await fetch(url, {\n      credentials: 'include',\n      headers: {\n        'Content-Type': 'application/json',\n      },\n      ...fetchProps,\n    })\n      .then(res => res.json())\n      .catch(error => ({ message: error }))\n\n    if (response.code) {\n      response.error = true\n    }\n\n    return response\n  },\n\n  /**\n   * Gets from the API or SessionStorage Cache\n   *\n   * @param {String} key Cache Key\n   * @param {String} url The endpoint URL\n   * @param {Boolean} ignoreCache Whether to bypass cache or not\n   * @param {Object} fetchProps fetch props\n   * @returns {Object} API Response Object\n   */\n  async getCached(key, url, ignoreCache = false, fetchProps = {}) {\n    const response = await getCachedRequest(\n      key,\n      [\n        url,\n        {\n          credentials: 'include',\n          headers: {\n            'Content-Type': 'application/json',\n          },\n          ...fetchProps,\n        },\n      ],\n      ignoreCache,\n    )\n\n    if (response.code) {\n      response.error = true\n    }\n\n    return response\n  },\n\n  /**\n   * Post to the API\n   *\n   * @param {String} url The endpoint URL\n   * @param {Object} data The Payload\n   * @param {Object} fetchProps fetch props\n   * @returns {Object} API Response Object\n   */\n  async post(url, data = {}, fetchProps = {}) {\n    const response = await fetch(url, {\n      method: 'POST',\n      credentials: 'include',\n      headers: {\n        'Content-Type': 'application/json',\n      },\n      ...fetchProps,\n      body: JSON.stringify(data),\n    })\n      .then(res => res.json())\n      .catch(error => ({ error: true, message: error }))\n\n    if (response.code) {\n      response.error = true\n    }\n\n    return response\n  },\n}\n\nexport default API\n","import { API_ROOT } from '../constants'\nimport API from '../utils/API'\n\nexport class Bookmark {\n  /**\n   * Constructor\n   *\n   * @param {Element} el Element with the class `.wsum-bookmark`\n   * @param {Object} options Object to overwrite default Options\n   */\n  constructor(el, options = {}) {\n    this.button = el\n    this.options = {\n      bookmarkedClass: 'wsum-bookmark--bookmarked',\n      fetchingClass: 'wsum-bookmark--fetching',\n      ...options,\n    }\n    this.postID = this.button.dataset.id\n    this.postData = JSON.parse(this.button.dataset.bookmark)\n    this.isBookmarked = false\n    this.bookmarkItem = this.bookmarkItem.bind(this)\n    this.closePopUp = this.closePopUp.bind(this)\n    this.timeOut = null\n    this.popUp = null\n\n    this.init()\n  }\n\n  /**\n   * Triggers when bookmarking action (add/remove) was successfull\n   */\n  success() {\n    this.isBookmarked = !this.isBookmarked\n    if (this.isBookmarked) {\n      this.button.classList.add(this.options.bookmarkedClass)\n      window.wsumBookmarks.add(this.postData)\n      this.openPopUp()\n    } else {\n      this.button.classList.remove(this.options.bookmarkedClass)\n      window.wsumBookmarks.remove(this.postData)\n    }\n  }\n\n  /**\n   * Removes the Bookmarked Pop Up from the DOM if exist\n   */\n  removePopUp() {\n    if (this.popUp) {\n      this.popUp.remove()\n      this.popUp = null\n    }\n  }\n\n  /**\n   * Removes the Pop Up with a fade out animation\n   */\n  closePopUp() {\n    if (this.timeOut) {\n      clearTimeout(this.timeOut)\n      this.timeOut = null\n    }\n\n    if (this.popUp) {\n      this.popUp.classList.remove('active')\n\n      setTimeout(() => {\n        this.removePopUp()\n        this.button.focus()\n      }, 200)\n    }\n  }\n\n  /**\n   * Generates a Pop Up\n   */\n  openPopUp() {\n    this.removePopUp()\n\n    this.popUp = document.createElement('div')\n    this.popUp.className = 'wsum-modal wsum-modal--bookmark'\n    this.popUp.innerHTML = `\n      <div class=\"wsum-modal__dialog\">\n        <div class=\"wsum-modal--bookmark__icon\">\n          <i class=\"icon-bookmark\"></i>\n        </div>\n        <h5 class=\"wsum-modal--bookmark__heading\">\n          Bookmarked\n        </h5>\n        <p class=\"wsum-modal--bookmark__copy\">\n          You can find bookmarked content in your account.\n        </p>\n      </div>\n    `\n    document.documentElement.appendChild(this.popUp)\n    this.popUp.classList.add('active')\n    this.popUp.addEventListener('click', this.closePopUp)\n\n    this.timeOut = setTimeout(() => {\n      this.closePopUp()\n    }, 4000)\n  }\n\n  /**\n   * Handles Post Bookmark state for logged in user\n   *\n   * @param {Event} e Click Event\n   */\n  async bookmarkItem(e) {\n    e.preventDefault()\n    e.stopPropagation()\n\n    const endpoint = `${API_ROOT}/user-${this.isBookmarked ? 'remove' : 'add'}-bookmark`\n\n    this.button.setAttribute('disabled', 'disabled')\n    this.button.classList.add(this.options.fetchingClass)\n\n    const response = await API.post(endpoint, {\n      id: Number(this.postID),\n    })\n\n    const { error } = response\n\n    if (!error) {\n      this.success()\n    }\n\n    this.button.removeAttribute('disabled')\n    this.button.classList.remove(this.options.fetchingClass)\n  }\n\n  /**\n   * Initializes the Bookmark button\n   */\n  init() {\n    if (!this.postID) {\n      this.button.classList.remove(this.options.fetchingClass)\n      return\n    }\n    this.isBookmarked = window.wsumBookmarks.has(Number(this.postID))\n    if (this.isBookmarked) {\n      this.button.classList.add(this.options.bookmarkedClass)\n    }\n    this.button.addEventListener('click', this.bookmarkItem)\n    this.button.classList.remove(this.options.fetchingClass)\n    this.button.removeAttribute('disabled')\n  }\n\n  destroy() {\n    if (!this.postID) {\n      return\n    }\n    this.button.removeEventListener('click', this.bookmarkItem)\n  }\n}\n\nconst bookmarkInit = {\n  init() {\n    document.addEventListener('bookmarks-ready', () => {\n      const elements = document.querySelectorAll('.wsum-bookmark')\n      elements.forEach(el => new Bookmark(el))\n    })\n  },\n}\n\nexport default bookmarkInit\n","/* eslint-disable camelcase */\nimport { API_ROOT } from '../constants'\nimport API from '../utils/API'\n\n/**\n * Bookmarks Class\n *\n * Handles User bookmarks state and cache\n */\nclass Bookmarks {\n  /**\n   * Constructor\n   */\n  constructor() {\n    this.ids = []\n    this.videos = []\n    this['top-100'] = []\n    this['courses-resorts'] = []\n    this.articles = []\n    this.players = []\n    this.authors = []\n    this.fetching = true\n\n    this.init()\n  }\n\n  /**\n   * Get Items from cache (if exist) or API endpoint\n   *\n   * @param {Boolean} ignoreCache Flag to ignore cache. Default to `false`\n   *\n   * @returns {Object} Request Result\n   */\n  async get(ignoreCache = false) {\n    this.fetching = true\n    const cachedResponse = await API.getCached(\n      'wsum-user-bookmarks',\n      `${API_ROOT}/get-user-bookmarks`,\n      ignoreCache,\n      {\n        method: 'POST',\n      },\n    )\n    const { error, data } = cachedResponse\n    if (!error) {\n      Object.keys(data).forEach(key => {\n        this[key] = data[key]\n      })\n    }\n\n    this.fetching = false\n    return cachedResponse\n  }\n\n  /**\n   * Clears the Session Storage Cache\n   */\n  clear() {\n    this.ids = []\n    this.videos = []\n    this['top-100'] = []\n    this['courses-resorts'] = []\n    this.articles = []\n    this.players = []\n    this.authors = []\n    window.sessionStorage.removeItem('wsum-user-bookmarks')\n  }\n\n  /**\n   * Cache current bookmarks into Session Storage\n   */\n  cacheItems() {\n    window.sessionStorage.setItem(\n      'wsum-user-bookmarks',\n      JSON.stringify({\n        'wsum-user-bookmarks': {\n          error: false,\n          data: {\n            ids: this.ids,\n            videos: this.videos,\n            'top-100': this['top-100'],\n            'courses-resorts': this['courses-resorts'],\n            articles: this.articles,\n            players: this.players,\n            authors: this.authors,\n          },\n        },\n        expire: Date.now() + 300 * 1000,\n      }),\n    )\n  }\n\n  /**\n   * Check if a Post ID is bookmarked\n   *\n   * @param {Number} postID The Post ID to Check\n   * @returns {Boolean} Whether the Post is bookmarked or not\n   */\n  has(postID) {\n    return this.ids.includes(postID)\n  }\n\n  /**\n   * Add an item to the Bookmarks and then cache it\n   *\n   * @param {Object} post The Post Object\n   */\n  add(post) {\n    // Add to the IDs tracker\n    const { id } = post\n    if (!this.has(id)) {\n      this.ids.push(id)\n    }\n\n    // Add to corresponding KEY\n    const key = this.getPostKey(post)\n    const foundIndex = this[key].findIndex(bookmark => Number(bookmark.id) === Number(post.id))\n    if (!(foundIndex > -1)) {\n      this[key].push(post)\n      this.cacheItems()\n    }\n  }\n\n  /**\n   * Retrieves the key to store/remove bookmark\n   *\n   * @param {Object} post\n   * @returns {String} The key to use\n   */\n  getPostKey(post) {\n    const { type, is_top_100 = false } = post\n    const keyTypes = {\n      golf_video: 'videos',\n      players: 'players',\n      contributor: 'authors',\n      course: 'courses-resorts',\n      resort: 'courses-resorts',\n      'course-new': 'courses-resorts',\n      'resort-new': 'courses-resorts',\n    }\n\n    if (type === 'article') {\n      if (is_top_100) {\n        return 'top-100'\n      }\n      return 'articles'\n    }\n\n    return keyTypes[type] || type\n  }\n\n  /**\n   * Remove an item from bookmarks and then cache it\n   *\n   * @param {Object} post The Post Object\n   */\n  remove(post) {\n    // Remove from IDs tracker\n    const { id } = post\n    if (this.has(id)) {\n      const index = this.ids.indexOf(id)\n      this.ids.splice(index, 1)\n    }\n\n    // Remove from corresponding KEY\n    const key = this.getPostKey(post)\n    const foundIndex = this[key].findIndex(bookmark => Number(bookmark.id) === Number(post.id))\n    if (key && foundIndex > -1) {\n      this[key].splice(foundIndex, 1)\n      this.cacheItems()\n    }\n  }\n\n  /**\n   * Init Bookmarks and sends `bookmarks-ready` event\n   */\n  async init() {\n    const { userIsLoggedIn } = window.wsum\n    if (userIsLoggedIn) {\n      await this.get()\n      document.dispatchEvent(new CustomEvent('bookmarks-ready'))\n    }\n  }\n}\n\nconst bookmarksInit = {\n  init() {\n    window.wsumBookmarks = new Bookmarks()\n  },\n}\n\nexport default bookmarksInit\n","export default {\n  /**\n   * Get cookie value by name\n   *\n   * @param {String} name The cookie name\n   * @returns {String|null} The cookie value. `null` if cookie doesn't exist\n   */\n  get(name) {\n    const cookie = document.cookie.match(`(^|;) ?${name}=([^;]*)(;|$)`)\n    return cookie ? cookie[2] : null\n  },\n\n  /**\n   * Sets value to a cookie with expiration date\n   *\n   * @param {String} name The cookie name\n   * @param {String} value The cookie value\n   * @param {Number} days Days to expire\n   */\n  set(name, value, days) {\n    const date = new Date()\n    date.setTime(date.getTime() + 24 * 60 * 60 * 1000 * days)\n    document.cookie = `${name}=${value};path=/;expires=${date.toGMTString()}`\n  },\n\n  /**\n   * Removes a cookie\n   *\n   * @param {String} name The cookie name\n   */\n  remove(name) {\n    const date = new Date()\n    date.setTime(date.getTime() - 60000)\n    document.cookie = `${name}=;path=/;expires=${date.toGMTString()}`\n  },\n}\n","import cookie from '../utils/cookie'\nimport { API_ROOT, GATED_CONTENT_COOKIE } from '../constants'\n\nclass Logout {\n  /**\n   * Constructor\n   *\n   * @param {Element} el Element with the class `.wsum-logout`\n   */\n  constructor(el) {\n    this.button = el\n    this.endpoint = `${API_ROOT}/auth/logout`\n    const pageTitleEl = document.querySelector('.article__title')\n    this.page_title = pageTitleEl ? pageTitleEl.innerText : ''\n    this.doLogout = this.doLogout.bind(this)\n\n    this.init()\n  }\n\n  /**\n   * Logout Action\n   *\n   * Clear cookies and session storage.\n   * Logout the current user\n   *\n   * @param {Event} e Click Event\n   */\n  doLogout(e) {\n    e.preventDefault()\n    cookie.remove(GATED_CONTENT_COOKIE)\n    if (window.dataLayer) {\n      window.dataLayer.push({\n        event: 'igt.userLogout',\n        insideGolf: {\n          action: {\n            id: 'insideGolf_logout',\n            creative: this.page_title,\n            position: window.location.href,\n          },\n        },\n      })\n    }\n    window.sessionStorage.clear()\n\n    window.location.href = this.endpoint\n  }\n\n  init() {\n    this.button.addEventListener('click', this.doLogout)\n  }\n\n  destroy() {\n    this.button.removeEventListener('click', this.doLogout)\n  }\n}\n\nconst logoutInit = {\n  init() {\n    const wrapperEl = document.querySelectorAll('.wsum-logout')\n    wrapperEl.forEach(form => new Logout(form))\n  },\n}\n\nexport default logoutInit\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 { createFocusTrap } from 'focus-trap'\nimport { inViewPort } from 'golf/utils/inViewPort'\nimport { GATED_CONTENT_COOKIE, ADWALLET_BOT_COOKIE } from '../constants'\nimport cookie from '../utils/cookie'\n\nclass GatedContent {\n  constructor() {\n    this.modal = document.querySelector('.wsum-modal--gate')\n    this.popup = document.querySelector('.free-article-popup')\n    this.adWalletCookie = cookie.get(ADWALLET_BOT_COOKIE)\n    this.cookie = this.getCookie()\n    this.intervalCheck = null\n    this.isOpen = false\n\n    const pageTitleEl = document.querySelector('.article__title')\n    this.page_title = pageTitleEl ? pageTitleEl.innerText : ''\n\n    this.closePopup = this.closePopup.bind(this)\n    this.openPopup = this.openPopup.bind(this)\n\n    if (this.adWalletCookie && this.adWalletCookie === 'true') {\n      return\n    }\n\n    this.init()\n  }\n\n  /**\n   * Get the cookie value\n   *\n   * @returns {Object}\n   */\n  getCookie() {\n    const cookieValue = cookie.get(GATED_CONTENT_COOKIE)\n    if (cookieValue) {\n      return JSON.parse(atob(cookieValue))\n    }\n    return {\n      viewed: [],\n      free: [],\n    }\n  }\n\n  /**\n   * Sets Cookie value\n   *\n   * @param {object} value\n   * @param {number} days\n   */\n  setCookie(value, days = 30) {\n    const encodedValue = btoa(JSON.stringify(value))\n    cookie.set(GATED_CONTENT_COOKIE, encodedValue, days)\n    return value\n  }\n\n  /**\n   * Open the modal\n   */\n  openModal() {\n    if (this.modal && !this.isOpen) {\n      this.modal.classList.add('active')\n      document.body.classList.add('no-scroll')\n      this.focusTrap = null\n      this.isOpen = true\n\n      if (window.dataLayer && !this.tracked) {\n        window.dataLayer.push({\n          event: 'eec.promotionView',\n          ecommerce: {\n            promoView: {\n              promotions: [\n                {\n                  id: 'gated_content_modal',\n                  name: 'gated_content_modal',\n                  creative: this.page_title,\n                  position: window.location.href,\n                },\n              ],\n            },\n          },\n        })\n        this.tracked = true\n      }\n\n      // Scroll 1px to show the main navigation\n      const doc = document.documentElement\n      const top = (window.scrollY || doc.scrollTop) - (doc.clientTop || 0)\n      window.scroll({ top: top - 1 })\n\n      // Trap Focus\n      setTimeout(() => {\n        this.focusTrap = createFocusTrap(this.modal)\n        this.focusTrap.activate()\n      }, 210)\n\n      // Check every 5 seconds the modal state\n      this.intervalCheck = setInterval(() => {\n        this.openModal()\n      }, 5000)\n    }\n  }\n\n  /**\n   * Initialize the modal\n   */\n  initModal() {\n    if (this.modal) {\n      const firstParagraph = document.querySelector('p.first')\n      if (firstParagraph) {\n        inViewPort(\n          firstParagraph,\n          () => {\n            this.openModal()\n          },\n          { rootMargin: '0px', threshold: 1 },\n        )\n      } else {\n        setTimeout(() => {\n          this.openModal()\n        }, 10000)\n      }\n    }\n  }\n\n  /**\n   * Open the popup\n   */\n  openPopup() {\n    if (this.popup) {\n      this.popup.classList.add('active')\n      document.body.classList.add('no-scroll')\n\n      // Trap Focus\n      this.focusTrap = createFocusTrap(this.popup)\n      this.focusTrap.activate()\n\n      if (window.dataLayer && !this.tracked) {\n        window.dataLayer.push({\n          event: 'eec.promotionView',\n          ecommerce: {\n            promoView: {\n              promotions: [\n                {\n                  id: 'free_article_popup',\n                  name: 'free_article_popup',\n                  creative: this.page_title,\n                  position: window.location.href,\n                },\n              ],\n            },\n          },\n        })\n        this.tracked = true\n      }\n    }\n  }\n\n  /**\n   * Close the popup\n   */\n  closePopup() {\n    if (this.popup) {\n      this.popup.classList.remove('active')\n      document.body.classList.remove('no-scroll')\n    }\n\n    if (this.focusTrap) {\n      this.focusTrap.deactivate()\n      this.focusTrap = null\n    }\n  }\n\n  /**\n   * Initialize the popup\n   */\n  initPopUp() {\n    if (this.popup) {\n      this.popupCloseBtn = this.popup.querySelector('.free-article-popup__close')\n\n      setTimeout(this.openPopup, 5000)\n\n      if (this.popupCloseBtn) {\n        this.popupCloseBtn.addEventListener('click', this.closePopup)\n      }\n\n      document.addEventListener('keydown', e => {\n        if (e.key === 'Escape') {\n          this.closePopup()\n        }\n      })\n    }\n  }\n\n  /**\n   * Initialize the gated content system\n   */\n  init() {\n    const { isGated, postId, freeArticles = 1 } = window.wsum\n    const { viewed = [], free = [] } = this.cookie\n\n    if (isGated && !viewed.includes(postId)) {\n      viewed.push(postId)\n\n      if (viewed.length <= freeArticles) {\n        free.push(postId)\n      }\n    }\n\n    this.cookie = this.setCookie({\n      viewed,\n      free,\n    })\n\n    if (viewed.length <= freeArticles) {\n      this.initPopUp()\n    } else if (free.includes(postId)) {\n      this.initPopUp()\n    } else {\n      this.initModal()\n    }\n  }\n}\n\nconst gatedContentInit = {\n  init() {\n    return new GatedContent()\n  },\n}\n\nexport default gatedContentInit\n","export const inViewPort = (\n  element,\n  callback,\n  options = { rootMargin: '50px', threshold: 0.25 },\n  delay = 0,\n) => {\n  if (!element || !callback) return false\n\n  const inViewObserver = new IntersectionObserver(entries => {\n    entries.forEach(entry => {\n      if (entry.isIntersecting) {\n        const { target } = entry\n        if (delay > 0) {\n          setTimeout(() => {\n            callback(target)\n            inViewObserver.unobserve(target)\n          }, delay)\n          return\n        }\n        callback(target)\n        inViewObserver.unobserve(target)\n      }\n    })\n  }, options)\n\n  inViewObserver.observe(element)\n\n  return element\n}\n\nexport const isInViewport = element => {\n  const rect = element.getBoundingClientRect()\n  const windowHeight =\n    'innerHeight' in window ? window.innerHeight : document.documentElement.offsetHeight\n\n  const top = rect.top + windowHeight >= windowHeight\n  const bottom = rect.bottom <= windowHeight\n\n  return top && bottom\n}\n","const PromotionClick = {\n  init() {\n    const pageTitleEl = document.querySelector('.article__title')\n    const title = pageTitleEl ? pageTitleEl.innerText : ''\n    const elements = document.querySelectorAll('[data-track=\"promo_click\"]')\n    if (elements.length) {\n      elements.forEach(el => {\n        el.addEventListener('click', () => {\n          const { promotion = 'gated_content_modal' } = el.dataset\n          if (window.dataLayer) {\n            window.dataLayer.push({\n              event: 'eec.promotionClick',\n              ecommerce: {\n                promoClick: {\n                  promotions: [\n                    {\n                      id: promotion,\n                      name: promotion,\n                      creative: title,\n                      position: window.location.href,\n                    },\n                  ],\n                },\n              },\n            })\n          }\n        })\n      })\n    }\n  },\n}\n\nexport default PromotionClick\n","import cookie from '../utils/cookie'\nimport { NOTICE_POPUP_COOKIE } from '../constants'\n\nclass NoticePopUp {\n  /**\n   * Constructor\n   *\n   * @param {HTMLElement} el Element with the class `.wsum-notice`\n   */\n  constructor(el) {\n    this.container = el\n    this.closeButton = this.container.querySelector('.wsum-notice__close')\n    this.checkbox = this.container.querySelector('.wsum-notice__checkbox input')\n    this.submitButton = this.container.querySelector('.wsum-notice__submit')\n    this.acknowledgeCookie = cookie.get(NOTICE_POPUP_COOKIE)\n    this.isOpen = false\n\n    this.close = this.close.bind(this)\n    this.accept = this.accept.bind(this)\n    this.toggleSubmit = this.toggleSubmit.bind(this)\n\n    this.init()\n  }\n\n  /**\n   * Opens Pop-Up\n   */\n  open() {\n    this.container.classList.add('active')\n    this.isOpen = true\n  }\n\n  /**\n   * Closes the Pop-Up\n   */\n  close() {\n    this.container.classList.remove('active')\n    this.isOpen = false\n  }\n\n  /**\n   * Acknowledges the pop-up message\n   */\n  accept() {\n    this.close()\n    cookie.set(NOTICE_POPUP_COOKIE, 'acknowledged', 7)\n  }\n\n  /**\n   * Enable/Disable the Submit button\n   */\n  toggleSubmit() {\n    this.submitButton.disabled = !this.checkbox.checked\n  }\n\n  /**\n   * Initializes the Notice Pop-Up\n   */\n  init() {\n    this.closeButton.addEventListener('click', this.close)\n    this.submitButton.addEventListener('click', this.accept)\n    this.checkbox.addEventListener('input', this.toggleSubmit)\n\n    if (!this.acknowledgeCookie) {\n      this.open()\n    }\n  }\n}\n\nconst noticePopUpInit = {\n  init() {\n    const wrapperEl = document.querySelector('.wsum-notice')\n    return wrapperEl ? new NoticePopUp(wrapperEl) : null\n  },\n}\n\nexport default noticePopUpInit\n","/**\n * GTM Controller Object\n */\nconst GTMController = {\n  getPageViewEvent(userIsLoggedIn = false, userIsSubscribed = false, userIsCostumer = false) {\n    if (!userIsLoggedIn) {\n      return 'igt.guestPageView'\n    }\n    if (!userIsCostumer) {\n      return 'igt.subsUserPageView'\n    }\n    if (!userIsSubscribed) {\n      return 'igt.unsubsUserPageView'\n    }\n    return 'igt.subsUserPageView'\n  },\n  getLinkEvent(userIsLoggedIn = false, userIsSubscribed = false, userIsCostumer = false) {\n    if (!userIsLoggedIn) {\n      return 'igt.guestLinkClick'\n    }\n    if (!userIsCostumer) {\n      return 'igt.subsUserLinkClick'\n    }\n    if (!userIsSubscribed) {\n      return 'igt.unsubsUserLinkClick'\n    }\n    return 'igt.subsUserLinkClick'\n  },\n  init() {\n    /**\n     * Track Checkout Step\n     */\n    if (window.track_data) {\n      const { step = '' } = window.track_data\n      if (window.dataLayer && step) {\n        window.dataLayer.push({\n          event: 'eec.checkout',\n          ecommerce: {\n            checkout: {\n              actionField: { step },\n            },\n          },\n        })\n      }\n    }\n\n    if (window.dataLayer && window.wsum) {\n      const pageTitleEl = document.querySelector('.article__title')\n      const pageTitle = pageTitleEl ? pageTitleEl.innerText : ''\n      const { userIsLoggedIn, userIsSubscribed, userIsCostumer } = window.wsum\n\n      /**\n       * Track Inside Golf Page View\n       */\n      window.dataLayer.push({\n        event: 'igt.pageView',\n        insideGolf: {\n          action: {\n            id: 'insideGolf_pageView',\n            creative: pageTitle,\n            position: window.location.href,\n          },\n          user: {\n            isLoggedIn: userIsLoggedIn,\n            isSubscribed: userIsSubscribed,\n            isCostumer: userIsCostumer,\n          },\n        },\n      })\n\n      window.dataLayer.push({\n        event: this.getPageViewEvent(userIsLoggedIn, userIsSubscribed, userIsCostumer),\n        insideGolf: {\n          action: {\n            id: 'insideGolf_pageView',\n            creative: pageTitle,\n            position: window.location.href,\n          },\n        },\n      })\n\n      /**\n       * Track Inside Golf Links Clicks\n       */\n      const links = document.getElementsByTagName('a')\n      if (links && links.length) {\n        Array.from(links).forEach(linkItem => {\n          linkItem.addEventListener('click', () => {\n            const { href } = linkItem\n\n            window.dataLayer.push({\n              event: 'igt.linkClick',\n              insideGolf: {\n                action: {\n                  id: 'insideGolf_click',\n                  creative: pageTitle,\n                  position: window.location.href,\n                  url: href,\n                },\n                user: {\n                  isLoggedIn: userIsLoggedIn,\n                  isSubscribed: userIsSubscribed,\n                  isCostumer: userIsCostumer,\n                },\n              },\n            })\n\n            window.dataLayer.push({\n              event: this.getLinkEvent(userIsLoggedIn, userIsSubscribed, userIsCostumer),\n              insideGolf: {\n                action: {\n                  id: 'insideGolf_click',\n                  creative: pageTitle,\n                  position: window.location.href,\n                  url: href,\n                },\n              },\n            })\n          })\n        })\n      }\n    }\n  },\n}\n\nexport default GTMController\n","const PANTHEON_STRIPPED = 'PANTHEON_STRIPPED'\n\nclass UTMParameters {\n  static fixLinkUTMParameters(el) {\n    if (el.href.includes(PANTHEON_STRIPPED)) {\n      const parameters = ['utm_source', 'utm_medium', 'utm_campaign']\n      const urlParams = new URLSearchParams(window.location.search)\n      const urlObj = new URL(el.href)\n\n      parameters.forEach(paramName => {\n        if (urlObj.searchParams.get(paramName) === PANTHEON_STRIPPED) {\n          urlObj.searchParams.set(paramName, urlParams.get(paramName))\n          el.href = urlObj.toString()\n        }\n      })\n    }\n  }\n\n  static fixInputUTMParameters(el) {\n    if (el.value === PANTHEON_STRIPPED) {\n      const urlParams = new URLSearchParams(window.location.search)\n      el.value = urlParams.get(el.name)\n    }\n  }\n}\n\nconst utmParametersInit = {\n  init() {\n    const links = document.querySelectorAll('.wsum-utm-link')\n    links.forEach(el => UTMParameters.fixLinkUTMParameters(el))\n\n    const inputs = document.querySelectorAll('.wsum-utm-input')\n    inputs.forEach(el => UTMParameters.fixInputUTMParameters(el))\n  },\n}\n\nexport default utmParametersInit\n","/**\n * Triggers a callback function once the DOM is ready\n *\n * @param {function} callback The function to trigger\n */\nexport default function DOMReady(callback) {\n  if (document.readyState !== 'loading') {\n    callback()\n  } else {\n    document.addEventListener('DOMContentLoaded', () => {\n      callback()\n    })\n  }\n}\n","import DOMReady from './utils/DOMReady'\n\nimport bookmark from './modules/bookmark'\nimport bookmarks from './modules/bookmarks'\nimport logout from './modules/logout'\nimport gatedContent from './modules/gated-content'\nimport promotionClick from './modules/promotion-link'\nimport noticePopUp from './modules/notice-pop-up'\nimport GTMController from './modules/tracking'\nimport utmParameters from './modules/utm-parameters'\n\n// eslint-disable-next-line no-unused-vars\nimport css from '../css/wsum-app.scss'\n\nDOMReady(() => {\n  bookmark.init()\n  bookmarks.init()\n  logout.init()\n  gatedContent.init()\n  promotionClick.init()\n  noticePopUp.init()\n  GTMController.init()\n  utmParameters.init()\n})\n"],"names":["module","exports","API_ROOT","window","wsum","api","NOTICE_POPUP_COOKIE","ADWALLET_BOT_COOKIE","GATED_CONTENT_COOKIE","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","__webpack_modules__","key","fetchProps","bypassSessionStorageCache","Promise","resolve","reject","sessionStorage","getItem","cache","JSON","parse","expire","Date","now","fetch","then","async","res","json","success","status","setItem","stringify","catch","err","get","url","response","credentials","headers","error","message","code","getCached","ignoreCache","getCachedRequest","post","data","method","body","Bookmark","this","isBookmarked","button","classList","add","options","bookmarkedClass","wsumBookmarks","postData","openPopUp","remove","removePopUp","popUp","closePopUp","timeOut","clearTimeout","setTimeout","focus","document","createElement","className","innerHTML","documentElement","appendChild","addEventListener","bookmarkItem","e","preventDefault","stopPropagation","endpoint","setAttribute","fetchingClass","API","id","Number","postID","removeAttribute","init","has","destroy","removeEventListener","constructor","el","dataset","bookmark","bind","querySelectorAll","forEach","Bookmarks","fetching","cachedResponse","Object","keys","clear","ids","videos","articles","players","authors","removeItem","cacheItems","includes","push","getPostKey","foundIndex","findIndex","type","is_top_100","golf_video","contributor","course","resort","index","indexOf","splice","userIsLoggedIn","dispatchEvent","CustomEvent","name","cookie","match","set","value","days","date","setTime","getTime","toGMTString","Logout","doLogout","dataLayer","event","insideGolf","action","creative","page_title","position","location","href","pageTitleEl","querySelector","innerText","form","candidateSelectors","candidateSelector","join","NoElement","Element","matches","prototype","msMatchesSelector","webkitMatchesSelector","getRootNode","element","_element$getRootNode","call","ownerDocument","isInert","node","lookUp","_node$getAttribute","inertAtt","getAttribute","parentNode","getCandidates","includeContainer","filter","candidates","Array","slice","apply","unshift","getCandidatesIteratively","elements","elementsToCheck","from","length","shift","tagName","assigned","assignedElements","nestedCandidates","children","flatten","scopeParent","shadowRoot","getShadowRoot","validShadowRoot","shadowRootFilter","_nestedCandidates","hasTabIndex","isNaN","parseInt","getTabIndex","Error","tabIndex","test","_node$getAttribute2","attValue","isContentEditable","sortOrderedTabbables","a","b","documentOrder","isInput","isNonTabbableRadio","isRadio","radioSet","radioScope","queryRadios","CSS","escape","console","checked","nodes","i","getCheckedRadio","isTabbableRadio","isZeroArea","_node$getBoundingClie","getBoundingClientRect","width","height","isHidden","_ref","displayCheck","getComputedStyle","visibility","nodeUnderDetails","parentElement","originalNode","rootNode","assignedSlot","host","_nodeRoot","_nodeRootHost","_nodeRootHost$ownerDo","_node$ownerDocument","nodeRoot","nodeRootHost","attached","contains","_nodeRoot2","_nodeRootHost2","_nodeRootHost2$ownerD","isNodeAttached","getClientRects","isNodeMatchingSelectorFocusable","disabled","isHiddenInput","some","child","isDetailsWithSummary","item","isDisabledFromFieldset","isNodeMatchingSelectorTabbable","isValidShadowRootTabbable","shadowHostNode","sortByOrder","regularTabbables","orderedTabbables","isScope","candidateTabindex","getSortOrderTabIndex","content","sort","reduce","acc","sortable","concat","isTabbable","focusableCandidateSelector","isFocusable","ownKeys","r","t","getOwnPropertySymbols","o","getOwnPropertyDescriptor","enumerable","_objectSpread2","arguments","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","obj","arg","input","hint","prim","Symbol","toPrimitive","TypeError","String","_toPrimitive","_toPropertyKey","configurable","writable","activeFocusTraps","trapStack","trap","activeTrap","pause","trapIndex","unpause","isTabEvent","keyCode","isKeyForward","shiftKey","isKeyBackward","delay","fn","arr","idx","every","valueOrHandler","_len","params","_key","getActualTarget","target","composedPath","internalTrapStack","createFocusTrap","userOptions","doc","config","returnFocusOnDeactivate","escapeDeactivates","delayInitialFocus","state","containers","containerGroups","tabbableGroups","nodeFocusedBeforeActivation","mostRecentlyFocusedNode","active","paused","delayInitialFocusTimer","recentNavEvent","getOption","configOverrideOptions","optionName","configOptionName","findContainerIndex","container","tabbableNodes","find","getNodeForOption","optionValue","_len2","_key2","getInitialFocusNode","tabbableOptions","activeElement","firstTabbableGroup","firstTabbableNode","updateTabbableNodes","map","tabbable","focusableNodes","focusable","lastTabbableNode","firstDomTabbableNode","lastDomTabbableNode","reverse","posTabIndexesFound","nextTabbableNode","forward","nodeIdx","group","g","getActiveElement","tryFocus","preventScroll","toLowerCase","select","isSelectableInput","getReturnFocusNode","previousActiveElement","findNextNavNode","_ref2","_ref2$isBackward","isBackward","destinationNode","containerIndex","containerGroup","startOfGroupIndex","_ref3","destinationGroupIndex","destinationGroup","lastOfGroupIndex","_ref4","_destinationGroupIndex","_destinationGroup","checkPointerDown","clickOutsideDeactivates","deactivate","returnFocus","allowOutsideClick","checkFocusIn","targetContained","Document","nextNode","stopImmediatePropagation","navAcrossContainers","mruContainerIdx","mruTabIdx","n","checkKey","checkKeyNav","checkClick","addListeners","capture","passive","removeListeners","mutationObserver","MutationObserver","mutations","mutation","removedNodes","updateObservedNodes","disconnect","observe","subtree","childList","activate","activateOptions","onActivate","onPostActivate","checkCanFocusTrap","finishActivation","deactivateOptions","onDeactivate","onPostDeactivate","checkCanReturnFocus","finishDeactivation","pauseOptions","onPause","onPostPause","unpauseOptions","onUnpause","onPostUnpause","updateContainerElements","containerElements","elementsAsArray","Boolean","GatedContent","getCookie","cookieValue","atob","viewed","free","setCookie","encodedValue","btoa","openModal","modal","isOpen","focusTrap","tracked","ecommerce","promoView","promotions","top","scrollY","scrollTop","clientTop","scroll","intervalCheck","setInterval","initModal","firstParagraph","callback","rootMargin","threshold","inViewObserver","IntersectionObserver","entries","entry","isIntersecting","unobserve","inViewPort","openPopup","popup","closePopup","initPopUp","popupCloseBtn","isGated","postId","freeArticles","adWalletCookie","title","promotion","promoClick","NoticePopUp","open","close","accept","toggleSubmit","submitButton","checkbox","closeButton","acknowledgeCookie","wrapperEl","getPageViewEvent","userIsSubscribed","userIsCostumer","getLinkEvent","track_data","step","checkout","actionField","pageTitle","user","isLoggedIn","isSubscribed","isCostumer","links","getElementsByTagName","linkItem","PANTHEON_STRIPPED","UTMParameters","fixLinkUTMParameters","parameters","urlParams","URLSearchParams","search","urlObj","URL","paramName","searchParams","toString","fixInputUTMParameters","bookmarks","logout","gatedContent","promotionClick","noticePopUp","GTMController","utmParameters","readyState"],"sourceRoot":""}