{"version":3,"sources":["webpack://SnapSlider/webpack/universalModuleDefinition","webpack://SnapSlider/webpack/bootstrap","webpack://SnapSlider/./node_modules/lodash/isObject.js","webpack://SnapSlider/./node_modules/lodash/debounce.js","webpack://SnapSlider/./node_modules/lodash/throttle.js","webpack://SnapSlider/./node_modules/lodash/_root.js","webpack://SnapSlider/./node_modules/lodash/_Symbol.js","webpack://SnapSlider/./node_modules/smoothscroll-polyfill/dist/smoothscroll.js","webpack://SnapSlider/./node_modules/tabbable/index.js","webpack://SnapSlider/./node_modules/lodash/now.js","webpack://SnapSlider/./node_modules/lodash/_freeGlobal.js","webpack://SnapSlider/(webpack)/buildin/global.js","webpack://SnapSlider/./node_modules/lodash/toNumber.js","webpack://SnapSlider/./node_modules/lodash/_baseTrim.js","webpack://SnapSlider/./node_modules/lodash/_trimmedEndIndex.js","webpack://SnapSlider/./node_modules/lodash/isSymbol.js","webpack://SnapSlider/./node_modules/lodash/_baseGetTag.js","webpack://SnapSlider/./node_modules/lodash/_getRawTag.js","webpack://SnapSlider/./node_modules/lodash/_objectToString.js","webpack://SnapSlider/./node_modules/lodash/isObjectLike.js","webpack://SnapSlider/./node_modules/element-closest/index.mjs","webpack://SnapSlider/./src/helpers/toArray.js","webpack://SnapSlider/./src/helpers/qsa.js","webpack://SnapSlider/./src/helpers/getElements.js","webpack://SnapSlider/./src/helpers/hasOwnProperty.js","webpack://SnapSlider/./src/helpers/isObject.js","webpack://SnapSlider/./src/helpers/minmax.js","webpack://SnapSlider/./src/helpers/passive.js","webpack://SnapSlider/./src/helpers/pick.js","webpack://SnapSlider/./src/helpers/values.js","webpack://SnapSlider/./src/snap-slider.js","webpack://SnapSlider/./src/helpers/getStyle.js","webpack://SnapSlider/./src/helpers/getClosestAttribute.js","webpack://SnapSlider/./src/helpers/onReady.js","webpack://SnapSlider/./src/helpers/on.js","webpack://SnapSlider/./src/helpers/dashes.js","webpack://SnapSlider/./src/modules/logger.js"],"names":["root","factory","exports","module","define","amd","window","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","type","isObject","now","toNumber","nativeMax","Math","max","nativeMin","min","func","wait","options","lastArgs","lastThis","maxWait","result","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","TypeError","invokeFunc","time","args","thisArg","undefined","apply","leadingEdge","setTimeout","timerExpired","shouldInvoke","timeSinceLastCall","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","arguments","this","clearTimeout","cancel","flush","debounce","freeGlobal","freeSelf","self","Function","polyfill","w","document","documentElement","style","__forceSmoothScrollPolyfill__","userAgent","Element","HTMLElement","original","scroll","scrollTo","scrollBy","elementScroll","scrollElement","scrollIntoView","performance","Date","ROUNDING_TOLERANCE","navigator","RegExp","join","test","shouldBailOut","smoothScroll","body","left","scrollX","pageXOffset","top","scrollY","pageYOffset","scrollLeft","scrollTop","SyntaxError","behavior","scrollableParent","findScrollableParent","parentRects","getBoundingClientRect","clientRects","getComputedStyle","position","x","y","firstArg","hasScrollableSpace","el","axis","clientHeight","scrollHeight","clientWidth","scrollWidth","canOverflow","overflowValue","isScrollable","isScrollableY","isScrollableX","parentNode","host","step","context","currentX","currentY","k","elapsed","startTime","cos","PI","startX","startY","method","scrollable","requestAnimationFrame","candidateSelectors","candidateSelector","matches","msMatchesSelector","webkitMatchesSelector","tabbable","candidate","candidateTabindex","regularTabbables","orderedTabbables","candidates","querySelectorAll","includeContainer","Array","slice","unshift","length","isNodeMatchingSelectorTabbable","getTabindex","push","documentOrder","tabIndex","node","sort","sortOrderedTabbables","map","a","concat","isNodeMatchingSelectorFocusable","isInput","isRadio","checked","nodes","getCheckedRadio","ownerDocument","isTabbableRadio","isNonTabbableRadio","disabled","isHiddenInput","offsetParent","visibility","isHidden","isTabbable","Error","isFocusable","focusableCandidateSelector","tabindexAttr","parseInt","getAttribute","isNaN","contentEditable","isContentEditable","b","tagName","global","g","e","baseTrim","isSymbol","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","other","valueOf","isBinary","trimmedEndIndex","reTrimStart","string","replace","reWhitespace","index","charAt","baseGetTag","isObjectLike","getRawTag","objectToString","symToStringTag","objectProto","nativeObjectToString","toString","isOwn","tag","unmasked","ElementPrototype","mozMatchesSelector","selector","elements","Boolean","closest","element","nodeType","toArray","val","qsa","getElements","obj","prop","constructor","minmax","passive","opts","addEventListener","removeEventListener","error","pick","keys","reduce","values","arr","logger","require","counter","SnapSlider","containerOrOptions","terms","prev","next","enableFocus","callbacks","init","container","watchForChanges","_SnapSliders","id","indexOf","button","goto","split","str","trim","pop","sliderID","nav","slider","event","target","getButtonTarget","console","log","idOrElements","forEach","num","slideIndex","isValidIndex","sliderContainer","slideIndexNumber","slide","getIndexNumber","getSlide","section","heading","description","groups","items","collapsed","buttons","navs","getButtons","notFound","slides","start","loop","on","shift","eventName","getMaybeSetID","getMaybeSetSlides","align","getMaybeSetAlign","current","getMaybeSetStart","getMaybeSetLoop","transition","scrolling","navOptions","addGotoButtons","addNav","update","setAttribute","children","getStyle","attr","getClosestAttribute","ceil","getSnapAlign","offsetTop","offsetLeft","offsetHeight","offsetWidth","focus","force","ignoreCallbacks","immediate","getScrollOffset","startTransition","fireEvent","buildGoto","from","to","diff","abs","stuck","checkTransition","stopTransition","match","textContent","toLowerCase","className","isRelative","buttonsOrOptions","hasAttribute","setGoto","nextIndex","isPrevButton","isNextButton","updateButtons","filter","isCurrent","classList","add","remove","removeAttribute","tab","navContainers","navContainer","offset","scrollListener","throttle","getClosest","scrollEndListener","arrowKeyListener","defaultPrevented","isPrev","isNext","preventDefault","resizeObserver","observe","disconnect","ResizeObserver","resizeCallback","focusListener","initialOptions","hasLoaded","updateSlides","handleFocus","events","callback","getCurrentSlide","preventScroll","activeElement","$","fn","snapSlider","readyState","onReady","elementClosest","smoothscroll","parentSelector","childSelector","parent","querySelector","possibleTargets","handleGoto","dashes","char","getSubstitution","params","group","content","item","groupEnd"],"mappings":"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","file":"snap-slider.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"SnapSlider\"] = factory();\n\telse\n\t\troot[\"SnapSlider\"] = factory();\n})(window, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 18);\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","var isObject = require('./isObject'),\n    now = require('./now'),\n    toNumber = require('./toNumber');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        timeWaiting = wait - timeSinceLastCall;\n\n    return maxing\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nmodule.exports = debounce;\n","var debounce = require('./debounce'),\n    isObject = require('./isObject');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide `options` to indicate whether `func`\n * should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the throttled function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=true]\n *  Specify invoking on the leading edge of the timeout.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // Avoid excessively updating the position while scrolling.\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // Cancel the trailing throttled invocation.\n * jQuery(window).on('popstate', throttled.cancel);\n */\nfunction throttle(func, wait, options) {\n  var leading = true,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  if (isObject(options)) {\n    leading = 'leading' in options ? !!options.leading : leading;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n  return debounce(func, wait, {\n    'leading': leading,\n    'maxWait': wait,\n    'trailing': trailing\n  });\n}\n\nmodule.exports = throttle;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","/* smoothscroll v0.4.4 - 2019 - Dustan Kasten, Jeremias Menichelli - MIT License */\n(function () {\n  'use strict';\n\n  // polyfill\n  function polyfill() {\n    // aliases\n    var w = window;\n    var d = document;\n\n    // return if scroll behavior is supported and polyfill is not forced\n    if (\n      'scrollBehavior' in d.documentElement.style &&\n      w.__forceSmoothScrollPolyfill__ !== true\n    ) {\n      return;\n    }\n\n    // globals\n    var Element = w.HTMLElement || w.Element;\n    var SCROLL_TIME = 468;\n\n    // object gathering original scroll methods\n    var original = {\n      scroll: w.scroll || w.scrollTo,\n      scrollBy: w.scrollBy,\n      elementScroll: Element.prototype.scroll || scrollElement,\n      scrollIntoView: Element.prototype.scrollIntoView\n    };\n\n    // define timing method\n    var now =\n      w.performance && w.performance.now\n        ? w.performance.now.bind(w.performance)\n        : Date.now;\n\n    /**\n     * indicates if a the current browser is made by Microsoft\n     * @method isMicrosoftBrowser\n     * @param {String} userAgent\n     * @returns {Boolean}\n     */\n    function isMicrosoftBrowser(userAgent) {\n      var userAgentPatterns = ['MSIE ', 'Trident/', 'Edge/'];\n\n      return new RegExp(userAgentPatterns.join('|')).test(userAgent);\n    }\n\n    /*\n     * IE has rounding bug rounding down clientHeight and clientWidth and\n     * rounding up scrollHeight and scrollWidth causing false positives\n     * on hasScrollableSpace\n     */\n    var ROUNDING_TOLERANCE = isMicrosoftBrowser(w.navigator.userAgent) ? 1 : 0;\n\n    /**\n     * changes scroll position inside an element\n     * @method scrollElement\n     * @param {Number} x\n     * @param {Number} y\n     * @returns {undefined}\n     */\n    function scrollElement(x, y) {\n      this.scrollLeft = x;\n      this.scrollTop = y;\n    }\n\n    /**\n     * returns result of applying ease math function to a number\n     * @method ease\n     * @param {Number} k\n     * @returns {Number}\n     */\n    function ease(k) {\n      return 0.5 * (1 - Math.cos(Math.PI * k));\n    }\n\n    /**\n     * indicates if a smooth behavior should be applied\n     * @method shouldBailOut\n     * @param {Number|Object} firstArg\n     * @returns {Boolean}\n     */\n    function shouldBailOut(firstArg) {\n      if (\n        firstArg === null ||\n        typeof firstArg !== 'object' ||\n        firstArg.behavior === undefined ||\n        firstArg.behavior === 'auto' ||\n        firstArg.behavior === 'instant'\n      ) {\n        // first argument is not an object/null\n        // or behavior is auto, instant or undefined\n        return true;\n      }\n\n      if (typeof firstArg === 'object' && firstArg.behavior === 'smooth') {\n        // first argument is an object and behavior is smooth\n        return false;\n      }\n\n      // throw error when behavior is not supported\n      throw new TypeError(\n        'behavior member of ScrollOptions ' +\n          firstArg.behavior +\n          ' is not a valid value for enumeration ScrollBehavior.'\n      );\n    }\n\n    /**\n     * indicates if an element has scrollable space in the provided axis\n     * @method hasScrollableSpace\n     * @param {Node} el\n     * @param {String} axis\n     * @returns {Boolean}\n     */\n    function hasScrollableSpace(el, axis) {\n      if (axis === 'Y') {\n        return el.clientHeight + ROUNDING_TOLERANCE < el.scrollHeight;\n      }\n\n      if (axis === 'X') {\n        return el.clientWidth + ROUNDING_TOLERANCE < el.scrollWidth;\n      }\n    }\n\n    /**\n     * indicates if an element has a scrollable overflow property in the axis\n     * @method canOverflow\n     * @param {Node} el\n     * @param {String} axis\n     * @returns {Boolean}\n     */\n    function canOverflow(el, axis) {\n      var overflowValue = w.getComputedStyle(el, null)['overflow' + axis];\n\n      return overflowValue === 'auto' || overflowValue === 'scroll';\n    }\n\n    /**\n     * indicates if an element can be scrolled in either axis\n     * @method isScrollable\n     * @param {Node} el\n     * @param {String} axis\n     * @returns {Boolean}\n     */\n    function isScrollable(el) {\n      var isScrollableY = hasScrollableSpace(el, 'Y') && canOverflow(el, 'Y');\n      var isScrollableX = hasScrollableSpace(el, 'X') && canOverflow(el, 'X');\n\n      return isScrollableY || isScrollableX;\n    }\n\n    /**\n     * finds scrollable parent of an element\n     * @method findScrollableParent\n     * @param {Node} el\n     * @returns {Node} el\n     */\n    function findScrollableParent(el) {\n      while (el !== d.body && isScrollable(el) === false) {\n        el = el.parentNode || el.host;\n      }\n\n      return el;\n    }\n\n    /**\n     * self invoked function that, given a context, steps through scrolling\n     * @method step\n     * @param {Object} context\n     * @returns {undefined}\n     */\n    function step(context) {\n      var time = now();\n      var value;\n      var currentX;\n      var currentY;\n      var elapsed = (time - context.startTime) / SCROLL_TIME;\n\n      // avoid elapsed times higher than one\n      elapsed = elapsed > 1 ? 1 : elapsed;\n\n      // apply easing to elapsed time\n      value = ease(elapsed);\n\n      currentX = context.startX + (context.x - context.startX) * value;\n      currentY = context.startY + (context.y - context.startY) * value;\n\n      context.method.call(context.scrollable, currentX, currentY);\n\n      // scroll more if we have not reached our destination\n      if (currentX !== context.x || currentY !== context.y) {\n        w.requestAnimationFrame(step.bind(w, context));\n      }\n    }\n\n    /**\n     * scrolls window or element with a smooth behavior\n     * @method smoothScroll\n     * @param {Object|Node} el\n     * @param {Number} x\n     * @param {Number} y\n     * @returns {undefined}\n     */\n    function smoothScroll(el, x, y) {\n      var scrollable;\n      var startX;\n      var startY;\n      var method;\n      var startTime = now();\n\n      // define scroll context\n      if (el === d.body) {\n        scrollable = w;\n        startX = w.scrollX || w.pageXOffset;\n        startY = w.scrollY || w.pageYOffset;\n        method = original.scroll;\n      } else {\n        scrollable = el;\n        startX = el.scrollLeft;\n        startY = el.scrollTop;\n        method = scrollElement;\n      }\n\n      // scroll looping over a frame\n      step({\n        scrollable: scrollable,\n        method: method,\n        startTime: startTime,\n        startX: startX,\n        startY: startY,\n        x: x,\n        y: y\n      });\n    }\n\n    // ORIGINAL METHODS OVERRIDES\n    // w.scroll and w.scrollTo\n    w.scroll = w.scrollTo = function() {\n      // avoid action when no arguments are passed\n      if (arguments[0] === undefined) {\n        return;\n      }\n\n      // avoid smooth behavior if not required\n      if (shouldBailOut(arguments[0]) === true) {\n        original.scroll.call(\n          w,\n          arguments[0].left !== undefined\n            ? arguments[0].left\n            : typeof arguments[0] !== 'object'\n              ? arguments[0]\n              : w.scrollX || w.pageXOffset,\n          // use top prop, second argument if present or fallback to scrollY\n          arguments[0].top !== undefined\n            ? arguments[0].top\n            : arguments[1] !== undefined\n              ? arguments[1]\n              : w.scrollY || w.pageYOffset\n        );\n\n        return;\n      }\n\n      // LET THE SMOOTHNESS BEGIN!\n      smoothScroll.call(\n        w,\n        d.body,\n        arguments[0].left !== undefined\n          ? ~~arguments[0].left\n          : w.scrollX || w.pageXOffset,\n        arguments[0].top !== undefined\n          ? ~~arguments[0].top\n          : w.scrollY || w.pageYOffset\n      );\n    };\n\n    // w.scrollBy\n    w.scrollBy = function() {\n      // avoid action when no arguments are passed\n      if (arguments[0] === undefined) {\n        return;\n      }\n\n      // avoid smooth behavior if not required\n      if (shouldBailOut(arguments[0])) {\n        original.scrollBy.call(\n          w,\n          arguments[0].left !== undefined\n            ? arguments[0].left\n            : typeof arguments[0] !== 'object' ? arguments[0] : 0,\n          arguments[0].top !== undefined\n            ? arguments[0].top\n            : arguments[1] !== undefined ? arguments[1] : 0\n        );\n\n        return;\n      }\n\n      // LET THE SMOOTHNESS BEGIN!\n      smoothScroll.call(\n        w,\n        d.body,\n        ~~arguments[0].left + (w.scrollX || w.pageXOffset),\n        ~~arguments[0].top + (w.scrollY || w.pageYOffset)\n      );\n    };\n\n    // Element.prototype.scroll and Element.prototype.scrollTo\n    Element.prototype.scroll = Element.prototype.scrollTo = function() {\n      // avoid action when no arguments are passed\n      if (arguments[0] === undefined) {\n        return;\n      }\n\n      // avoid smooth behavior if not required\n      if (shouldBailOut(arguments[0]) === true) {\n        // if one number is passed, throw error to match Firefox implementation\n        if (typeof arguments[0] === 'number' && arguments[1] === undefined) {\n          throw new SyntaxError('Value could not be converted');\n        }\n\n        original.elementScroll.call(\n          this,\n          // use left prop, first number argument or fallback to scrollLeft\n          arguments[0].left !== undefined\n            ? ~~arguments[0].left\n            : typeof arguments[0] !== 'object' ? ~~arguments[0] : this.scrollLeft,\n          // use top prop, second argument or fallback to scrollTop\n          arguments[0].top !== undefined\n            ? ~~arguments[0].top\n            : arguments[1] !== undefined ? ~~arguments[1] : this.scrollTop\n        );\n\n        return;\n      }\n\n      var left = arguments[0].left;\n      var top = arguments[0].top;\n\n      // LET THE SMOOTHNESS BEGIN!\n      smoothScroll.call(\n        this,\n        this,\n        typeof left === 'undefined' ? this.scrollLeft : ~~left,\n        typeof top === 'undefined' ? this.scrollTop : ~~top\n      );\n    };\n\n    // Element.prototype.scrollBy\n    Element.prototype.scrollBy = function() {\n      // avoid action when no arguments are passed\n      if (arguments[0] === undefined) {\n        return;\n      }\n\n      // avoid smooth behavior if not required\n      if (shouldBailOut(arguments[0]) === true) {\n        original.elementScroll.call(\n          this,\n          arguments[0].left !== undefined\n            ? ~~arguments[0].left + this.scrollLeft\n            : ~~arguments[0] + this.scrollLeft,\n          arguments[0].top !== undefined\n            ? ~~arguments[0].top + this.scrollTop\n            : ~~arguments[1] + this.scrollTop\n        );\n\n        return;\n      }\n\n      this.scroll({\n        left: ~~arguments[0].left + this.scrollLeft,\n        top: ~~arguments[0].top + this.scrollTop,\n        behavior: arguments[0].behavior\n      });\n    };\n\n    // Element.prototype.scrollIntoView\n    Element.prototype.scrollIntoView = function() {\n      // avoid smooth behavior if not required\n      if (shouldBailOut(arguments[0]) === true) {\n        original.scrollIntoView.call(\n          this,\n          arguments[0] === undefined ? true : arguments[0]\n        );\n\n        return;\n      }\n\n      // LET THE SMOOTHNESS BEGIN!\n      var scrollableParent = findScrollableParent(this);\n      var parentRects = scrollableParent.getBoundingClientRect();\n      var clientRects = this.getBoundingClientRect();\n\n      if (scrollableParent !== d.body) {\n        // reveal element inside parent\n        smoothScroll.call(\n          this,\n          scrollableParent,\n          scrollableParent.scrollLeft + clientRects.left - parentRects.left,\n          scrollableParent.scrollTop + clientRects.top - parentRects.top\n        );\n\n        // reveal parent in viewport unless is fixed\n        if (w.getComputedStyle(scrollableParent).position !== 'fixed') {\n          w.scrollBy({\n            left: parentRects.left,\n            top: parentRects.top,\n            behavior: 'smooth'\n          });\n        }\n      } else {\n        // reveal element in viewport\n        w.scrollBy({\n          left: clientRects.left,\n          top: clientRects.top,\n          behavior: 'smooth'\n        });\n      }\n    };\n  }\n\n  if (typeof exports === 'object' && typeof module !== 'undefined') {\n    // commonjs\n    module.exports = { polyfill: polyfill };\n  } else {\n    // global\n    polyfill();\n  }\n\n}());\n","var candidateSelectors = [\n  'input',\n  'select',\n  'textarea',\n  'a[href]',\n  'button',\n  '[tabindex]',\n  'audio[controls]',\n  'video[controls]',\n  '[contenteditable]:not([contenteditable=\"false\"])',\n];\nvar candidateSelector = candidateSelectors.join(',');\n\nvar matches = typeof Element === 'undefined'\n  ? function () {}\n  : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;\n\nfunction tabbable(el, options) {\n  options = options || {};\n\n  var regularTabbables = [];\n  var orderedTabbables = [];\n\n  var candidates = el.querySelectorAll(candidateSelector);\n\n  if (options.includeContainer) {\n    if (matches.call(el, candidateSelector)) {\n      candidates = Array.prototype.slice.apply(candidates);\n      candidates.unshift(el);\n    }\n  }\n\n  var i, candidate, candidateTabindex;\n  for (i = 0; i < candidates.length; i++) {\n    candidate = candidates[i];\n\n    if (!isNodeMatchingSelectorTabbable(candidate)) continue;\n\n    candidateTabindex = getTabindex(candidate);\n    if (candidateTabindex === 0) {\n      regularTabbables.push(candidate);\n    } else {\n      orderedTabbables.push({\n        documentOrder: i,\n        tabIndex: candidateTabindex,\n        node: candidate,\n      });\n    }\n  }\n\n  var tabbableNodes = orderedTabbables\n    .sort(sortOrderedTabbables)\n    .map(function(a) { return a.node })\n    .concat(regularTabbables);\n\n  return tabbableNodes;\n}\n\ntabbable.isTabbable = isTabbable;\ntabbable.isFocusable = isFocusable;\n\nfunction isNodeMatchingSelectorTabbable(node) {\n  if (\n    !isNodeMatchingSelectorFocusable(node)\n    || isNonTabbableRadio(node)\n    || getTabindex(node) < 0\n  ) {\n    return false;\n  }\n  return true;\n}\n\nfunction isTabbable(node) {\n  if (!node) throw new Error('No node provided');\n  if (matches.call(node, candidateSelector) === false) return false;\n  return isNodeMatchingSelectorTabbable(node);\n}\n\nfunction isNodeMatchingSelectorFocusable(node) {\n  if (\n    node.disabled\n    || isHiddenInput(node)\n    || isHidden(node)\n  ) {\n    return false;\n  }\n  return true;\n}\n\nvar focusableCandidateSelector = candidateSelectors.concat('iframe').join(',');\nfunction isFocusable(node) {\n  if (!node) throw new Error('No node provided');\n  if (matches.call(node, focusableCandidateSelector) === false) return false;\n  return isNodeMatchingSelectorFocusable(node);\n}\n\nfunction getTabindex(node) {\n  var tabindexAttr = parseInt(node.getAttribute('tabindex'), 10);\n  if (!isNaN(tabindexAttr)) return tabindexAttr;\n  // 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 (isContentEditable(node)) return 0;\n  return node.tabIndex;\n}\n\nfunction sortOrderedTabbables(a, b) {\n  return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;\n}\n\nfunction isContentEditable(node) {\n  return node.contentEditable === 'true';\n}\n\nfunction isInput(node) {\n  return node.tagName === 'INPUT';\n}\n\nfunction isHiddenInput(node) {\n  return isInput(node) && node.type === 'hidden';\n}\n\nfunction isRadio(node) {\n  return isInput(node) && node.type === 'radio';\n}\n\nfunction isNonTabbableRadio(node) {\n  return isRadio(node) && !isTabbableRadio(node);\n}\n\nfunction getCheckedRadio(nodes) {\n  for (var i = 0; i < nodes.length; i++) {\n    if (nodes[i].checked) {\n      return nodes[i];\n    }\n  }\n}\n\nfunction isTabbableRadio(node) {\n  if (!node.name) return true;\n  // This won't account for the edge case where you have radio groups with the same\n  // in separate forms on the same page.\n  var radioSet = node.ownerDocument.querySelectorAll('input[type=\"radio\"][name=\"' + node.name + '\"]');\n  var checked = getCheckedRadio(radioSet);\n  return !checked || checked === node;\n}\n\nfunction isHidden(node) {\n  // offsetParent being null will allow detecting cases where an element is invisible or inside an invisible element,\n  // as long as the element does not use position: fixed. For them, their visibility has to be checked directly as well.\n  return node.offsetParent === null || getComputedStyle(node).visibility === 'hidden';\n}\n\nmodule.exports = tabbable;\n","var root = require('./_root');\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\nmodule.exports = now;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","var baseTrim = require('./_baseTrim'),\n    isObject = require('./isObject'),\n    isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = baseTrim(value);\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = toNumber;\n","var trimmedEndIndex = require('./_trimmedEndIndex');\n\n/** Used to match leading whitespace. */\nvar reTrimStart = /^\\s+/;\n\n/**\n * The base implementation of `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\nfunction baseTrim(string) {\n  return string\n    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n    : string;\n}\n\nmodule.exports = baseTrim;\n","/** Used to match a single whitespace character. */\nvar reWhitespace = /\\s/;\n\n/**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\nfunction trimmedEndIndex(string) {\n  var index = string.length;\n\n  while (index-- && reWhitespace.test(string.charAt(index))) {}\n  return index;\n}\n\nmodule.exports = trimmedEndIndex;\n","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","function polyfill(window) {\n  var ElementPrototype = window.Element.prototype;\n\n  if (typeof ElementPrototype.matches !== 'function') {\n    ElementPrototype.matches = ElementPrototype.msMatchesSelector || ElementPrototype.mozMatchesSelector || ElementPrototype.webkitMatchesSelector || function matches(selector) {\n      var element = this;\n      var elements = (element.document || element.ownerDocument).querySelectorAll(selector);\n      var index = 0;\n\n      while (elements[index] && elements[index] !== element) {\n        ++index;\n      }\n\n      return Boolean(elements[index]);\n    };\n  }\n\n  if (typeof ElementPrototype.closest !== 'function') {\n    ElementPrototype.closest = function closest(selector) {\n      var element = this;\n\n      while (element && element.nodeType === 1) {\n        if (element.matches(selector)) {\n          return element;\n        }\n\n        element = element.parentNode;\n      }\n\n      return null;\n    };\n  }\n}\n\nexport default polyfill;\n//# sourceMappingURL=index.mjs.map\n","/**\r\n * Convert a value to an array.\r\n * @param  {mixed}   val\r\n * @return {Array}\r\n */\r\nexport default function toArray(val) {\r\n  return Array.prototype.slice.call(val);\r\n}\r\n","import toArray from './toArray';\r\n\r\n/**\r\n * QSA = \"Query Selector All\" that returns an Array instead of a NodeList.\r\n * @param  {String}   selector\r\n * @param  {Element}  context\r\n * @return {Array}\r\n */\r\nexport default function qsa(selector, context) {\r\n  return selector ? toArray((context || document).querySelectorAll(selector)) : [];\r\n}\r\n","import qsa from './qsa';\r\n\r\n/**\r\n * Get an array of elements from a mixed-value parameter.\r\n * Accepts Strings, Elements, and Array-like values.\r\n * @param  {String|Element|Array}  elements\r\n * @param  {Element}  context\r\n * @return {Array}\r\n */\r\nexport default function getElements(elements, context) {\r\n  // 1. If value is a String, query the DOM\r\n  if (typeof elements === 'string') {\r\n    return qsa(elements, context);\r\n  }\r\n\r\n  // 2. Put single element in an Array\r\n  if (elements instanceof Element) {\r\n    return [elements];\r\n  }\r\n\r\n  // 3. Assume everything can be treated like an Array\r\n  if (elements) {\r\n    return Array.prototype.slice.call(elements);\r\n  }\r\n\r\n  // 4. Otherwise, fallback to an empty array\r\n  return [];\r\n}\r\n","/**\r\n * Check whether an object actually has a property.\r\n * @param  {Object} obj\r\n * @param  {String} prop\r\n * @return {Boolean}\r\n */\r\nexport default function hasOwnProperty(obj, prop) {\r\n  return Object.prototype.hasOwnProperty.call(obj, prop);\r\n}\r\n","/**\r\n * Strict check for Objects. Literally checks whether\r\n * the value's constructor is \"Object\".\r\n * @param  {mixed}  val\r\n * @return {String}\r\n */\r\nexport default function isObject(val) {\r\n  return val && val.constructor.name === 'Object';\r\n}\r\n","/**\r\n * Keep a value within some minimum and maximum values.\r\n * @param  {Number}  value\r\n * @param  {Number}  min\r\n * @param  {Number}  max\r\n * @return {Number}\r\n */\r\nexport default function minmax(value, min, max) {\r\n  value = Math.min(max, value);\r\n  value = Math.max(min, value);\r\n  return value;\r\n}\r\n","/* eslint-disable getter-return */\r\n\r\n/**\r\n * Passive Event Listeners.\r\n *\r\n * Pass this value as a 3rd argument to your event listeners\r\n * to dramatically improve performance.\r\n *\r\n * @see https://developers.google.com/web/updates/2016/06/passive-event-listeners\r\n * @see https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md#feature-detection\r\n * @type {Boolean}\r\n */\r\nconst passive = (() => {\r\n  let result = false;\r\n\r\n  try {\r\n    const opts = Object.defineProperty({}, 'passive', {\r\n      get: function get() {\r\n        result = { passive: true };\r\n      },\r\n    });\r\n    window.addEventListener('testPassive', null, opts);\r\n    window.removeEventListener('testPassive', null, opts);\r\n  } catch (error) {\r\n    // 🤫\r\n  }\r\n\r\n  return result;\r\n})();\r\n\r\nexport default passive;\r\n","/**\r\n * Pick keys from an object.\r\n * @param  {Object} obj\r\n * @param  {Array}  keys\r\n * @return {Object}\r\n */\r\nexport default function pick(obj, keys) {\r\n  return keys.reduce((result, key) => {\r\n    result[key] = obj[key];\r\n\r\n    return result;\r\n  }, {});\r\n}\r\n","/* eslint-disable no-restricted-syntax, no-var, vars-on-top */\r\n\r\nimport hasOwnProperty from './hasOwnProperty';\r\n\r\n/**\r\n * Helper that does the same thing as `Object.values()`. Works in IE!\r\n * @param  {Object}  obj\r\n * @return {Array}\r\n */\r\nfunction values(obj) {\r\n  var arr = [];\r\n\r\n  for (var prop in obj) {\r\n    if (hasOwnProperty(obj, prop)) {\r\n      arr.push(obj[prop]);\r\n    }\r\n  }\r\n\r\n  return arr;\r\n}\r\n\r\n// Use native code if supported, else return polyfill.\r\n// eslint-disable-next-line no-confusing-arrow\r\nconst fn = (() => typeof Object.values === 'function' ? Object.values : values)();\r\n\r\nexport default fn;\r\n","// Dependencies\r\nimport elementClosest from 'element-closest';\r\nimport smoothscroll from 'smoothscroll-polyfill';\r\nimport tabbable from 'tabbable';\r\n\r\n// Helpers\r\nimport debounce from 'lodash/debounce';\r\nimport throttle from 'lodash/throttle';\r\nimport getClosestAttribute from './helpers/getClosestAttribute';\r\nimport getElements from './helpers/getElements';\r\nimport getStyle from './helpers/getStyle';\r\nimport hasOwnProperty from './helpers/hasOwnProperty';\r\nimport isObject from './helpers/isObject';\r\nimport minmax from './helpers/minmax';\r\nimport on from './helpers/on';\r\nimport onReady from './helpers/onReady';\r\nimport passive from './helpers/passive';\r\nimport pick from './helpers/pick';\r\nimport qsa from './helpers/qsa';\r\nimport toArray from './helpers/toArray';\r\nimport values from './helpers/values';\r\n\r\n// Modules\r\nconst logger = (process.env.NODE_ENV !== 'production')\r\n  ? require('./modules/logger')\r\n  : {};\r\n\r\n// Internal Variables\r\nlet counter = 1;\r\n\r\n/**\r\n * Snap Slider.\r\n * @class\r\n */\r\nclass SnapSlider {\r\n  /**\r\n   * New Snap Slider.\r\n   *\r\n   * See `init()` for a full breakdown of `options`.\r\n   *\r\n   * @param  {String|Element|Array|Object}  containerOrOptions\r\n   * @param  {Object}                       options\r\n   * @constructor\r\n   */\r\n  constructor(containerOrOptions, options = {}) {\r\n    // Setup internal variables.\r\n    this.terms = {\r\n      prev: /(prev|back|before|left|up)/,\r\n      next: /(next|forward|after|right|down)/,\r\n    };\r\n\r\n    this.enableFocus = false;\r\n\r\n    /* eslint-disable quote-props */\r\n    this.callbacks = {\r\n      'load': [],\r\n      'change': [],\r\n      'change.click': [],\r\n      'change.scroll': [],\r\n      'change.keydown': [],\r\n      'change.focusin': [],\r\n      'scroll': [],\r\n      'scroll.start': [],\r\n      'scroll.end': [],\r\n    };\r\n    /* eslint-enable quote-props */\r\n\r\n    this.init(containerOrOptions, options);\r\n\r\n    // Don't construct sliders with empty containers.\r\n    if (!this.container) {\r\n      return;\r\n    }\r\n\r\n    this.watchForChanges();\r\n\r\n    // Keep track of the slider so we can reference & debug it later.\r\n    this.container.SnapSlider = this;\r\n    window._SnapSliders[this.id] = this;\r\n  }\r\n\r\n  /**\r\n   * Initialize this slider.\r\n   *\r\n   * @param  {String|Element|Array|Object}  containerOrOptions\r\n   * @param  {Object}                       options\r\n   * @param  {String|Element|Array}         options.container\r\n   * @param  {String}                       options.id\r\n   * @param  {String|Element|Array}         options.slides\r\n   * @param  {String|Number}                options.start\r\n   * @param  {String|Element|Array}         options.nav\r\n   * @param  {String|Element|Array}         options.buttons\r\n   * @param  {String|Element|Array}         options.prev\r\n   * @param  {String|Element|Array}         options.next\r\n   * @return {void}\r\n   */\r\n  init(containerOrOptions, options = {}) {\r\n    // Allow people to quickly spin up sliders by just passing a container\r\n    // element, or by passing in a single options object.\r\n    if (isObject(containerOrOptions)) {\r\n      options = containerOrOptions;\r\n    }\r\n\r\n    // Fill default options.\r\n    this.options = {\r\n      container: containerOrOptions,\r\n      id: '',\r\n      slides: '',\r\n      nav: '',\r\n      buttons: '',\r\n      prev: '',\r\n      next: '',\r\n      start: 0,\r\n      loop: null,\r\n      on: {},\r\n      ...options,\r\n    };\r\n\r\n    // Get single element from params.\r\n    const container = getElements(this.options.container).shift();\r\n\r\n    // Don't construct sliders with empty containers.\r\n    if (!container) {\r\n      if (process.env.NODE_ENV !== 'production') {\r\n        console.log(`\r\n🚫 Whoops! Snap Slider can't find a container element matching \"${this.options.container}\".\\n\r\n🔍 Please check your selectors for typos. Make sure the element actually exists\r\n   in the DOM when Snap Slider tries to initialize it.\\n\r\n👇 Here's a copy of the options you tried to initialize with for debugging:\\n\\n`, this.options, '\\n\\n');\r\n      }\r\n      return;\r\n    }\r\n\r\n    // Great! Now let's start initializing everything.\r\n    this.container = container;\r\n\r\n    // Get selectors from JavaScript or data attributes.\r\n    this.options.buttons = options.buttons || this.container.getAttribute('data-snap-slider-buttons');\r\n    this.options.prev = options.prev || this.container.getAttribute('data-snap-slider-prev');\r\n    this.options.next = options.next || this.container.getAttribute('data-snap-slider-next');\r\n\r\n    // Get and set persistent options in data attributes.\r\n    this.id = this.getMaybeSetID(container, this.options.id);\r\n    this.slides = this.getMaybeSetSlides(container, this.options.slides);\r\n    this.align = this.getMaybeSetAlign(container, this.options.align);\r\n    this.current = this.getMaybeSetStart(container, this.options.start);\r\n    this.loop = this.getMaybeSetLoop(container, this.options.loop);\r\n\r\n    // Reset internal variables.\r\n    this.transition = null;\r\n    this.scrolling = false;\r\n\r\n    // Add custom callbacks.\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    for (const eventName in this.options.on) {\r\n      if (hasOwnProperty(this.options.on, eventName)) {\r\n        this.on(eventName, this.options.on[eventName]);\r\n      }\r\n    }\r\n\r\n    // Setup navigation.\r\n    // NOTE: If left blank, `addNav()` will handle the fallbacks for button selectors.\r\n    const navOptions = pick(this.options, [\r\n      'buttons',\r\n      'prev',\r\n      'next',\r\n    ]);\r\n\r\n    // Init custom goto buttons in the container.\r\n    // NOTE: \"Goto\" buttons are automatically handled by delegated click\r\n    // events on the `body`. For more details, see `handleGotoClick()`.\r\n    this.addGotoButtons({ ...navOptions, container });\r\n\r\n    // Init standard navs with data attributes.\r\n    this.addNav(`[data-snap-slider-nav=\"${this.id}\"]`, navOptions);\r\n\r\n    // Then init custom navs too.\r\n    if (this.options.nav) {\r\n      this.addNav(this.options.nav, navOptions);\r\n    }\r\n\r\n    // Go to the slide we want to start on.\r\n    this.update();\r\n  }\r\n\r\n  /**\r\n   * Get and maybe set a slider's ID on the closest container element.\r\n   *\r\n   * If no ID was specified, generates a fallback ID.\r\n   *\r\n   * @param  {Element}  container\r\n   * @param  {String}   id\r\n   * @return {String}\r\n   */\r\n  getMaybeSetID(container, id) {\r\n    // Either use the ID we were given or the ID already on the container.\r\n    id = id\r\n      || container.getAttribute('data-snap-slider')\r\n      || container.id;\r\n\r\n    // If we don't have an ID, make one up and increment our internal\r\n    // counter for the next slider.\r\n    if (!id) {\r\n      id = `slider-${counter}`;\r\n      counter += 1;\r\n    }\r\n\r\n    // Store value in data attribute.\r\n    container.setAttribute('data-snap-slider', id);\r\n\r\n    // Return the final ID.\r\n    return id;\r\n  }\r\n\r\n  /**\r\n   * Get all slide elements for a given container.\r\n   *\r\n   * Defaults to container's children.\r\n   *\r\n   * @param  {Element}  container\r\n   * @param  {String}   selector\r\n   * @return {Array}\r\n   */\r\n  getMaybeSetSlides(container, selector) {\r\n    // Get selector from JavaScript or data attribute.\r\n    selector = selector && typeof selector === 'string'\r\n      ? selector\r\n      : container.getAttribute('data-snap-slider-slides');\r\n\r\n    // Store value in data attribute.\r\n    container.setAttribute('data-snap-slider-slides', selector || '');\r\n\r\n    // If selector exists, use those elements. Otherwise,\r\n    // assume the container's immediate children are slides.\r\n    const slides = selector\r\n      ? getElements(selector, container)\r\n      : toArray(container.children);\r\n\r\n    // Ensure all slides are focusable but not tabbable.\r\n    if (this.enableFocus) {\r\n      slides.forEach((slide) => slide.setAttribute('tabindex', '-1'));\r\n    }\r\n\r\n    // Return array of slides.\r\n    return slides;\r\n  }\r\n\r\n  /**\r\n   * Get alignment fallback for a given container.\r\n   *\r\n   * @param  {Element}  container\r\n   * @param  {String}   align\r\n   * @return {String}\r\n   */\r\n  getMaybeSetAlign(container, align) {\r\n    // Get align index from JavaScript, data attribute, or leave blank.\r\n    align = align || container.getAttribute('data-snap-slider-align') || '';\r\n\r\n    // Store value in data attribute.\r\n    container.setAttribute('data-snap-slider-align', align);\r\n\r\n    return align;\r\n  }\r\n\r\n  /**\r\n   * Get start index for a given container.\r\n   *\r\n   * Defaults to 1.\r\n   *\r\n   * @param  {Element}  container\r\n   * @param  {String}   start\r\n   * @return {String|Number}\r\n   */\r\n  getMaybeSetStart(container, start) {\r\n    // Get start index from JavaScript, data attribute, or default to 1.\r\n    if (!SnapSlider.isValidIndex(start)) {\r\n      start = container.getAttribute('data-snap-slider-start') || 1;\r\n    }\r\n\r\n    // Store value in data attribute.\r\n    container.setAttribute('data-snap-slider-start', start);\r\n\r\n    return start;\r\n  }\r\n\r\n  /**\r\n   * Get and maybe set a slider's `loop` option on the closest container element.\r\n   *\r\n   * @param  {Element}  container\r\n   * @param  {Boolean}  loop\r\n   * @return {String}\r\n   */\r\n  getMaybeSetLoop(container, loop) {\r\n    // If we were given a Boolean value to set, use that.\r\n    // Else check for an existing data attribute.\r\n    // Defaults to `false`.\r\n    loop = typeof loop === 'boolean'\r\n      ? loop\r\n      : container.getAttribute('data-snap-slider-loop') === 'true';\r\n\r\n    // Store value in data attribute.\r\n    container.setAttribute('data-snap-slider-loop', loop);\r\n\r\n    // Return the final loop value.\r\n    return loop;\r\n  }\r\n\r\n  /**\r\n   * Get the `scroll-snap-align` for a snap slider element.\r\n   *\r\n   * Falls back to `data-snap-slider-align` when no CSS\r\n   * is detected, otherwise defaults to `start`.\r\n   *\r\n   * @param  {Element}  el\r\n   * @return {String}\r\n   */\r\n  getSnapAlign(el) {\r\n    // Get element's CSS align value.\r\n    const style = getStyle(el, 'scrollSnapAlign');\r\n\r\n    // If browser supports Scroll Snap and slide\r\n    // has a non-empty value, return it.\r\n    if (style && style.indexOf('none') < 0) {\r\n      return style;\r\n    }\r\n\r\n    // Otherwise, fallback to the slider's align attribute.\r\n    // Else assume \"start\" for everything.\r\n    return getClosestAttribute(el, 'data-snap-slider-align')\r\n      || 'start';\r\n  }\r\n\r\n  /**\r\n   * Get a specific slide element. Accepts any valid goto alias.\r\n   *\r\n   * @param  {Number}   index  Starts at 1.\r\n   * @return {Element}\r\n   */\r\n  getSlide(index) {\r\n    // Convert index aliases to numbers.\r\n    index = this.getIndexNumber(index);\r\n\r\n    // Return the slide for that numeric index.\r\n    // NOTE: Subtract 1 because the array is 0-index, but our API is 1-index.\r\n    return this.slides[index - 1];\r\n  }\r\n\r\n  /**\r\n   * Get the current slide element.\r\n   *\r\n   * @return {Element}\r\n   */\r\n  getCurrentSlide() {\r\n    // NOTE: Subtract 1 because the array is 0-index, but our API is 1-index.\r\n    return this.slides[this.current - 1];\r\n  }\r\n\r\n  /**\r\n   * Is this a valid index?\r\n   *\r\n   * - first\r\n   * - middle\r\n   * - last\r\n   * - prev\r\n   * - next\r\n   *\r\n   * @param  {String|Number}  index\r\n   * @return {Number}\r\n   */\r\n  static isValidIndex(index) {\r\n    const aliases = [\r\n      'first',\r\n      'middle',\r\n      'last',\r\n      'prev',\r\n      'next',\r\n    ];\r\n\r\n    // Valid indexes are either a known alias,\r\n    // or a positive integer.\r\n    return aliases.indexOf(index) >= 0\r\n      || parseInt(index, 10) >= 1;\r\n  }\r\n\r\n  /**\r\n   * Get the slide number for any index.\r\n   *\r\n   * Returns -1 if index is invalid.\r\n   *\r\n   * @param  {String|Number}  index\r\n   * @return {Number}\r\n   */\r\n  getIndexNumber(index) {\r\n    let num;\r\n\r\n    if (index === 'first') {\r\n      // Get the first slide.\r\n      num = 1;\r\n    } else if (index === 'middle') {\r\n      // Get the middle slide.\r\n      num = Math.ceil(this.slides.length / 2);\r\n    } else if (index === 'last') {\r\n      // Get the last slide.\r\n      num = this.slides.length;\r\n    } else if (index === 'prev') {\r\n      // Get the previous slide.\r\n      num = this.current - 1;\r\n    } else if (index === 'next') {\r\n      // Get the next slide.\r\n      num = this.current + 1;\r\n    } else {\r\n      // Try to get a number.\r\n      num = parseInt(index, 10) || -1;\r\n    }\r\n\r\n    if (this.loop) {\r\n      // If we're looping, send out-of-bounds requests\r\n      // to the other end of the slider.\r\n      if (num < 1) {\r\n        num = this.slides.length;\r\n      }\r\n\r\n      if (num > this.slides.length) {\r\n        num = 1;\r\n      }\r\n    } else if (num < 1 || num > this.slides.length) {\r\n      // Otherwise, ignore out-of-range indexes.\r\n      num = -1;\r\n    }\r\n\r\n    // Return numeric index. Or, if something goes wrong,\r\n    // fallback to the first slide.\r\n    return num || 1;\r\n  }\r\n\r\n  /**\r\n   * Get the offset we should scroll to for a specific slide.\r\n   *\r\n   * @param  {Element}  slide\r\n   * @return {Object}   { top, left }\r\n   */\r\n  getScrollOffset(slide) {\r\n    const { container } = this;\r\n    const align = this.getSnapAlign(slide);\r\n\r\n    // Calculate the 'start' position by default.\r\n    // NOTE: This forces slides with align `none` to still snap into place.\r\n    let top = slide.offsetTop;\r\n    let left = slide.offsetLeft;\r\n\r\n    // NOTE: Because Safari uses the 2-value syntax, we simply check for matching\r\n    // keywords. If this causes incorrect behavior, use the `data-snap-slider-align`\r\n    // attribute to override our automatic CSS detection.\r\n    if (align.indexOf('center') >= 0) {\r\n      // To center a slide, start with its beginning offset (the 'start' position).\r\n      // Then add half the slide's size minus half the container size.\r\n      top = slide.offsetTop + slide.offsetHeight / 2 - container.offsetHeight / 2;\r\n      left = slide.offsetLeft + slide.offsetWidth / 2 - container.offsetWidth / 2;\r\n    } else if (align.indexOf('end') >= 0) {\r\n      // To align the end of a slide, start with its beginning offset (the 'start' position).\r\n      // Then subtract the size of the container, but add back the size of the slide.\r\n      top = slide.offsetTop - container.offsetHeight + slide.offsetHeight;\r\n      left = slide.offsetLeft - container.offsetWidth + slide.offsetWidth;\r\n    }\r\n\r\n    // Keep offsets within the scrollable area.\r\n    top = minmax(top, 0, container.scrollHeight);\r\n    left = minmax(left, 0, container.scrollWidth);\r\n\r\n    return { top, left };\r\n  }\r\n\r\n  /**\r\n   * Go to a slide.\r\n   *\r\n   * @param  {String|Number}  index                    Starts at 1.\r\n   * @param  {Object}         options\r\n   * @param  {Boolean}        options.focus\r\n   * @param  {Boolean}        options.force\r\n   * @param  {Boolean}        options.ignoreCallbacks\r\n   * @param  {Boolean}        options.immediate\r\n   * @param  {Event}          event\r\n   * @return {Boolean}\r\n   */\r\n  goto(index, options = {}, event) {\r\n    // Fill default options.\r\n    options = {\r\n      // By default, focus the slide we're going to.\r\n      focus: true,\r\n      // Force-update the scroll position, even if we're already on the current slide.\r\n      force: false,\r\n      // Ignore custom callbacks for events.\r\n      ignoreCallbacks: false,\r\n      // Immediately update position without smooth scrolling.\r\n      immediate: false,\r\n      ...options,\r\n    };\r\n\r\n    // Get the next slide we should go to.\r\n    const next = this.getIndexNumber(index);\r\n\r\n    // If nothing changed, don't do anything (as long as\r\n    // we're not trying to force it).\r\n    if (!options.force && next === this.current) {\r\n      return false;\r\n    }\r\n\r\n    // Get the next slide.\r\n    const slide = this.getSlide(next);\r\n\r\n    if (!slide) {\r\n      return false;\r\n    }\r\n\r\n    // Scroll to it!\r\n    const { top, left } = this.getScrollOffset(slide);\r\n\r\n    if (options.immediate) {\r\n      // Scroll immediately.\r\n      this.container.scroll({ top, left });\r\n    } else {\r\n      // Let the event handlers know we're coming, then smooth scroll.\r\n      this.startTransition(next);\r\n      this.container.scroll({ top, left, behavior: 'smooth' });\r\n    }\r\n\r\n    // Update state.\r\n    this.current = next;\r\n\r\n    // We changed slides!\r\n    this.fireEvent('change', event, options);\r\n\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * Build the `goto` attribute for a nav button.\r\n   *\r\n   * @param  {Element|Boolean}  nav\r\n   * @param  {String|Number}    index\r\n   * @return {String}\r\n   */\r\n  buildGoto(nav, index = '') {\r\n    // Start with an empty string.\r\n    let goto = '';\r\n\r\n    // If this button isn't part of a nav, include the slider ID.\r\n    if (!nav) {\r\n      goto += `${this.id}:`;\r\n    }\r\n\r\n    // Add the index and return.\r\n    return goto + index;\r\n  }\r\n\r\n  /**\r\n   * Set the `goto` attribute for nav buttons.\r\n   *\r\n   * @param  {String|Element|Array}  buttons\r\n   * @param  {String}                index\r\n   * @return {void}\r\n   */\r\n  setGoto(buttons, index) {\r\n    buttons = getElements(buttons);\r\n\r\n    // If we found custom prev/next buttons, set their `goto` attributes\r\n    // before we loop through the rest of the buttons.\r\n    buttons.forEach((button) => {\r\n      button.setAttribute('data-snap-slider-goto', this.buildGoto(\r\n        // Don't assume this button is grouped with the others. It may\r\n        // be somewhere else on the page, so double check for a parent\r\n        // slider or nav container.\r\n        button.closest('[data-snap-slider], [data-snap-slider-nav]'),\r\n        index,\r\n      ));\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Get the slider ID and slide index a goto button is targeting.\r\n   *\r\n   * NOTE: This method is static so we can call it in the delegated body\r\n   * click events. For more details, see `handleGotoClick()`.\r\n   *\r\n   * @param  {String|Element|Array}  button\r\n   * @return {Object}                { sliderID, index }\r\n   */\r\n  static getButtonTarget(button) {\r\n    // Where are we going?\r\n    const goto = button ? button.getAttribute('data-snap-slider-goto') : '';\r\n\r\n    // Ignore missing buttons and attributes.\r\n    if (!goto) {\r\n      return {};\r\n    }\r\n\r\n    // Parse slide index and slider ID from `goto` attribute.\r\n    const args = goto.split(':').map((str) => str.trim());\r\n    const index = args.pop();\r\n    let sliderID = args.pop();\r\n\r\n    // If the slider ID wasn't included, check for a parent nav or container element.\r\n    if (!sliderID) {\r\n      const nav = button.closest('[data-snap-slider-nav]');\r\n      const container = button.closest('[data-snap-slider]');\r\n\r\n      // If it is in a nav or container, get the slider ID from there.\r\n      if (nav) {\r\n        sliderID = nav.getAttribute('data-snap-slider-nav');\r\n      }\r\n\r\n      if (container) {\r\n        sliderID = container.getAttribute('data-snap-slider');\r\n      }\r\n    }\r\n\r\n    // If there's still no slider ID, is this button already in a slider?\r\n    if (!sliderID) {\r\n      const slider = button.closest('data-snap-slider');\r\n\r\n      // If it is in a slider, get the slider ID from there.\r\n      if (slider) {\r\n        sliderID = slider.getAttribute('data-snap-slider');\r\n      }\r\n    }\r\n\r\n    return { sliderID, index };\r\n  }\r\n\r\n  /**\r\n   * Handle click events for nav (aka \"goto\") buttons.\r\n   *\r\n   * By delegating events to the body, we can automatically\r\n   * handle dynamic goto buttons (i.e., without having to\r\n   * reinitialize slider events).\r\n   *\r\n   * @param  {Event}  event\r\n   * @return {void}\r\n   */\r\n  static handleGoto(event) {\r\n    // Get the button we clicked.\r\n    const button = event.target.closest('[data-snap-slider-goto]');\r\n\r\n    // Get the slider we're trying to update.\r\n    const { sliderID, index } = SnapSlider.getButtonTarget(button);\r\n    const slider = window._SnapSliders[sliderID];\r\n\r\n    // Make sure it actually exists.\r\n    if (!slider) {\r\n      return;\r\n    }\r\n\r\n    // Go! But only focus the slide if we're NOT clicking a prev/next button.\r\n    slider.goto(index, null, event);\r\n  }\r\n\r\n  /**\r\n   * Start transitioning to another slide.\r\n   *\r\n   * This way when you click a nav button, the current slide updates\r\n   * immediately but the scroll listener doesn't override it, or fire\r\n   * extra change events.\r\n   *\r\n   * @param  {Number}  next\r\n   * @return {void}\r\n   */\r\n  startTransition(next) {\r\n    // Tell the scroll listener which slide we're transitioning to.\r\n    this.transition = {\r\n      from: this.current,\r\n      to: next,\r\n      diff: Math.abs(next - this.current),\r\n    };\r\n\r\n    // In case someone's fast enough to start scrolling again before our\r\n    // scroll listener resolves the `transition` flag, or if the slide's\r\n    // already visible and nothing actually has to scroll,\r\n    // set a timeout to resolve the transition.\r\n    const stuck = this.transition.to;\r\n\r\n    // If there's already a check waiting, clear it to avoid accidentally\r\n    // reverting to the wrong slide.\r\n    if (this.checkTransition) {\r\n      clearTimeout(this.checkTransition);\r\n    }\r\n\r\n    // Now make sure we don't get stuck!\r\n    this.checkTransition = setTimeout(() => {\r\n      if (this.transition.to === stuck) {\r\n        this.stopTransition();\r\n      }\r\n    }, 1000);\r\n  }\r\n\r\n  /**\r\n   * Stop the transitions! Set things back to normal.\r\n   *\r\n   * @return {void}\r\n   */\r\n  stopTransition() {\r\n    // Clear transition checks.\r\n    this.transition = null;\r\n    clearTimeout(this.checkTransition);\r\n  }\r\n\r\n  /**\r\n   * Is this a \"previous\" button?\r\n   *\r\n   * @param  {String|Element|Array}  button\r\n   * @return {Boolean}\r\n   */\r\n  isPrevButton(button) {\r\n    button = getElements(button).shift();\r\n\r\n    // Ignore missing elements.\r\n    if (!button) {\r\n      return false;\r\n    }\r\n\r\n    // Check whether the `goto` attribute is \"prev\".\r\n    // If not, check the text & class for common \"prev\" terms.\r\n    return (button.getAttribute('data-snap-slider-goto') || '').match(/\\bprev$/)\r\n      || button.textContent.toLowerCase().match(this.terms.prev)\r\n      || button.className.toLowerCase().match(this.terms.prev);\r\n  }\r\n\r\n  /**\r\n   * Is this a \"next\" button?\r\n   *\r\n   * @param  {String|Element|Array}  button\r\n   * @return {Boolean}\r\n   */\r\n  isNextButton(button) {\r\n    button = getElements(button).shift();\r\n\r\n    // Ignore missing elements.\r\n    if (!button) {\r\n      return false;\r\n    }\r\n\r\n    // Check whether the `goto` attribute is \"next\".\r\n    // If not, check the text & class for common \"next\" terms.\r\n    return (button.getAttribute('data-snap-slider-goto') || '').match(/\\bnext$/)\r\n      || button.textContent.toLowerCase().match(this.terms.next)\r\n      || button.className.toLowerCase().match(this.terms.next);\r\n  }\r\n\r\n  /**\r\n   * Is this index a relative term? I.e., is it `prev` or `next`?\r\n   *\r\n   * @param  {String|Number}  index\r\n   * @return {Boolean}\r\n   */\r\n  static isRelative(index) {\r\n    return index === 'prev' || index === 'next';\r\n  }\r\n\r\n  /**\r\n   * Does an index match the current slide?\r\n   *\r\n   * @param  {String|Number}  index\r\n   * @return {Boolean}\r\n   */\r\n  isCurrent(index) {\r\n    // Ignore relative indexes (i.e., `prev` and `next`) since they\r\n    // always refer to one more or less than the current index.\r\n    if (SnapSlider.isRelative(index)) {\r\n      return false;\r\n    }\r\n\r\n    // Does this numeric index match the current slide?\r\n    return this.getIndexNumber(index) === this.current;\r\n  }\r\n\r\n  /**\r\n   * Add goto buttons for the current slider.\r\n   *\r\n   * @param  {String|Element|Array|Object}  buttonsOrOptions\r\n   * @param  {Object}                       options\r\n   * @param  {String|Element|Array}         options.container\r\n   * @param  {String|Element|Array}         options.buttons\r\n   * @param  {String|Element|Array}         options.prev\r\n   * @param  {String|Element|Array}         options.next\r\n   * @return {Boolean}\r\n   */\r\n  addGotoButtons(buttonsOrOptions, options = {}) {\r\n    // Allow people to quickly add nav buttons by just passing the\r\n    // selector, or by passing in a single options object.\r\n    if (isObject(buttonsOrOptions)) {\r\n      options = buttonsOrOptions;\r\n    }\r\n\r\n    // Fill default options.\r\n    options = {\r\n      container: '',\r\n      buttons: buttonsOrOptions,\r\n      prev: '',\r\n      next: '',\r\n      ...options,\r\n    };\r\n\r\n    // Get button elements.\r\n    // NOTE: If someone passes an overly-generic selector (e.g., `button`)\r\n    // this will query the entire document. In general, you should either\r\n    // specify a container element, use specific selectors, or pass\r\n    // the elements directly.\r\n    const buttons = getElements(options.buttons, options.container);\r\n    const prev = getElements(options.prev, options.container);\r\n    const next = getElements(options.next, options.container);\r\n\r\n    // If we found custom prev/next buttons, set their `goto` attributes\r\n    // before we loop through the rest of the buttons.\r\n    prev.forEach((b) => b.hasAttribute('data-snap-slider-goto') || this.setGoto(prev, 'prev'));\r\n    next.forEach((b) => b.hasAttribute('data-snap-slider-goto') || this.setGoto(next, 'next'));\r\n\r\n    // Keep track of the index outside of the loop so we can\r\n    // skip prev/next buttons but still go in order.\r\n    let nextIndex = 1;\r\n\r\n    // Loop through the buttons and set each one's `goto` attribute.\r\n    buttons.forEach((button) => {\r\n      // Ignore buttons that already have a `goto` attribute.\r\n      if (button.hasAttribute('data-snap-slider-goto')) {\r\n        return null;\r\n      }\r\n\r\n      // Previous\r\n      if (this.isPrevButton(button)) {\r\n        return this.setGoto(button, 'prev');\r\n      }\r\n\r\n      // Next\r\n      if (this.isNextButton(button)) {\r\n        return this.setGoto(button, 'next');\r\n      }\r\n\r\n      // Numeric: Check the text for a number, else fallback to the next index.\r\n      const index = parseInt(button.textContent.replace(/.*\\b(\\d+)\\b.*/, '$1'), 10) || nextIndex;\r\n\r\n      // Increment the next index.\r\n      nextIndex = index + 1;\r\n\r\n      return this.setGoto(button, index);\r\n    });\r\n\r\n    this.updateButtons();\r\n\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * Get navs for the current slider.\r\n   *\r\n   * @return {Array}\r\n   */\r\n  getNavs() {\r\n    // eslint-disable-next-line arrow-body-style\r\n    return qsa('[data-snap-slider-nav]').filter((nav) => {\r\n      // Only return navs targeting the current slider.\r\n      return nav.getAttribute('data-snap-slider-nav') === this.id;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Get nav buttons for the current slider.\r\n   *\r\n   * @return {Array}\r\n   */\r\n  getButtons() {\r\n    return qsa('[data-snap-slider-goto]').filter((button) => {\r\n      const { sliderID } = SnapSlider.getButtonTarget(button);\r\n      // Only return buttons targeting the current slider.\r\n      return sliderID === this.id;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Update nav buttons for the current slider.\r\n   *\r\n   * @return {void}\r\n   */\r\n  updateButtons() {\r\n    // Wait until the slider has initialized.\r\n    if (!this.current) {\r\n      return;\r\n    }\r\n\r\n    // Loop through all the nav buttons.\r\n    this.getButtons().forEach((button) => {\r\n      // Figure out which slide it's for...\r\n      const { index } = SnapSlider.getButtonTarget(button);\r\n\r\n      // And update its class.\r\n      if (this.isCurrent(index)) {\r\n        button.classList.add('is-current');\r\n      } else {\r\n        button.classList.remove('is-current');\r\n      }\r\n\r\n      // Also, enable/disable relative buttons unless `loop` is on.\r\n      if (!this.loop && SnapSlider.isRelative(index)) {\r\n        // Disable prev button on first slide.\r\n        // Disable next button on last slide.\r\n        const disabled = (index === 'prev' && this.current === 1)\r\n          || (index === 'next' && this.current === this.slides.length);\r\n\r\n        if (disabled) {\r\n          // button.setAttribute('disabled', '');\r\n          button.classList.add('is-disabled');\r\n        } else {\r\n          // button.removeAttribute('disabled', '');\r\n          button.classList.remove('is-disabled');\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Update slide active states when the slider changes.\r\n   *\r\n   * @return {void}\r\n   */\r\n  updateSlides() {\r\n    this.slides.forEach((slide, index) => {\r\n      // NOTE: Subtract 1 because the array is 0-index, but our API is 1-index.\r\n      if (index === this.current - 1) {\r\n        slide.classList.add('is-current');\r\n        slide.removeAttribute('aria-hidden');\r\n\r\n        // Enable tabbing for current slide\r\n        qsa('[data-snap-slider-tabindex]', slide).forEach((tab) => {\r\n          tab.removeAttribute('tabindex');\r\n        });\r\n      } else {\r\n        slide.classList.remove('is-current');\r\n        slide.setAttribute('aria-hidden', 'true');\r\n\r\n        // Disable tabbing for non-current slides\r\n        tabbable(slide).forEach((tab) => {\r\n          tab.setAttribute('tabindex', '-1');\r\n          tab.setAttribute('data-snap-slider-tabindex', '');\r\n        });\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Add a nav element for the current slider. Automatically hooks up any nav\r\n   * buttons inside the nav.\r\n   *\r\n   * @param  {String|Element|Array|Object}  containerOrOptions\r\n   * @param  {Object}                       options\r\n   * @param  {String|Element|Array}         options.container\r\n   * @param  {String|Element|Array}         options.buttons\r\n   * @param  {String|Element|Array}         options.prev\r\n   * @param  {String|Element|Array}         options.next\r\n   * @return {Boolean}\r\n   */\r\n  addNav(containerOrOptions, options = {}) {\r\n    // Allow people to quickly add a nav by just passing a container\r\n    // element, or by passing in a single options object.\r\n    if (isObject(containerOrOptions)) {\r\n      options = containerOrOptions;\r\n    }\r\n\r\n    // Fill default options.\r\n    options = {\r\n      container: containerOrOptions,\r\n      buttons: '',\r\n      prev: '',\r\n      next: '',\r\n      ...options,\r\n    };\r\n\r\n    // Get matching nav containers.\r\n    const navContainers = getElements(options.container);\r\n\r\n    // Don't add navs without container elements.\r\n    if (!navContainers.length) {\r\n      return false;\r\n    }\r\n\r\n    navContainers.forEach((navContainer) => {\r\n      // Set a data attribute assigning the nav to this slider.\r\n      navContainer.setAttribute('data-snap-slider-nav', this.id);\r\n\r\n      // Get button selectors from JavaScript, data attribute, or default to 'button'.\r\n      // NOTE: In this case, allow the nav's data attribute to override the parent\r\n      // container's options.\r\n      const buttons = navContainer.getAttribute('data-snap-slider-buttons')\r\n        || options.buttons\r\n        || 'button';\r\n      const prev = options.prev || navContainer.getAttribute('data-snap-slider-prev');\r\n      const next = options.next || navContainer.getAttribute('data-snap-slider-next');\r\n\r\n      // And add them.\r\n      this.addGotoButtons({\r\n        container: navContainer,\r\n        buttons,\r\n        prev,\r\n        next,\r\n      });\r\n    });\r\n\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * Which slide is closest to its active offset position?\r\n   *\r\n   * Returns an object include the slide's index, element,\r\n   * and the diff between its active offset and our\r\n   * current scroll position.\r\n   *\r\n   * @return {Object}  { index, slide, diff }\r\n   */\r\n  getClosest() {\r\n    return this.slides.reduce((prev, slide, index) => {\r\n      // 1-index to stay consistent with our API.\r\n      index += 1;\r\n\r\n      // How far away are we from the next slide's active offset position?\r\n      const offset = this.getScrollOffset(slide);\r\n      const diff = {\r\n        top: Math.abs(this.container.scrollTop - offset.top),\r\n        left: Math.abs(this.container.scrollLeft - offset.left),\r\n      };\r\n\r\n      // Save the next slide's info to compare with other slides.\r\n      const next = { index, slide, diff };\r\n\r\n      // If this is the first slide, return it and compare the next one.\r\n      if (!prev) {\r\n        return next;\r\n      }\r\n\r\n      // Compare each slide to see which one is the closest to its active offset position.\r\n      // As soon as the next slide is at least as close as the previous one, return it.\r\n      if (next.diff.left <= prev.diff.left && next.diff.top <= prev.diff.top) {\r\n        return next;\r\n      }\r\n\r\n      // Otherwise, keep the last closest slide.\r\n      return prev;\r\n    // Init with `false` so the first slide gets processed just like the rest of them.\r\n    }, false);\r\n  }\r\n\r\n  /**\r\n   * Watch the container scroll for when the current slide changes.\r\n   *\r\n   * @return {void}\r\n   */\r\n  watchForChanges() {\r\n    // Scroll listener. Save so we can remove it during `destroy()`.\r\n    this.scrollListener = throttle((event) => {\r\n      // Which slide is closest to their active offset position?\r\n      const closest = this.getClosest();\r\n\r\n      // If someone's passively scrolling (i.e., not in a transition),\r\n      // then  as soon as we've scrolled to another slide, mark that\r\n      // slide as the new current one and fire a change event.\r\n      if (!this.transition && closest.index !== this.current) {\r\n        this.current = closest.index;\r\n        this.fireEvent('change', event);\r\n      }\r\n\r\n      // If we just started scrolling, update state and\r\n      // fire a `scroll.start` event.\r\n      if (!this.scrolling) {\r\n        this.scrolling = true;\r\n        this.fireEvent('scroll.start', event);\r\n      }\r\n\r\n      // Fire a generic `scroll` event.\r\n      this.fireEvent('scroll', event);\r\n    }, 250);\r\n\r\n    // Scroll end listener. Save so we can remove it during `destroy()`.\r\n    this.scrollEndListener = debounce((event) => {\r\n      // We're done scrolling!\r\n      this.scrolling = false;\r\n      this.fireEvent('scroll.end', event);\r\n\r\n      // Clear any previous transition checks.\r\n      // NOTE: This has to happen *after* we fire the `scroll.end` event,\r\n      // otherwise `handleFocus` won't be able to access `this.transition`.\r\n      this.stopTransition();\r\n    }, 250);\r\n\r\n    // Arrow key listener. Save so we can remove it during `destroy()`.\r\n    this.arrowKeyListener = throttle((event) => {\r\n      // Ignore events that have already been prevented.\r\n      if (event.defaultPrevented) {\r\n        return;\r\n      }\r\n\r\n      // Listen for arrow keys.\r\n      // @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key\r\n      const isPrev = ['Up', 'ArrowUp', 'Left', 'ArrowLeft'].indexOf(event.key) >= 0;\r\n      const isNext = ['Down', 'ArrowDown', 'Right', 'ArrowRight'].indexOf(event.key) >= 0;\r\n\r\n      // Ignore non-arrow keys.\r\n      if (!isPrev && !isNext) {\r\n        return;\r\n      }\r\n\r\n      // Go to the next or previous slide.\r\n      this.goto(isNext ? 'next' : 'prev', null, event);\r\n\r\n      // Prevent default browser scroll.\r\n      event.preventDefault();\r\n    }, 250);\r\n\r\n    // Resize Observer. Save so we can disconnect it during `destroy()`.\r\n    // Only init if browser supports it, else fallback to noop.\r\n    this.resizeObserver = { observe: () => {}, disconnect: () => {} };\r\n    if ('ResizeObserver' in window) {\r\n      this.resizeObserver = new ResizeObserver(this.resizeCallback.bind(this));\r\n    }\r\n\r\n    // Add all our listeners.\r\n    // Set timeout to avoid initial `goto` event triggering a scroll listener.\r\n    setTimeout(() => {\r\n      this.container.addEventListener('scroll', this.scrollListener, passive);\r\n      this.container.addEventListener('scroll', this.scrollEndListener, passive);\r\n      this.container.addEventListener('keydown', this.arrowKeyListener);\r\n      this.container.addEventListener('focusin', this.focusListener);\r\n      this.resizeObserver.observe(this.container);\r\n\r\n      // Done loading!\r\n      this.fireEvent('load');\r\n    }, 100);\r\n  }\r\n\r\n  /**\r\n   * Update the slider on load.\r\n   *\r\n   * @return {void}\r\n   */\r\n  hasLoaded() {\r\n    this.container.classList.add('has-loaded');\r\n  }\r\n\r\n  /**\r\n   * Update this slider (e.g., on resize). Basically just repositions the\r\n   * current slide.\r\n   *\r\n   * @return {void}\r\n   */\r\n  update() {\r\n    // Make sure we're still on the current slide.\r\n    this.goto(this.current, {\r\n      focus: false,\r\n      force: true,\r\n      ignoreCallbacks: true,\r\n      immediate: true,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Destroy this slider. Stop any active transitions, remove its event\r\n   * listeners, and delete it from our internal array of slider instances.\r\n   *\r\n   * @return {void}\r\n   */\r\n  destroy() {\r\n    // Stop running transitions, event listeners, etc.\r\n    this.stopTransition();\r\n    this.container.removeEventListener('scroll', this.scrollListener);\r\n    this.container.removeEventListener('scroll', this.scrollEndListener);\r\n    this.container.removeEventListener('keydown', this.arrowKeyListener);\r\n    this.resizeObserver.disconnect();\r\n\r\n    // Reset callbacks.\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    for (const eventName in this.callbacks) {\r\n      if (hasOwnProperty(this.callbacks, eventName)) {\r\n        this.callbacks[eventName] = [];\r\n      }\r\n    }\r\n\r\n    // Remove references to this slider.\r\n    delete this.container.SnapSlider;\r\n    delete window._SnapSliders[this.id];\r\n  }\r\n\r\n  /**\r\n   * Reset this slider (e.g., after adding or removing a slide).\r\n   *\r\n   * See `init()` for a full breakdown of `options`.\r\n   *\r\n   * @param  {Object}  options\r\n   * @return {void}\r\n   */\r\n  reset(options = {}) {\r\n    // Copy initial options.\r\n    const initialOptions = this.options;\r\n\r\n    // Remove initial callbacks to avoid duplicating them.\r\n    delete initialOptions.on;\r\n\r\n    // Don't let people reset critical options during reset (e.g., slider ID).\r\n    delete options.container;\r\n    delete options.id;\r\n\r\n    // Re-initialize this slider with initial options + overrides.\r\n    this.init(this.container, { ...initialOptions, ...options });\r\n  }\r\n\r\n  /**\r\n   * Handle resize observer events.\r\n   *\r\n   * @return {void}\r\n   */\r\n  resizeCallback() {\r\n    this.update();\r\n  }\r\n\r\n  /**\r\n   * When an event happens, fire all the callback functions for that event.\r\n   *\r\n   * @param  {String}   eventName\r\n   * @param  {Event}    event\r\n   * @param  {Object}   options\r\n   * @param  {Boolean}  options.focus\r\n   * @param  {Boolean}  options.ignoreCallbacks\r\n   * @return {void}\r\n   */\r\n  fireEvent(eventName, event, options = {}) {\r\n    // Ignore invalid events.\r\n    if (!hasOwnProperty(this.callbacks, eventName)) {\r\n      return;\r\n    }\r\n\r\n    // Fill default options.\r\n    options = {\r\n      // By default, focus the slide we're going to.\r\n      focus: true,\r\n      // Ignore custom callbacks for events.\r\n      ignoreCallbacks: false,\r\n      ...options,\r\n    };\r\n\r\n    // Required: Update slider attributes on load.\r\n    if (eventName === 'load') {\r\n      this.hasLoaded();\r\n    }\r\n\r\n    // Required: Update buttons and slides on every change.\r\n    if (eventName === 'change') {\r\n      this.updateButtons();\r\n      this.updateSlides();\r\n    }\r\n\r\n    // Allow focus events to be ignored.\r\n    if (options.focus) {\r\n      this.handleFocus(eventName, event);\r\n    }\r\n\r\n    // Allow callbacks to be ignored.\r\n    if (options.ignoreCallbacks) {\r\n      return;\r\n    }\r\n\r\n    // Fallback object for `null` events.\r\n    event = event || {};\r\n\r\n    // Include more granular event types for easier callbacks.\r\n    const events = [eventName];\r\n\r\n    if (hasOwnProperty(this.callbacks, `${eventName}.${event.type}`)) {\r\n      events.push(`${eventName}.${event.type}`);\r\n    }\r\n\r\n    // Fire all the callbacks for each event.\r\n    events.forEach((name) => {\r\n      this.callbacks[name].forEach((callback) => {\r\n        if (typeof callback === 'function') {\r\n          callback(this, event);\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Handle focus events differently depending on whether we're manually\r\n   * triggering changes or passively scrolling.\r\n   *\r\n   * @param  {String}   eventName\r\n   * @param  {Event}    event\r\n   * @return {void}\r\n   */\r\n  handleFocus(eventName, event) {\r\n    // Only handle focus for manually triggered changes (e.g., clicks and key presses).\r\n    // Ignore passive scrolling to avoid mistakenly hijacking someone's focus.\r\n    if (!this.transition) {\r\n      return;\r\n    }\r\n\r\n    // Only focus the slide if we're NOT clicking a prev/next button.\r\n    if (event && eventName === 'change') {\r\n      // Did we click a button?\r\n      const button = event.target.closest('[data-snap-slider-goto]');\r\n      const { index } = SnapSlider.getButtonTarget(button);\r\n\r\n      // If we clicked a relative button, get out.\r\n      if (SnapSlider.isRelative(index)) {\r\n        return;\r\n      }\r\n    }\r\n\r\n    // If we're only transitioning one slide over, focus immediately on change.\r\n    if (this.transition.diff <= 1 && eventName === 'change') {\r\n      this.getCurrentSlide().focus({ preventScroll: true });\r\n    }\r\n\r\n    // If we're transitioning across multiple slides, wait until the scroll ends to focus.\r\n    // Otherwise, we'll cause the scroll to flicker.\r\n    if (this.transition.diff > 1 && eventName === 'scroll.end') {\r\n      // Only focus the slide if we haven't already focused on another\r\n      // element during the transition.\r\n      if (!document.activeElement\r\n        || document.activeElement === document.body\r\n        || document.activeElement.closest('[data-snap-slider-goto]')) {\r\n        this.getCurrentSlide().focus({ preventScroll: true });\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Add callbacks to fire on specific events.\r\n   *\r\n   * @param  {String}    event     Event name.\r\n   * @param  {Function}  callback  Function w/ slider and event params (e.g., `fn(slider, event)`).\r\n   * @return {void}\r\n   */\r\n  on(event, callback) {\r\n    // Ignore invalid events.\r\n    if (!hasOwnProperty(this.callbacks, event)) {\r\n      if (process.env.NODE_ENV !== 'production') {\r\n        console.log(`\r\n🚫 Whoops! Snap Slider can't add events for \"${event}\".\\n\r\n📝 Please make sure your event matches one of the ones in this list:\\n\\n`, Object.keys(this.callbacks), '\\n\\n');\r\n      }\r\n      return;\r\n    }\r\n\r\n    // Ignore invalid callbacks.\r\n    if (typeof callback !== 'function') {\r\n      if (process.env.NODE_ENV !== 'production') {\r\n        console.log(`\r\n  🚫 Whoops! Snap Slider can only add functions as callbacks.\\n\r\n  👀 It looks like you passed a \"${typeof callback}\" instead.\\n\\n`, callback, '\\n\\n');\r\n      }\r\n      return;\r\n    }\r\n\r\n    // Add the callback for our event.\r\n    this.callbacks[event].push(callback);\r\n  }\r\n\r\n  /**\r\n   * Log that we couldn't find the element you're looking for.\r\n   *\r\n   * @param  {mixed}  element\r\n   * @return {void}\r\n   */\r\n  static notFound(element) {\r\n    if (process.env.NODE_ENV !== 'production') {\r\n      console.log(`\r\n😢 Oh no! Snap Slider couldn't find a slider for \"${element}\".\\n\r\n-------------------------------------------------------------------------------------------\r\nℹ️ NOTE: Make sure the elements you're trying to debug have a \\`data-snap-slider\\` attribute.\r\n-------------------------------------------------------------------------------------------\\n\\n`);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get the `SnapSlider` object for a slider based on its ID.\r\n   *\r\n   * @param  {String}      id\r\n   * @return {SnapSlider}\r\n   */\r\n  static get(id) {\r\n    return window._SnapSliders[id];\r\n  }\r\n\r\n  /**\r\n   * `console.log` info about a slider, its nav, or goto buttons.\r\n   *\r\n   * @param  {String|Element|Array} idOrElements\r\n   * @return {void}\r\n   */\r\n  static debug(idOrElements) {\r\n    if (process.env.NODE_ENV !== 'production') {\r\n      /* eslint-disable no-irregular-whitespace */\r\n      let elements = [];\r\n\r\n      // 1. Debug all sliders by default.\r\n      if (arguments.length === 0) {\r\n        idOrElements = '[data-snap-slider]';\r\n      }\r\n\r\n      // 2. Debug a slider by its ID.\r\n      if (typeof idOrElements === 'string'\r\n        && hasOwnProperty(window._SnapSliders, idOrElements)) {\r\n        idOrElements = `[data-snap-slider=\"${idOrElements}\"]`;\r\n      }\r\n\r\n      // 3. Debug slider elements.\r\n      elements = getElements(idOrElements);\r\n\r\n      if (!elements.length) {\r\n        SnapSlider.notFound(idOrElements);\r\n        return;\r\n      }\r\n\r\n      // Debug all the things!\r\n      elements.forEach((el, i) => {\r\n        // What are we debugging? Is this a button, nav, or container?\r\n        const button = el.closest('[data-snap-slider-goto]');\r\n        const nav = el.closest('[data-snap-slider-nav]');\r\n        const container = el.closest('[data-snap-slider]');\r\n\r\n        // If we're debugging more than one element at a time,\r\n        // add the index # to each section heading.\r\n        const num = elements.length > 1 ? `#${i + 1} ` : '';\r\n\r\n        // 2a. Buttons\r\n        if (button) {\r\n          // Get details for the target slider & slide.\r\n          const target = SnapSlider.getButtonTarget(button);\r\n          const slider = window._SnapSliders[target.sliderID];\r\n\r\n          // Make sure slide index is valid.\r\n          const { index } = target;\r\n          const slideIndex = SnapSlider.isValidIndex(index)\r\n            ? `\"${index}\"`\r\n            : `🚫 \"${index}\" - Yikes! This index is invalid.\\n\\nUse a positive number instead, or one of the following aliases:\\n\r\n  ${['first', 'middle', 'last', 'prev', 'next'].map((a) => `• ${a}`).join('\\n')}`;\r\n\r\n          // \"We couldn't find anything.\"\r\n          const sliderID = target.sliderID\r\n            ? `\"${target.sliderID}\"`\r\n            : `🤷‍♀️ We couldn't find any.\\n\r\n  • Make sure your button is inside a \\`data-snap-slider-nav\\` element, or...\r\n  • Include the slider ID you want to target in your \\`data-snap-slider-goto\\` attribute.\r\n      ◦ For example, \\`data-snap-slider-goto=\"example-slider:${target.index || 'prev'}\"\\`.`;\r\n\r\n          let sliderContainer = `🤷‍♀️ We couldn't find any.\\n\r\n  • Double check that your slider ID is correct (👆).\r\n  • Make sure your slider has the same ID in its \\`data-snap-slider\\` attribute.\r\n      ◦ For example, \\`data-snap-slider=\"example-slider\"\\`.`;\r\n          let slideIndexNumber = `🤷‍♀️ We couldn't find any.\\n\r\n  • Double check that your index is valid (👆).\r\n  • Make sure a slide actually exists at that index (👇).`;\r\n          let slide = `🤷‍♀️ We couldn't find any.\\n\r\n  • Double check that your index is valid (👆).\r\n  • Make sure a slide actually exists at that index.\r\n  • Make sure your slider recognizes the slide element as a slide.`;\r\n\r\n          // We found it!\r\n          if (slider && slider.container) {\r\n            sliderContainer = slider.container;\r\n            slideIndexNumber = slider.getIndexNumber(index);\r\n            slide = slider.getSlide(index);\r\n          }\r\n\r\n          // Log 'em.\r\n          return logger.section({\r\n            heading: `🕹 Button ${num}`,\r\n            description: button,\r\n            groups: [\r\n              {\r\n                heading: '1. What slider is this button targeting?',\r\n                items: [\r\n                  { heading: 'Slider ID', description: sliderID },\r\n                  { heading: 'Slider Element', description: sliderContainer },\r\n                  { heading: 'Slider Object', description: slider || \"🤷‍♀️ We couldn't find any.\" },\r\n                ],\r\n              },\r\n              {\r\n                heading: '2. Which slide will it go to?',\r\n                items: [\r\n                  { heading: 'Slide Index', description: slideIndex },\r\n                  { heading: 'Slide Index (Number)', description: slideIndexNumber },\r\n                  { heading: 'Slide Element', description: slide },\r\n                ],\r\n              },\r\n            ],\r\n            collapsed: true,\r\n          });\r\n        }\r\n\r\n        // 2b. Navigation\r\n        if (nav) {\r\n          // Get details for the target slider\r\n          let sliderID = nav.getAttribute('data-snap-slider-nav');\r\n          const slider = window._SnapSliders[sliderID];\r\n          let buttons = qsa('[data-snap-slider-goto]', nav);\r\n\r\n          // \"We couldn't find anything.\"\r\n          sliderID = sliderID\r\n            ? `\"${sliderID}\"`\r\n            : `🤷‍♀️ We couldn't find any.\\n\r\n  • Include the slider ID you want to target in your \\`data-snap-slider-nav\\` attribute.\r\n      ◦ For example, \\`data-snap-slider-nav=\"example-slider\"\\`.`;\r\n\r\n          let sliderContainer = `🤷‍♀️ We couldn't find any.\\n\r\n  • Make sure the ID in your container's \\`data-snap-slider\\` attribute and the ID in your nav's \\`data-snap-slider-nav\\` attribute both match.`;\r\n\r\n          if (!buttons.length) {\r\n            buttons = `🤷‍♀️ We couldn't find any.\\n\r\n  • Make sure your buttons have a \\`data-snap-slider-goto\\` attribute.`;\r\n          }\r\n\r\n          // We found it!\r\n          if (slider && slider.container) {\r\n            sliderContainer = slider.container;\r\n          }\r\n\r\n          // Log 'em.\r\n          return logger.section({\r\n            heading: `🗺 Navigation ${num}`,\r\n            description: nav,\r\n            groups: [\r\n              {\r\n                heading: '1. What slider is this nav targeting?',\r\n                items: [\r\n                  { heading: 'Slider ID', description: sliderID },\r\n                  { heading: 'Slider Element', description: sliderContainer },\r\n                  { heading: 'Slider Object', description: slider || \"🤷‍♀️ We couldn't find any.\" },\r\n                ],\r\n              },\r\n              {\r\n                heading: '2. What buttons are in this nav?',\r\n                items: [{ heading: 'Buttons', description: buttons }],\r\n              },\r\n            ],\r\n            collapsed: true,\r\n          });\r\n        }\r\n\r\n        // 2c. Containers (aka sliders)\r\n        if (container) {\r\n          // Get details for the slider.\r\n          let sliderID = container.getAttribute('data-snap-slider');\r\n          const slider = window._SnapSliders[sliderID];\r\n          let navs = qsa(`[data-snap-slider-nav=\"${sliderID}\"]`);\r\n          let buttons = slider ? slider.getButtons() : [];\r\n\r\n          // \"We couldn't find anything.\"\r\n          sliderID = sliderID\r\n            ? `\"${sliderID}\"`\r\n            : `🤷‍♀️ We couldn't find any.\\n\r\n  • Include the slider ID you want in your \\`data-snap-slider\\` attribute.\r\n      ◦ For example, \\`data-snap-slider=\"example-slider\"\\`.`;\r\n\r\n          if (!navs.length) {\r\n            navs = `🤷‍♀️ We couldn't find any.\\n\r\n  • Make sure the ID in your container's \\`data-snap-slider\\` attribute and the ID in your nav's \\`data-snap-slider-nav\\` attribute both match.`;\r\n          }\r\n\r\n          if (!buttons.length) {\r\n            buttons = `🤷‍♀️ We couldn't find any.\\n\r\n  • Make sure your button is inside a \\`data-snap-slider-nav\\` element, or...\r\n  • Include the slider ID you want to target in your \\`data-snap-slider-goto\\` attribute.\r\n      ◦ For example, \\`data-snap-slider-goto=\"example-slider:prev\"\\`.`;\r\n          }\r\n\r\n          // Log 'em.\r\n          return logger.section({\r\n            heading: `🥨 Slider ${num}`,\r\n            description: container,\r\n            groups: [\r\n              {\r\n                heading: '1. What slider is this?',\r\n                items: [\r\n                  { heading: 'Slider ID', description: sliderID },\r\n                  { heading: 'Slider Object', description: slider || \"🤷‍♀️ We couldn't find any.\" },\r\n                ],\r\n              },\r\n              {\r\n                heading: '2. What navs target this slider?',\r\n                items: [{ heading: 'Navs', description: navs }],\r\n              },\r\n              {\r\n                heading: '3. What buttons target this slider?',\r\n                items: [{ heading: 'Buttons', description: buttons }],\r\n              },\r\n            ],\r\n            collapsed: true,\r\n          });\r\n        }\r\n\r\n        return SnapSlider.notFound(idOrElements);\r\n      });\r\n      /* eslint-enable no-irregular-whitespace */\r\n    }\r\n  }\r\n}\r\n\r\n// Keep track of all the sliders on the page to reference.\r\nwindow._SnapSliders = [];\r\n\r\n// Make the constructor globally accessible.\r\nwindow.SnapSlider = SnapSlider;\r\n\r\n// If jQuery exists, integrate.\r\nif (typeof $ !== 'undefined') {\r\n  // eslint-disable-next-line no-undef, func-names\r\n  $.fn.snapSlider = function (options) {\r\n    return new SnapSlider(this, options);\r\n  };\r\n}\r\n\r\n// Auto-init once the DOM is ready.\r\nonReady(() => {\r\n  // Init polyfills.\r\n  elementClosest(window);\r\n  smoothscroll.polyfill();\r\n\r\n  // Initialize all sliders with data attributes.\r\n  qsa('[data-snap-slider]').forEach((el) => new SnapSlider(el));\r\n\r\n  // Setup click events for *all* nav elements.\r\n  on('body', 'click', '[data-snap-slider-goto]', SnapSlider.handleGoto);\r\n});\r\n\r\nexport default SnapSlider;\r\n","import hasOwnProperty from './hasOwnProperty';\r\n\r\n/**\r\n * Get a computed style for some element.\r\n * @param  {Element}  el\r\n * @param  {String}   prop\r\n * @return {String}\r\n */\r\nexport default function getStyle(el, prop) {\r\n  const style = window.getComputedStyle(el);\r\n\r\n  // Ignore mmissing elements or props\r\n  if (!style || !hasOwnProperty(style, prop)) {\r\n    return '';\r\n  }\r\n\r\n  return style[prop];\r\n}\r\n","/**\r\n * Get an attribute for the closest element with it.\r\n * @param  {Element}  el\r\n * @param  {String}  attr\r\n * @return {String}\r\n */\r\nexport default function getClosestAttribute(el, attr) {\r\n  // Ignore missing elements\r\n  if (!el) {\r\n    return '';\r\n  }\r\n\r\n  // Find the closest element with a mattring attribute\r\n  el = el.closest(`[${attr}]`);\r\n\r\n  // If we found a match, return the attribute, otherwise\r\n  // return an empty string.\r\n  return el ? el.getAttribute(attr) : '';\r\n}\r\n","/**\r\n * Wait to run a function on DOMContentLoaded, or fire immediately if the\r\n * event has already fired.\r\n * @param  {Function} fn\r\n * @return {void}\r\n */\r\nexport default function onReady(fn) {\r\n  if (document.readyState !== 'loading') {\r\n    fn();\r\n  } else {\r\n    document.addEventListener('DOMContentLoaded', fn);\r\n  }\r\n}\r\n","/* eslint-disable consistent-return, func-names, no-var, prefer-arrow-callback, vars-on-top */\r\n\r\n/**\r\n * Plain JavaScript event delegation. Add a handler for whenever an element's\r\n * children trigger a specified event.\r\n * @see https://bdadam.com/blog/plain-javascript-event-delegation.html\r\n * @param  {String}    parentSelector\r\n * @param  {String}    eventName\r\n * @param  {String}    childSelector\r\n * @param  {Function}  fn\r\n * @return {Boolean}\r\n */\r\nexport default function on(parentSelector, eventName, childSelector, fn) {\r\n  var parent = document.querySelector(parentSelector);\r\n\r\n  if (!parent) {\r\n    return false;\r\n  }\r\n\r\n  parent.addEventListener(eventName, function (event) {\r\n    var possibleTargets = parent.querySelectorAll(childSelector);\r\n    var target = event.target;\r\n\r\n    for (var i = 0, l = possibleTargets.length; i < l; i += 1) {\r\n      var el = target;\r\n      var p = possibleTargets[i];\r\n\r\n      while (el && el !== parent) {\r\n        if (el === p) {\r\n          return fn.call(p, event);\r\n        }\r\n\r\n        el = el.parentNode;\r\n      }\r\n    }\r\n  });\r\n\r\n  return true;\r\n}\r\n\r\n// Example:\r\n// on('body', 'click', '.product', function(e) {\r\n//   console.log(e.target);\r\n// });\r\n","/**\r\n * Return a string of dashes.\r\n *\r\n * @param  {Number}  num\r\n * @param  {String}  char\r\n * @return {String}\r\n */\r\nexport default function dashes(num, char = '-') {\r\n  let str = '';\r\n\r\n  for (let i = 0; i < num; i += 1) {\r\n    str += char;\r\n  }\r\n\r\n  return str;\r\n}\r\n","/* eslint-disable indent */\r\n\r\n// Helpers\r\nimport dashes from '../helpers/dashes';\r\n\r\n/**\r\n * Get the substitution string for to format this value in a console.log.\r\n *\r\n * - %o = Object\r\n * - %d = Number (aka \"Digit\")\r\n * - %s = String\r\n * - %c = CSS\r\n *\r\n * @see https://developer.mozilla.org/en-US/docs/Web/API/console#Using_string_substitutions\r\n * @param  {mixed}   value\r\n * @return {String}\r\n */\r\nexport function getSubstitution(value) {\r\n  // Object\r\n  if (typeof value === 'object') {\r\n    return '%o';\r\n  }\r\n\r\n  // Number\r\n  if (typeof value === 'number') {\r\n    return '%d';\r\n  }\r\n\r\n  // When in doubt, assume everything else is a String.\r\n  return '%s';\r\n}\r\n\r\n/**\r\n * Log a full debug section.\r\n *\r\n * @param  {Object}  params\r\n * @param  {Object}  params.heading\r\n * @return {void}\r\n */\r\nexport function section(params) {\r\n  const {\r\n    heading,\r\n    description,\r\n    groups,\r\n    collapsed,\r\n  } = params;\r\n\r\n  // Allow groups to be collapsed.\r\n  const method = collapsed ? 'groupCollapsed' : 'group';\r\n\r\n  // HEADING\r\n  console.log(`%c\r\n┏━━${dashes(heading.length, '━')}━━┓\r\n┃  ${heading}  ┃\r\n┗━━${dashes(heading.length, '━')}━━┛`, 'font-size: 1.25em;', '\\n\\n',\r\n  description,\r\n  '\\n\\n');\r\n\r\n  // GROUPS\r\n  groups.forEach((group) => {\r\n    // Heading\r\n    console[method](`%c${group.heading}`, 'font-weight: bold;');\r\n\r\n    // Build up a single console.log for all the items in the group.\r\n    const args = [];\r\n    let content = '';\r\n\r\n    group.items.forEach((item) => {\r\n      // eslint-disable-next-line no-shadow\r\n      const { heading, description } = item;\r\n\r\n      // Heading\r\n      content += `\\n%c${getSubstitution(heading)}\\n`;\r\n      args.push('text-decoration: underline;', heading);\r\n\r\n      // Description\r\n      content += `\\n%c${getSubstitution(description)}\\n`;\r\n      args.push('text-decoration: none;', description);\r\n    });\r\n\r\n    // Log the items!\r\n    console.log(content, ...args);\r\n\r\n    // And end the group.\r\n    console.groupEnd();\r\n  });\r\n\r\n  // Add an empty line after the section.\r\n  console.log('\\n');\r\n}\r\n"],"sourceRoot":""}