index.min.js

/******/ (() => { // webpackBootstrap
/******/ 	var __webpack_modules__ = ({

/***/ 251:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.refresh = refresh;
exports.trap = trap;
exports.untrap = untrap;
var _makeupFocusables = _interopRequireDefault(__webpack_require__(6257));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const _observer = typeof window !== "undefined" ? new MutationObserver(refresh) : null;

// for the element that will be trapped
let trappedEl;

// for the trap boundary/bumper elements
let topTrap;
let outerTrapBefore;
let innerTrapBefore;
let innerTrapAfter;
let outerTrapAfter;
let botTrap;

// for the first and last focusable element inside the trap
let firstFocusableElement;
let lastFocusableElement;
function createTrapBoundary() {
  const trapBoundary = document.createElement("div");
  trapBoundary.setAttribute("aria-hidden", "true");
  trapBoundary.setAttribute("tabindex", "0");
  trapBoundary.className = "keyboard-trap-boundary";
  return trapBoundary;
}
function setFocusToFirstFocusableElement() {
  firstFocusableElement.focus();
}
function setFocusToLastFocusableElement() {
  lastFocusableElement.focus();
}
function createTraps() {
  topTrap = createTrapBoundary();
  outerTrapBefore = topTrap.cloneNode();
  innerTrapBefore = topTrap.cloneNode();
  innerTrapAfter = topTrap.cloneNode();
  outerTrapAfter = topTrap.cloneNode();
  botTrap = topTrap.cloneNode();
  topTrap.addEventListener("focus", setFocusToFirstFocusableElement);
  outerTrapBefore.addEventListener("focus", setFocusToFirstFocusableElement);
  innerTrapBefore.addEventListener("focus", setFocusToLastFocusableElement);
  innerTrapAfter.addEventListener("focus", setFocusToFirstFocusableElement);
  outerTrapAfter.addEventListener("focus", setFocusToLastFocusableElement);
  botTrap.addEventListener("focus", setFocusToLastFocusableElement);
}
function untrap() {
  if (trappedEl) {
    topTrap = safeDetach(topTrap);
    outerTrapBefore = safeDetach(outerTrapBefore);
    innerTrapBefore = safeDetach(innerTrapBefore);
    innerTrapAfter = safeDetach(innerTrapAfter);
    outerTrapAfter = safeDetach(outerTrapAfter);
    botTrap = safeDetach(botTrap);
    trappedEl.classList.remove("keyboard-trap--active");

    // let observers know the keyboard is no longer trapped
    trappedEl.dispatchEvent(new CustomEvent("keyboardUntrap", {
      bubbles: true
    }));
    trappedEl = null;
    _observer?.disconnect();
  }
  return trappedEl;
}
function safeDetach(el) {
  const parent = el.parentNode;
  return parent ? parent.removeChild(el) : el;
}
function trap(el) {
  if (!topTrap) {
    createTraps();
  } else {
    untrap();
  }
  trappedEl = el;

  // when bundled up with isomorphic components on the server, this code is run,
  // so we must check if 'document' is defined.
  const body = typeof document === "undefined" ? null : document.body;
  const focusableElements = (0, _makeupFocusables.default)(trappedEl, true);
  firstFocusableElement = focusableElements[0];
  lastFocusableElement = focusableElements[focusableElements.length - 1];
  body.insertBefore(topTrap, body.childNodes[0]);
  trappedEl.parentNode.insertBefore(outerTrapBefore, trappedEl);
  trappedEl.insertBefore(innerTrapBefore, trappedEl.childNodes[0]);
  trappedEl.appendChild(innerTrapAfter);
  trappedEl.parentNode.insertBefore(outerTrapAfter, trappedEl.nextElementSibling);
  body.appendChild(botTrap);

  // let observers know the keyboard is now trapped
  trappedEl.dispatchEvent(new CustomEvent("keyboardTrap", {
    bubbles: true
  }));
  trappedEl.classList.add("keyboard-trap--active");
  _observer?.observe(el, {
    childList: true,
    subtree: true
  });
  return trappedEl;
}
function refresh() {
  if (topTrap && trappedEl) {
    let focusableElements = (0, _makeupFocusables.default)(trappedEl, true);
    focusableElements = focusableElements.filter(function (el) {
      return !el.classList.contains("keyboard-trap-boundary");
    });
    firstFocusableElement = focusableElements[0];
    lastFocusableElement = focusableElements[focusableElements.length - 1];
  }
}


/***/ }),

/***/ 296:
/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {

__webpack_require__(6939);


/***/ }),

/***/ 1381:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
// extracted by mini-css-extract-plugin


/***/ }),

/***/ 1553:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.modal = modal;
exports.unmodal = unmodal;
var keyboardTrap = _interopRequireWildcard(__webpack_require__(251));
var screenreaderTrap = _interopRequireWildcard(__webpack_require__(3893));
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
const defaultOptions = {
  hoist: false,
  useHiddenProperty: false,
  wrap: false
};
const tags = {
  SCRIPT: "script",
  LINK: "link"
};
let modalEl;
let hoistedPlaceholderEl;
let inertContentEl;
let originalPositionIndexes = [];
function isRootLevel(el) {
  return el.parentNode.tagName.toLowerCase() === "body";
}
function unhoist() {
  if (hoistedPlaceholderEl) {
    hoistedPlaceholderEl.replaceWith(modalEl);
    hoistedPlaceholderEl = null;
  }
}
function hoist() {
  if (!hoistedPlaceholderEl && !isRootLevel(modalEl)) {
    hoistedPlaceholderEl = document.createElement("div");
    hoistedPlaceholderEl.setAttribute("data-makeup-modal", "placeholder");
    modalEl.parentElement.insertBefore(hoistedPlaceholderEl, modalEl);
    document.body.appendChild(modalEl);
  }
}
function wrap() {
  if (!inertContentEl && isRootLevel(modalEl)) {
    inertContentEl = document.createElement("div");
    inertContentEl.setAttribute("data-makeup-modal", "inert");
    [...document.body.children].forEach((child, index) => {
      // checking for the script and link tags is necessary because moving them could cause issues.
      // for example, moving a script to the top of the body could freeze the page while the script loads.
      if (!(child === modalEl || child.tagName.toLowerCase() === tags.SCRIPT || child.tagName === tags.LINK)) {
        inertContentEl.appendChild(child);
        originalPositionIndexes.push(index);
      }
    });
    document.body.prepend(inertContentEl);
  }
}
function unwrap() {
  if (inertContentEl) {
    [...inertContentEl.children].forEach(child => {
      if (!(child.tagName.toLowerCase() === tags.SCRIPT || child.tagName === tags.LINK)) {
        const index = originalPositionIndexes.shift();
        if (index > document.body.children.length) {
          document.body.appendChild(child);
        } else {
          document.body.insertBefore(child, document.body.children[index + 1]);
        }
      }
    });
    inertContentEl.remove();
    inertContentEl = null;
    originalPositionIndexes = [];
  }
}
function unmodal() {
  if (modalEl) {
    keyboardTrap.untrap(modalEl);
    screenreaderTrap.untrap(modalEl);
    unwrap();
    unhoist();
    document.body.removeAttribute("data-makeup-modal");
    modalEl.removeAttribute("data-makeup-modal");
    modalEl.dispatchEvent(new CustomEvent("makeup-unmodal", {
      bubbles: false
    }));
    modalEl = null;
  }
  return modalEl;
}
function modal(el, options) {
  const _options = Object.assign({}, defaultOptions, options);
  unmodal();
  modalEl = el;
  if (_options.hoist) {
    hoist();
  }
  if (_options.wrap) {
    wrap();
  }
  screenreaderTrap.trap(modalEl, options);

  // no need to create keyboard traps when inert content is using hidden property
  if (!_options.useHiddenProperty) {
    keyboardTrap.trap(modalEl);
  }
  document.body.setAttribute("data-makeup-modal", "true");
  modalEl.setAttribute("data-makeup-modal", "widget");
  modalEl.dispatchEvent(new CustomEvent("makeup-modal", {
    bubbles: false
  }));
  return modalEl;
}


/***/ }),

/***/ 2002:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
// extracted by mini-css-extract-plugin


/***/ }),

/***/ 2261:
/***/ ((__unused_webpack_module, exports) => {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.getAncestors = getAncestors;
exports.getSiblings = getSiblings;
exports.getSiblingsOfAncestors = getSiblingsOfAncestors;
// filter function for ancestor elements
const filterAncestor = item => item.nodeType === 1 && item.tagName.toLowerCase() !== "body" && item.tagName.toLowerCase() !== "html";

// filter function for sibling elements
const filterSibling = item => item.nodeType === 1 && item.tagName.toLowerCase() !== "script";

// reducer to flatten arrays
const flattenArrays = (a, b) => a.concat(b);

// recursive function to get previous sibling nodes of given element
function getPreviousSiblings(el) {
  let siblings = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
  const previousSibling = el.previousSibling;
  if (!previousSibling) {
    return siblings;
  }
  siblings.push(previousSibling);
  return getPreviousSiblings(previousSibling, siblings);
}

// recursive function to get next sibling nodes of given element
function getNextSiblings(el) {
  let siblings = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
  const nextSibling = el.nextSibling;
  if (!nextSibling) {
    return siblings;
  }
  siblings.push(nextSibling);
  return getNextSiblings(nextSibling, siblings);
}

// returns all sibling element nodes of given element
function getSiblings(el) {
  const allSiblings = getPreviousSiblings(el).concat(getNextSiblings(el));
  return allSiblings.filter(filterSibling);
}

// recursive function to get all ancestor nodes of given element
function getAllAncestors(el) {
  let ancestors = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
  const nextAncestor = el.parentNode;
  if (!nextAncestor) {
    return ancestors;
  }
  ancestors.push(nextAncestor);
  return getAllAncestors(nextAncestor, ancestors);
}

// get ancestor nodes of given element
function getAncestors(el) {
  return getAllAncestors(el).filter(filterAncestor);
}

// get siblings of ancestors (i.e. aunts and uncles) of given el
function getSiblingsOfAncestors(el) {
  return getAncestors(el).map(item => getSiblings(item)).reduce(flattenArrays, []);
}


/***/ }),

/***/ 2583:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
var _makeupDialog = _interopRequireDefault(__webpack_require__(9893));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const defaultLightboxOptions = {
  baseClass: "lightbox-dialog",
  baseClassModifier: "",
  quickDismiss: true,
  closeButtonSelector: ".lightbox-dialog__close",
  windowSelector: ".lightbox-dialog__window"
};
class _default extends _makeupDialog.default {
  constructor(el) {
    let selectedOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    super(el, Object.assign({}, defaultLightboxOptions, selectedOptions, {
      modal: true
    }));
  }
  _observeEvents() {
    super._observeEvents();
    this._onClickListener = _onClick.bind(this);
    this._el.addEventListener("click", this._onClickListener);
  }
  _unobserveEvents() {
    super._unobserveEvents();
    this._el.removeEventListener("click", this._onClickListener);
  }
  destroy() {
    super.destroy();
    this._onClickListener = null;
  }
}
exports["default"] = _default;
function _onClick(e) {
  if (this._options.quickDismiss === true && e.target === this._el) {
    this.close();
  }
}


/***/ }),

/***/ 3540:
/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {

__webpack_require__(2002);


/***/ }),

/***/ 3866:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
var _makeupLightboxDialog = _interopRequireDefault(__webpack_require__(2583));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const defaultAlertOptions = {
  baseClass: "alert-dialog",
  baseClassModifier: "alert",
  quickDismiss: false,
  acknowledgeButtonSelector: ".alert-dialog__acknowledge",
  windowSelector: ".alert-dialog__window"
};
class _default extends _makeupLightboxDialog.default {
  constructor(el) {
    let selectedOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    super(el, Object.assign({}, defaultAlertOptions, selectedOptions));
  }
  _observeEvents() {
    super._observeEvents();
    this._acknowledgeButtonEl = this._el.querySelector(this._options.acknowledgeButtonSelector);
    this._onAcknowledgeButtonClickListener = _onAcknowledgeButtonClick.bind(this);
    this._acknowledgeButtonEl.addEventListener("click", this._onAcknowledgeButtonClickListener);
  }
  _unobserveEvents() {
    super._unobserveEvents();
    this._acknowledgeButtonEl.removeEventListener("click", this._onAcknowledgeButtonClickListener);
  }
  acknowledge() {
    this._hide();
    this._el.dispatchEvent(new CustomEvent("dialog-acknowledge"));
  }
  destroy() {
    super.destroy();
    this._onAcknowledgeButtonClickListener = null;
  }
}
exports["default"] = _default;
function _onAcknowledgeButtonClick() {
  this.acknowledge();
}


/***/ }),

/***/ 3893:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.trap = trap;
exports.untrap = untrap;
var util = _interopRequireWildcard(__webpack_require__(2261));
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
// the main landmark
let mainEl;

// the element that will be trapped
let trappedEl;

// collection of elements that get 'dirtied' with aria-hidden attr or hidden prop
let dirtyObjects;

// filter function for svg elements
const filterSvg = item => item.tagName.toLowerCase() !== "svg";
function showElementPrep(el, useHiddenProperty) {
  let preparedElement;
  if (useHiddenProperty === false) {
    preparedElement = prepareElement(el, "aria-hidden", "false");
  } else {
    preparedElement = prepareElement(el, "hidden", false);
  }
  return preparedElement;
}
function hideElementPrep(el, useHiddenProperty) {
  let preparedElement;
  if (useHiddenProperty === false) {
    preparedElement = prepareElement(el, "aria-hidden", "true");
  } else {
    preparedElement = prepareElement(el, "hidden", true);
  }
  return preparedElement;
}
function prepareElement(el, attributeName, dirtyValue) {
  const isProperty = typeof dirtyValue === "boolean";
  return {
    el,
    attributeName,
    cleanValue: isProperty ? el[attributeName] : el.getAttribute(attributeName),
    dirtyValue,
    isProperty
  };
}
function dirtyElement(preparedObj) {
  if (preparedObj.isProperty === true) {
    preparedObj.el[preparedObj.attributeName] = preparedObj.dirtyValue;
  } else {
    preparedObj.el.setAttribute(preparedObj.attributeName, preparedObj.dirtyValue);
  }
}
function cleanElement(preparedObj) {
  if (preparedObj.cleanValue) {
    if (preparedObj.isProperty === true) {
      preparedObj.el[preparedObj.attributeName] = preparedObj.cleanValue;
    } else {
      preparedObj.el.setAttribute(preparedObj.attributeName, preparedObj.cleanValue);
    }
  } else {
    preparedObj.el.removeAttribute(preparedObj.attributeName);
  }
}
function untrap() {
  if (trappedEl) {
    // restore 'dirtied' elements to their original state
    dirtyObjects.forEach(item => cleanElement(item));
    dirtyObjects = [];

    // 're-enable' the main landmark
    if (mainEl) {
      mainEl.setAttribute("role", "main");
    }

    // let observers know the screenreader is now untrapped
    trappedEl.dispatchEvent(new CustomEvent("screenreaderUntrap", {
      bubbles: true
    }));
    trappedEl = null;
  }
}
const defaultOptions = {
  useHiddenProperty: false
};
function trap(el, selectedOptions) {
  // ensure current trap is deactivated
  untrap();
  const options = Object.assign({}, defaultOptions, selectedOptions);

  // update the trapped el reference
  trappedEl = el;

  // update the main landmark reference
  mainEl = document.querySelector('main, [role="main"]');

  // we must remove the main landmark to avoid issues on voiceover iOS
  if (mainEl) {
    mainEl.setAttribute("role", "presentation");
  }

  // cache all ancestors, siblings & siblings of ancestors for trappedEl
  const ancestors = util.getAncestors(trappedEl);
  let siblings = util.getSiblings(trappedEl);
  let siblingsOfAncestors = util.getSiblingsOfAncestors(trappedEl);

  // if using hidden property, filter out SVG elements as they do not support this property
  if (options.useHiddenProperty === true) {
    siblings = siblings.filter(filterSvg);
    siblingsOfAncestors = siblingsOfAncestors.filter(filterSvg);
  }

  // prepare elements
  dirtyObjects = [showElementPrep(trappedEl, options.useHiddenProperty)].concat(ancestors.map(item => showElementPrep(item, options.useHiddenProperty))).concat(siblings.map(item => hideElementPrep(item, options.useHiddenProperty))).concat(siblingsOfAncestors.map(item => hideElementPrep(item, options.useHiddenProperty)));

  // update DOM
  dirtyObjects.forEach(item => dirtyElement(item));

  // let observers know the screenreader is now trapped
  trappedEl.dispatchEvent(new CustomEvent("screenreaderTrap", {
    bubbles: true
  }));
}


/***/ }),

/***/ 4658:
/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {

__webpack_require__(8481);
__webpack_require__(3540);


/***/ }),

/***/ 5015:
/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {

__webpack_require__(1381);


/***/ }),

/***/ 5625:
/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {

__webpack_require__(6117);


/***/ }),

/***/ 5957:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
// extracted by mini-css-extract-plugin


/***/ }),

/***/ 6117:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
// extracted by mini-css-extract-plugin


/***/ }),

/***/ 6257:
/***/ ((__unused_webpack_module, exports) => {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = _default;
const focusableElList = ["a[href]", "area[href]", "button:not([disabled])", "embed", "iframe", "input:not([disabled])", "object", "select:not([disabled])", "textarea:not([disabled])", "*[tabindex]", "*[contenteditable]"];
const focusableElSelector = focusableElList.join();
function _default(el) {
  let keyboardOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  let callback = arguments.length > 2 ? arguments[2] : undefined;
  if (callback) {
    const request = requestAnimationFrame(() => {
      callback(getFocusables(el, keyboardOnly));
    });
    return () => {
      cancelAnimationFrame(request);
    };
  }
  return getFocusables(el, keyboardOnly);
}
function getFocusables(el) {
  let keyboardOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  let focusableEls = Array.prototype.slice.call(el.querySelectorAll(focusableElSelector));

  // filter out elements with display: none or nested in a display: none parent
  focusableEls = focusableEls.filter(function (focusableEl) {
    return !!(focusableEl.offsetWidth || focusableEl.offsetHeight || focusableEl.getClientRects().length);
  });
  if (keyboardOnly === true) {
    focusableEls = focusableEls.filter(function (focusableEl) {
      return focusableEl.getAttribute("tabindex") !== "-1";
    });
  }
  return focusableEls;
}


/***/ }),

/***/ 6558:
/***/ ((__unused_webpack_module, exports) => {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = transition;
/**
 * Author: Mr D.Piercey
 */
const TRANSITION_END = "transitionend";
const IMMEDIATE_TRANSITION_REG = /0m?s(?:, )?/g;
/**
 * Applies a primer `-init` class before starting a transition
 * to make transitioning properties that are not animatable easier.
 *
 * **Order**
 * 1. Add class: "$name-init"
 * 2. Wait one frame.
 * 3. Remove class "$name-init".
 * 4. Add class "$name".
 * 5. Wait for animation to finish.
 * 6. Remove class "$name".
 *
 * @param {HTMLElement} el The root element that contains the animation.
 * @param {string} name The base className to use for the transition.
 * @param {Function} cb A callback called after the transition as ended.
 */

function transition(el, baseClass, cb) {
  let ended;
  let pending;
  let ran = 0;
  const classList = el.classList;
  const initClass = "".concat(baseClass, "-init");
  let cancelFrame = nextFrame(function () {
    el.addEventListener(TRANSITION_END, listener, true);
    classList.add(baseClass);
    classList.remove(initClass);
    pending = getTransitionCount(el);
    cancelFrame = undefined;
    if (pending === 0) {
      cancel();
    }
  });
  classList.add(initClass);
  return cancel;
  /**
   * Cancels the current transition and resets the className.
   */

  function cancel() {
    if (ended) {
      return;
    }
    ended = true;
    el.removeEventListener(TRANSITION_END, listener, true);
    if (cancelFrame) {
      cancelFrame();
      classList.remove(initClass);
    } else {
      classList.remove(baseClass);
    }
  }
  /**
   * Handles a single transition end event.
   * Once all child transitions have ended the overall animation is completed.
   */

  function listener() {
    if (++ran === pending) {
      ended = true;
      el.removeEventListener(TRANSITION_END, listener, true);
      classList.remove(baseClass);
      if (cb) {
        cb();
      }
    }
  }
}

/**
 * Walks the tree of an element and counts how many transitions have been applied.
 *
 * @param {HTMLElement} el
 * @return {number}
 */

function getTransitionCount(el) {
  let count = window.getComputedStyle(el).transitionDuration.replace(IMMEDIATE_TRANSITION_REG, "") ? 1 : 0;
  let child = el.firstElementChild;
  while (child) {
    count += getTransitionCount(child);
    child = child.nextElementSibling;
  }
  return count;
}
/**
 * Runs a function during the next animation frame.
 *
 * @param {function} fn a function to run on the next animation frame.
 * @return {function} a function to cancel the callback.
 */

function nextFrame(fn) {
  let frame;
  let cancelFrame;
  if (window.requestAnimationFrame) {
    frame = requestAnimationFrame(function () {
      frame = requestAnimationFrame(fn);
    });
    cancelFrame = cancelAnimationFrame;
  } else {
    frame = setTimeout(fn, 26); // 16ms to simulate RAF, 10ms to ensure called after the frame.

    cancelFrame = clearTimeout;
  }
  return function () {
    if (frame) {
      cancelFrame(frame);
      frame = undefined;
    }
  };
}


/***/ }),

/***/ 6939:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
// extracted by mini-css-extract-plugin


/***/ }),

/***/ 8481:
/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {

__webpack_require__(9357);


/***/ }),

/***/ 9357:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
// extracted by mini-css-extract-plugin


/***/ }),

/***/ 9893:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
var Modal = _interopRequireWildcard(__webpack_require__(1553));
var _makeupFocusables = _interopRequireDefault(__webpack_require__(6257));
var _transition = _interopRequireDefault(__webpack_require__(6558));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
const defaultDialogOptions = {
  baseClass: "dialog",
  closeButtonSelector: ".dialog__close",
  focusManagementIndex: 0,
  modal: false,
  quickDismiss: true,
  transitionsModifier: "mask-fade"
};
class _default {
  constructor(widgetEl, selectedOptions) {
    this._options = Object.assign({}, defaultDialogOptions, selectedOptions);
    this._el = widgetEl;
    if (this._options.modal === true) {
      this._el.setAttribute("aria-modal", "true");
    }
    this._windowEl = this._el.querySelector(this._options.windowSelector);
    this._closeButtonEl = this._el.querySelector(this._options.closeButtonSelector);
    this._hasTransitions = this._el.classList.contains(`${this._options.baseClass}--${this._options.transitionsModifier}`);
    this._onCloseButtonClickListener = _onCloseButtonClick.bind(this);
    this._onKeyDownListener = _onKeyDown.bind(this);
    this._onOpenTransitionEndCallback = _onOpenTransitionEnd.bind(this);
    this._onCloseTransitionEndCallback = _onCloseTransitionEnd.bind(this);
    this._el.classList.add(`${this._options.baseClass}--js`);
    if (!this.hidden) {
      if (this.modal) {
        _doModalFocusManagement(this);
      }
      this._observeEvents();
    }
  }
  get focusables() {
    return (0, _makeupFocusables.default)(this._windowEl);
  }
  get modal() {
    return this._el.getAttribute("aria-modal") === "true";
  }
  get hidden() {
    return this._el.hidden;
  }
  open() {
    this._show();
    this._el.dispatchEvent(new CustomEvent("dialog-open"));
  }
  close() {
    this._hide();
    this._el.dispatchEvent(new CustomEvent("dialog-close"));
  }
  _show() {
    if (this._hasTransitions) {
      if (this._cancelTransition) {
        this._cancelTransition();
      }
      this._cancelTransition = (0, _transition.default)(this._el, `${this._options.baseClass}--show`, this._onOpenTransitionEndCallback);
    } else {
      if (this.modal) {
        setTimeout(() => _doModalFocusManagement(this), 50);
      }
      this._el.hidden = false;
    }
    this._observeEvents();
  }
  _hide() {
    if (this._hasTransitions) {
      if (this._cancelTransition) {
        this._cancelTransition();
      }
      this._cancelTransition = (0, _transition.default)(this._el, `${this._options.baseClass}--hide`, this._onCloseTransitionEndCallback);
    } else {
      if (this.modal) {
        Modal.unmodal();
      }
      this._el.hidden = true;
    }
    this._autoDismissTimeout = null;
    this._unobserveEvents();
  }
  _observeEvents() {
    document.addEventListener("keydown", this._onKeyDownListener);
    if (this._closeButtonEl) {
      this._closeButtonEl.addEventListener("click", this._onCloseButtonClickListener);
    }
  }
  _unobserveEvents() {
    this._el.removeEventListener("click", this._onCloseButtonClickListener);
    document.removeEventListener("keydown", this._onKeyDownListener);
    if (this._closeButtonEl) {
      this._closeButtonEl.addEventListener("click", this._onCloseButtonClickListener);
    }
  }
  destroy() {
    this._destroyed = true;
    this._unobserveEvents();
    this._onCloseButtonClickListener = null;
    this._onKeyDownListener = null;
    this._onOpenTransitionEndCallback = null;
    this._onCloseTransitionEndCallback = null;
    this._autoDismissTimeout = null;
  }
}
exports["default"] = _default;
function _doModalFocusManagement(dialogWidget) {
  const autoFocusEl = dialogWidget._el.querySelector("[autofocus]");
  if (autoFocusEl) {
    autoFocusEl.focus();
  } else {
    dialogWidget.focusables[dialogWidget._options.focusManagementIndex].focus();
  }
  Modal.modal(dialogWidget._el);
}
function _onOpenTransitionEnd() {
  this._el.hidden = false;
  this._cancelTransition = undefined;
  if (this.modal) {
    _doModalFocusManagement(this);
  }
}
function _onCloseTransitionEnd() {
  if (this.modal) {
    Modal.unmodal();
  }
  this._el.hidden = true;
  this._cancelTransition = undefined;
}
function _onKeyDown(e) {
  if (this._options.quickDismiss === true && e.keyCode === 27) {
    this.close();
  }
}
function _onCloseButtonClick() {
  this.close();
}


/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/make namespace object */
/******/ 	(() => {
/******/ 		// define __esModule on exports
/******/ 		__webpack_require__.r = (exports) => {
/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 			}
/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
/******/ 		};
/******/ 	})();
/******/ 	
/************************************************************************/
var __webpack_exports__ = {};
// This entry needs to be wrapped in an IIFE because it needs to be in strict mode.
(() => {
"use strict";


__webpack_require__(5957);
__webpack_require__(4658);
__webpack_require__(5015);
__webpack_require__(296);
__webpack_require__(5625);
var _makeupAlertDialog = _interopRequireDefault(__webpack_require__(3866));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
// STYLES

// REQUIRE
//const AlertDialog = require('makeup-alert-dialog');

// IMPORT

window.onload = function () {
  document.querySelectorAll(".alert-dialog").forEach(function (el, i) {
    const widget = new _makeupAlertDialog.default(el);
  });
};
})();

/******/ })()
;
//# sourceMappingURL=index.min.js.map