{"version":3,"sources":["webpack:///./node_modules/vue-ssr-carousel/index.js"],"names":["module","exports","modules","installedModules","__webpack_require__","moduleId","i","l","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","__webpack_exports__","render","_vm","this","_c","_self","$slots","default","length","staticClass","attrs","scopeId","on","keyup","$event","type","indexOf","_k","keyCode","onTab","apply","arguments","tag","domProps","innerHTML","_s","instanceStyles","ref","style","peekStyles","_g","class","pressing","disabled","overflowVisible","noDrag","maskListeners","_b","scopedSlots","_u","fn","_t","proxy","hasPeekClones","dragging","trackTranslateX","slideOrder","activeSlides","leftPeekingSlideIndex","rightPeekingSlideIndex","showArrows","back","next","props","index","pages","shouldLoop","pageLabel","_e","showDots","goto","gotoDot","boundedIndex","_v","currentSlideMessage","staticRenderFns","_withStripped","ssr_carousel_arrowsvue_type_template_id_559c4b35_lang_pug_render","backDisabled","click","$emit","nextDisabled","ssr_carousel_arrowsvue_type_template_id_559c4b35_lang_pug_staticRenderFns","ssr_carousel_arrowsvue_type_script_lang_coffee_","Number","Boolean","String","computed","src_ssr_carousel_arrowsvue_type_script_lang_coffee_","normalizeComponent","scriptExports","functionalTemplate","injectStyles","moduleIdentifier","shadowMode","hook","options","_compiled","functional","_scopeId","context","$vnode","ssrContext","parent","__VUE_SSR_CONTEXT__","_registeredComponents","add","_ssrRegister","$root","$options","shadowRoot","_injectStyles","originalRender","h","existing","beforeCreate","concat","component","ssr_carousel_arrows","ssr_carousel_dotsvue_type_template_id_98a1e6f8_lang_pug_render","_l","isDisabled","ssr_carousel_dotsvue_type_template_id_98a1e6f8_lang_pug_staticRenderFns","interactiveSelector","ssr_carousel_dotsvue_type_script_lang_coffee_","methods","src_ssr_carousel_dotsvue_type_script_lang_coffee_","ssr_carousel_dots_component","ssr_carousel_dots","ssr_carousel_track_render","ssr_carousel_track_staticRenderFns","notPassive","passive","ssr_carousel_trackvue_type_script_lang_coffee_","Array","data","renderAsList","mounted","denyTabindex","inactiveSlides","clonedSlides","trackHTMLElement","uniqueSlidesCount","allSlidesCount","getSlideComponents","hasClonedSlides","results","j","push","filter","ref1","styles","transform","watch","allowTabindex","makeSlides","map","vnode","cssClass","isPeekingClone","peekingIndex","slideCount","makeReactiveVnode","order","display","clones","text","newVnode","console","error","indices","setTabindex","slideIndices","tabindexValue","el","len","getSlideElementsByIndices","matches","tabIndex","querySelectorAll","forEach","from","$el","children","src_ssr_carousel_trackvue_type_script_lang_coffee_","ssr_carousel_track_component","ssr_carousel_track","accessibility_coffee","paginationLabel","usingKeyboard","paginateBySlide","autoplay_coffee","autoplayDelay","pauseOnFocus","autoplayStart","beforeDestroy","autoplayStop","autoplayPaused","windowHidden","isFocused","paused","autoPlayInterval","setInterval","autoplayNext","clearInterval","dimensions_coffee","viewportWidth","carouselWidth","gutterWidth","onResize","window","addEventListener","removeEventListener","pageWidth","combinedPeek","slideWidth","currentSlidesPerPage","trackWidth","isVariableWidth","measuredTrackWidth","slidesCount","lastPageWidth","slidesOnLastPage","slidesPerPage","width","endX","peekLeftPx","peekRightPx","isOutOfBounds","currentX","firstSlide","nodeType","Node","ELEMENT_NODE","$refs","track","firstElementChild","parseInt","getComputedStyle","marginRight","getBoundingClientRect","innerWidth","capturePeekingMeasurements","captureTrackWidth","makeBreakpointSlideWidthStyle","breakpoint","scopeSelector","makeSlideWidthCalc","gutter","peekLeft","peekRight","isDisabledAtBreakpoint","getResponsiveValue","matchPeekWhenDisabled","autoUnit","dragging_coffee","boundaryDampening","dragAdvanceRatio","verticalDragTreshold","isTouchDrag","startPointer","lastPointer","dragVelocity","dragDirectionRatio","onPointerMove","onPointerUp","onWinMove","dragIndex","Math","abs","round","fractionalIndex","ceil","floor","distanceIntoPage","isLastPage","pageIndex","pageProgressPercent","remainingSlides","setIndex","widthDivisor","x","isVerticalDrag","preventVerticalScroll","moveEvent","upEvent","preventContentDrag","stopTweening","gotoStart","gotoEnd","tweenToStop","shouldPrevent","stopEvent","e","preventDefault","onPointerDown","pointerEvent","TouchEvent","getPointerCoords","pointer","targetX","y","applyBoundaryDampening","ref2","ref3","touches","pageX","pageY","pow","applyXBoundaries","max","min","contentDragPrevented","feathering_coffee","feather","makeBreakpointFeatheringStyle","cssValue","focus_coffee","hovered","windowVisible","onEnter","onLeave","updateVisibility","document","hidden","watchesHover","gutters_coffee","makeBreakpointSlideGutterStyle","lastChildGutter","looping_coffee","loop","center","currentSlideIndex","trackLoopOffset","offsetSlideCount","hasLeftPeekClone","leftMostSlideIndex","findIndex","rightMostSlideIndex","immediate","handler","setSlideOrder","count","split","keys","slice","makeBreakpointSlideOrderStyle","rules","join","pagination_coffee","slides","currentIncompletePageOffset","makeIncompletePageOffset","start","reduce","offset","applyIndexBoundaries","dotIndex","tweenToIndex","tweenToX","getXForIndex","startTweening","jumpToIndex","incompleteWidth","peeking_coffee","peekGutter","peek","hasRightPeekClone","hasPeekPrerequisites","currentResponsiveBreakpoint","left","right","responsive","peekValues","$nextTick","makeBreakpointTrackTransformStyle","rule","responsive_coffee","hashString","JSON","stringify","$props","responsiveRules","mediaQuery","makeMediaQuery","active","isBreakpointActive","match","reverse","find","makeBreakpointStyles","maxWidth","minWidth","makeBreakpointDisablingRules","val","ruleMatch","str","hash","charCodeAt","toString","tweening_coffee","tweenDampening","tweenInertia","tweening","cancelAnimationFrame","rafId","tweenToTarget","requestAnimationFrame","variable_width_coffee","scrollWidth","ssr_carouselvue_type_script_lang_coffee_","mixins","components","SsrCarouselArrows","SsrCarouselDots","SsrCarouselTrack","mousedown","touchstart","mouseenter","mouseleave","src_ssr_carouselvue_type_script_lang_coffee_","ssr_carousel_component"],"mappings":"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","file":"js/chunk-435b6c5f.833acdb7.js","sourcesContent":["module.exports =\n/******/ (function(modules) { // webpackBootstrap\n/******/ \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 = 0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n// ESM COMPAT FLAG\n__webpack_require__.r(__webpack_exports__);\n\n// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??ref--5!./node_modules/pug-plain-loader!./node_modules/vue-loader/lib??vue-loader-options!./src/ssr-carousel.vue?vue&type=template&id=40da5be2&lang=pug&\nvar render = function render() {\n  var _vm = this,\n    _c = _vm._self._c\n  return _vm.$slots.default && _vm.$slots.default.length\n    ? _c(\n        \"div\",\n        {\n          key: _vm.$slots.default.length,\n          staticClass: \"ssr-carousel\",\n          attrs: { \"data-ssrc-id\": _vm.scopeId },\n          on: {\n            keyup: function ($event) {\n              if (\n                !$event.type.indexOf(\"key\") &&\n                _vm._k($event.keyCode, \"tab\", 9, $event.key, \"Tab\")\n              )\n                return null\n              return _vm.onTab.apply(null, arguments)\n            },\n          },\n        },\n        [\n          _c(\"style\", {\n            tag: \"component\",\n            domProps: { innerHTML: _vm._s(_vm.instanceStyles) },\n          }),\n          _c(\n            \"div\",\n            { staticClass: \"ssr-carousel-slides\" },\n            [\n              _c(\"div\", {\n                ref: \"peekValues\",\n                staticClass: \"ssr-peek-values\",\n                style: _vm.peekStyles,\n              }),\n              _c(\n                \"div\",\n                _vm._g(\n                  {\n                    ref: \"mask\",\n                    staticClass: \"ssr-carousel-mask\",\n                    class: {\n                      pressing: _vm.pressing,\n                      disabled: _vm.disabled,\n                      \"no-mask\": _vm.overflowVisible,\n                      \"not-draggable\": _vm.noDrag,\n                    },\n                  },\n                  _vm.maskListeners\n                ),\n                [\n                  _c(\n                    \"ssr-carousel-track\",\n                    _vm._b(\n                      {\n                        ref: \"track\",\n                        scopedSlots: _vm._u(\n                          [\n                            {\n                              key: \"default\",\n                              fn: function () {\n                                return [_vm._t(\"default\")]\n                              },\n                              proxy: true,\n                            },\n                            _vm.hasPeekClones\n                              ? {\n                                  key: \"clones\",\n                                  fn: function () {\n                                    return [_vm._t(\"default\")]\n                                  },\n                                  proxy: true,\n                                }\n                              : null,\n                          ],\n                          null,\n                          true\n                        ),\n                      },\n                      \"ssr-carousel-track\",\n                      {\n                        dragging: _vm.dragging,\n                        trackTranslateX: _vm.trackTranslateX,\n                        slideOrder: _vm.slideOrder,\n                        activeSlides: _vm.activeSlides,\n                        leftPeekingSlideIndex: _vm.leftPeekingSlideIndex,\n                        rightPeekingSlideIndex: _vm.rightPeekingSlideIndex,\n                      },\n                      false\n                    )\n                  ),\n                ],\n                1\n              ),\n              _vm.showArrows\n                ? _c(\n                    \"ssr-carousel-arrows\",\n                    _vm._b(\n                      {\n                        on: { back: _vm.back, next: _vm.next },\n                        scopedSlots: _vm._u(\n                          [\n                            {\n                              key: \"back\",\n                              fn: function (props) {\n                                return [_vm._t(\"back-arrow\", null, null, props)]\n                              },\n                            },\n                            {\n                              key: \"next\",\n                              fn: function (props) {\n                                return [_vm._t(\"next-arrow\", null, null, props)]\n                              },\n                            },\n                          ],\n                          null,\n                          true\n                        ),\n                      },\n                      \"ssr-carousel-arrows\",\n                      {\n                        index: _vm.index,\n                        pages: _vm.pages,\n                        shouldLoop: _vm.shouldLoop,\n                        pageLabel: _vm.pageLabel,\n                      },\n                      false\n                    )\n                  )\n                : _vm._e(),\n            ],\n            1\n          ),\n          _vm.showDots\n            ? _c(\n                \"ssr-carousel-dots\",\n                _vm._b(\n                  {\n                    on: { goto: _vm.gotoDot },\n                    scopedSlots: _vm._u(\n                      [\n                        {\n                          key: \"dot\",\n                          fn: function (props) {\n                            return [_vm._t(\"dot\", null, null, props)]\n                          },\n                        },\n                      ],\n                      null,\n                      true\n                    ),\n                  },\n                  \"ssr-carousel-dots\",\n                  {\n                    boundedIndex: _vm.boundedIndex,\n                    pages: _vm.pages,\n                    pageLabel: _vm.pageLabel,\n                  },\n                  false\n                )\n              )\n            : _vm._e(),\n          _c(\n            \"div\",\n            {\n              staticClass: \"ssr-carousel-visually-hidden\",\n              attrs: { \"aria-live\": \"polite\", \"aria-atomic\": \"true\" },\n            },\n            [_vm._v(_vm._s(_vm.currentSlideMessage))]\n          ),\n        ],\n        1\n      )\n    : _vm._e()\n}\nvar staticRenderFns = []\nrender._withStripped = true\n\n\n// CONCATENATED MODULE: ./src/ssr-carousel.vue?vue&type=template&id=40da5be2&lang=pug&\n\n// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??ref--5!./node_modules/pug-plain-loader!./node_modules/vue-loader/lib??vue-loader-options!./src/ssr-carousel-arrows.vue?vue&type=template&id=559c4b35&lang=pug&\nvar ssr_carousel_arrowsvue_type_template_id_559c4b35_lang_pug_render = function render() {\n  var _vm = this,\n    _c = _vm._self._c\n  return _c(\"div\", { staticClass: \"ssr-carousel-arrows\" }, [\n    _c(\n      \"button\",\n      {\n        staticClass: \"ssr-carousel-back-button\",\n        attrs: {\n          \"aria-label\": `Previous ${_vm.pageLabel}`,\n          \"aria-disabled\": _vm.backDisabled,\n        },\n        on: {\n          click: function ($event) {\n            return _vm.$emit(\"back\")\n          },\n        },\n      },\n      [\n        _vm._t(\n          \"back\",\n          function () {\n            return [_c(\"span\", { staticClass: \"ssr-carousel-back-icon\" })]\n          },\n          { disabled: _vm.backDisabled }\n        ),\n      ],\n      2\n    ),\n    _c(\n      \"button\",\n      {\n        staticClass: \"ssr-carousel-next-button\",\n        attrs: {\n          \"aria-label\": `Next ${_vm.pageLabel}`,\n          \"aria-disabled\": _vm.nextDisabled,\n        },\n        on: {\n          click: function ($event) {\n            return _vm.$emit(\"next\")\n          },\n        },\n      },\n      [\n        _vm._t(\n          \"next\",\n          function () {\n            return [_c(\"span\", { staticClass: \"ssr-carousel-next-icon\" })]\n          },\n          { disabled: _vm.nextDisabled }\n        ),\n      ],\n      2\n    ),\n  ])\n}\nvar ssr_carousel_arrowsvue_type_template_id_559c4b35_lang_pug_staticRenderFns = []\nssr_carousel_arrowsvue_type_template_id_559c4b35_lang_pug_render._withStripped = true\n\n\n// CONCATENATED MODULE: ./src/ssr-carousel-arrows.vue?vue&type=template&id=559c4b35&lang=pug&\n\n// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/coffee-loader!./node_modules/vue-loader/lib??vue-loader-options!./src/ssr-carousel-arrows.vue?vue&type=script&lang=coffee&\n/* harmony default export */ var ssr_carousel_arrowsvue_type_script_lang_coffee_ = ({\n  props: {\n    index: Number,\n    pages: Number,\n    shouldLoop: Boolean,\n    pageLabel: String\n  },\n  computed: {\n    // Determine if button should be disabled because we're at the limits\n    backDisabled: function () {\n      if (!this.shouldLoop) {\n        return this.index === 0;\n      }\n    },\n    nextDisabled: function () {\n      if (!this.shouldLoop) {\n        return this.index === this.pages - 1;\n      }\n    }\n  }\n});\n// CONCATENATED MODULE: ./src/ssr-carousel-arrows.vue?vue&type=script&lang=coffee&\n /* harmony default export */ var src_ssr_carousel_arrowsvue_type_script_lang_coffee_ = (ssr_carousel_arrowsvue_type_script_lang_coffee_); \n// CONCATENATED MODULE: ./node_modules/mini-css-extract-plugin/dist/loader.js!./node_modules/css-loader/dist/cjs.js!./node_modules/vue-loader/lib/loaders/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js!./node_modules/stylus-loader!./node_modules/vue-loader/lib??vue-loader-options!./src/ssr-carousel-arrows.vue?vue&type=style&index=0&id=559c4b35&prod&lang=stylus&\n// extracted by mini-css-extract-plugin\n\n// CONCATENATED MODULE: ./src/ssr-carousel-arrows.vue?vue&type=style&index=0&id=559c4b35&prod&lang=stylus&\n\n// CONCATENATED MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js\n/* globals __VUE_SSR_CONTEXT__ */\n\n// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).\n// This module is a runtime utility for cleaner component module output and will\n// be included in the final webpack user bundle.\n\nfunction normalizeComponent(\n  scriptExports,\n  render,\n  staticRenderFns,\n  functionalTemplate,\n  injectStyles,\n  scopeId,\n  moduleIdentifier /* server only */,\n  shadowMode /* vue-cli only */\n) {\n  // Vue.extend constructor export interop\n  var options =\n    typeof scriptExports === 'function' ? scriptExports.options : scriptExports\n\n  // render functions\n  if (render) {\n    options.render = render\n    options.staticRenderFns = staticRenderFns\n    options._compiled = true\n  }\n\n  // functional template\n  if (functionalTemplate) {\n    options.functional = true\n  }\n\n  // scopedId\n  if (scopeId) {\n    options._scopeId = 'data-v-' + scopeId\n  }\n\n  var hook\n  if (moduleIdentifier) {\n    // server build\n    hook = function (context) {\n      // 2.3 injection\n      context =\n        context || // cached call\n        (this.$vnode && this.$vnode.ssrContext) || // stateful\n        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional\n      // 2.2 with runInNewContext: true\n      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\n        context = __VUE_SSR_CONTEXT__\n      }\n      // inject component styles\n      if (injectStyles) {\n        injectStyles.call(this, context)\n      }\n      // register component module identifier for async chunk inferrence\n      if (context && context._registeredComponents) {\n        context._registeredComponents.add(moduleIdentifier)\n      }\n    }\n    // used by ssr in case component is cached and beforeCreate\n    // never gets called\n    options._ssrRegister = hook\n  } else if (injectStyles) {\n    hook = shadowMode\n      ? function () {\n          injectStyles.call(\n            this,\n            (options.functional ? this.parent : this).$root.$options.shadowRoot\n          )\n        }\n      : injectStyles\n  }\n\n  if (hook) {\n    if (options.functional) {\n      // for template-only hot-reload because in that case the render fn doesn't\n      // go through the normalizer\n      options._injectStyles = hook\n      // register for functional component in vue file\n      var originalRender = options.render\n      options.render = function renderWithStyleInjection(h, context) {\n        hook.call(context)\n        return originalRender(h, context)\n      }\n    } else {\n      // inject component registration as beforeCreate hook\n      var existing = options.beforeCreate\n      options.beforeCreate = existing ? [].concat(existing, hook) : [hook]\n    }\n  }\n\n  return {\n    exports: scriptExports,\n    options: options\n  }\n}\n\n// CONCATENATED MODULE: ./src/ssr-carousel-arrows.vue\n\n\n\n\n\n\n/* normalize component */\n\nvar component = normalizeComponent(\n  src_ssr_carousel_arrowsvue_type_script_lang_coffee_,\n  ssr_carousel_arrowsvue_type_template_id_559c4b35_lang_pug_render,\n  ssr_carousel_arrowsvue_type_template_id_559c4b35_lang_pug_staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\n/* harmony default export */ var ssr_carousel_arrows = (component.exports);\n// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??ref--5!./node_modules/pug-plain-loader!./node_modules/vue-loader/lib??vue-loader-options!./src/ssr-carousel-dots.vue?vue&type=template&id=98a1e6f8&lang=pug&\nvar ssr_carousel_dotsvue_type_template_id_98a1e6f8_lang_pug_render = function render() {\n  var _vm = this,\n    _c = _vm._self._c\n  return _c(\n    \"div\",\n    { staticClass: \"ssr-carousel-dots\" },\n    _vm._l(_vm.pages, function (i) {\n      return _c(\n        \"button\",\n        {\n          key: i,\n          staticClass: \"ssr-carousel-dot-button\",\n          attrs: {\n            \"aria-label\": `Go to ${_vm.pageLabel} ${i}`,\n            \"aria-disabled\": _vm.isDisabled(i),\n          },\n          on: {\n            click: function ($event) {\n              return _vm.$emit(\"goto\", i - 1)\n            },\n          },\n        },\n        [\n          _vm._t(\n            \"dot\",\n            function () {\n              return [_c(\"span\", { staticClass: \"ssr-carousel-dot-icon\" })]\n            },\n            { index: i, disabled: _vm.isDisabled(i) }\n          ),\n        ],\n        2\n      )\n    }),\n    0\n  )\n}\nvar ssr_carousel_dotsvue_type_template_id_98a1e6f8_lang_pug_staticRenderFns = []\nssr_carousel_dotsvue_type_template_id_98a1e6f8_lang_pug_render._withStripped = true\n\n\n// CONCATENATED MODULE: ./src/ssr-carousel-dots.vue?vue&type=template&id=98a1e6f8&lang=pug&\n\n// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/coffee-loader!./node_modules/vue-loader/lib??vue-loader-options!./src/ssr-carousel-dots.vue?vue&type=script&lang=coffee&\n/* harmony default export */ var ssr_carousel_dotsvue_type_script_lang_coffee_ = ({\n  props: {\n    boundedIndex: Number,\n    pages: Number,\n    pageLabel: String\n  },\n  methods: {\n    // Check if dot index shuold be disabled\n    isDisabled: function (index) {\n      return this.boundedIndex === index - 1;\n    }\n  }\n});\n// CONCATENATED MODULE: ./src/ssr-carousel-dots.vue?vue&type=script&lang=coffee&\n /* harmony default export */ var src_ssr_carousel_dotsvue_type_script_lang_coffee_ = (ssr_carousel_dotsvue_type_script_lang_coffee_); \n// CONCATENATED MODULE: ./node_modules/mini-css-extract-plugin/dist/loader.js!./node_modules/css-loader/dist/cjs.js!./node_modules/vue-loader/lib/loaders/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js!./node_modules/stylus-loader!./node_modules/vue-loader/lib??vue-loader-options!./src/ssr-carousel-dots.vue?vue&type=style&index=0&id=98a1e6f8&prod&lang=stylus&\n// extracted by mini-css-extract-plugin\n\n// CONCATENATED MODULE: ./src/ssr-carousel-dots.vue?vue&type=style&index=0&id=98a1e6f8&prod&lang=stylus&\n\n// CONCATENATED MODULE: ./src/ssr-carousel-dots.vue\n\n\n\n\n\n\n/* normalize component */\n\nvar ssr_carousel_dots_component = normalizeComponent(\n  src_ssr_carousel_dotsvue_type_script_lang_coffee_,\n  ssr_carousel_dotsvue_type_template_id_98a1e6f8_lang_pug_render,\n  ssr_carousel_dotsvue_type_template_id_98a1e6f8_lang_pug_staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\n/* harmony default export */ var ssr_carousel_dots = (ssr_carousel_dots_component.exports);\n// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/coffee-loader!./node_modules/vue-loader/lib??vue-loader-options!./src/ssr-carousel-track.vue?vue&type=script&lang=coffee&\nvar interactiveSelector,\n  indexOf = [].indexOf;\ninteractiveSelector = 'a, button, input, textarea, select';\n/* harmony default export */ var ssr_carousel_trackvue_type_script_lang_coffee_ = ({\n  props: {\n    dragging: Boolean,\n    trackTranslateX: Number,\n    slideOrder: Array,\n    activeSlides: Array,\n    leftPeekingSlideIndex: Number,\n    rightPeekingSlideIndex: Number\n  },\n  // Should the track element be an ul\n  data: function () {\n    return {\n      renderAsList: false\n    };\n  },\n  // Set tabindex of inactive slides on mount\n  mounted: function () {\n    this.denyTabindex(this.inactiveSlides);\n    return this.denyTabindex(this.clonedSlides);\n  },\n  computed: {\n    // The HTML element of the track\n    trackHTMLElement: function () {\n      if (this.renderAsList) {\n        return 'ul';\n      } else {\n        return 'div';\n      }\n    },\n    // Get the count of non-cloned slides\n    uniqueSlidesCount: function () {\n      return this.slideOrder.length;\n    },\n    // Get the total slides count, including clones\n    allSlidesCount: function () {\n      return this.getSlideComponents().length;\n    },\n    // Check if there are cloned slides\n    hasClonedSlides: function () {\n      return this.allSlidesCount > this.uniqueSlidesCount;\n    },\n    // Make an array of inactive slide indices\n    inactiveSlides: function () {\n      var ref;\n      return function () {\n        var results = [];\n        for (var j = 0, ref = this.uniqueSlidesCount; 0 <= ref ? j < ref : j > ref; 0 <= ref ? j++ : j--) {\n          results.push(j);\n        }\n        return results;\n      }.apply(this).filter(index => {\n        return indexOf.call(this.activeSlides, index) < 0;\n      });\n    },\n    // An array of the cloned slides indices\n    clonedSlides: function () {\n      var ref, ref1;\n      return function () {\n        var results = [];\n        for (var j = ref = this.uniqueSlidesCount, ref1 = this.allSlidesCount; ref <= ref1 ? j < ref1 : j > ref1; ref <= ref1 ? j++ : j--) {\n          results.push(j);\n        }\n        return results;\n      }.apply(this);\n    },\n    // Styles that are used to position the track\n    styles: function () {\n      if (this.trackTranslateX) {\n        return {\n          transform: `translateX(${this.trackTranslateX}px)`\n        };\n      }\n    }\n  },\n  // Update the tabindex of interactive elements when slides change\n  watch: {\n    activeSlides: function () {\n      this.allowTabindex(this.activeSlides);\n      return this.denyTabindex(this.inactiveSlides);\n    }\n  },\n  methods: {\n    // Make the slides to render into the track\n    makeSlides: function () {\n      return this.getSlideComponents().map((vnode, index) => {\n        var cssClass, isPeekingClone, peekingIndex, slideCount;\n        vnode = this.makeReactiveVnode(vnode);\n        if (index === 0 && vnode.tag === 'li') {\n          // Check if we are rendering a list of elements\n          this.renderAsList = true;\n        }\n\n        // This is a peeking clone if it's index is greater than the slide count\n        slideCount = this.uniqueSlidesCount;\n        isPeekingClone = index >= slideCount;\n        peekingIndex = index - slideCount;\n        // Add the slide class using staticClass since it isn't reactive to data\n        cssClass = 'ssr-carousel-slide';\n        if (vnode.data.staticClass) {\n          vnode.data.staticClass += ` ${cssClass}`;\n        } else {\n          vnode.data.staticClass = cssClass;\n        }\n        // Order the slide, like for looping\n        if (!isPeekingClone) {\n          vnode.data.style.order = this.slideOrder[index] || 0;\n        } else {\n          // Or put at the beginning / end if peeking\n          vnode.data.style.order = function () {\n            switch (false) {\n              case peekingIndex !== this.leftPeekingSlideIndex:\n                return '-1';\n              case peekingIndex !== this.rightPeekingSlideIndex:\n                return this.slideOrder.length;\n            }\n          }.call(this);\n        }\n        // Hide cloned slides that aren't involved in peeking\n        if (isPeekingClone && peekingIndex !== this.leftPeekingSlideIndex && peekingIndex !== this.rightPeekingSlideIndex) {\n          vnode.data.style.display = 'none';\n        }\n        // Make peeking clones and slides not in viewport as aria-hidden\n        if (isPeekingClone || indexOf.call(this.activeSlides, index) < 0) {\n          vnode.data.attrs['aria-hidden'] = 'true';\n        }\n        // Prevent duplicate keys on clones\n        if (isPeekingClone && vnode.key != null) {\n          vnode.key += '-clone-' + index;\n        }\n        // Return modified vnode\n        return vnode;\n      });\n    },\n    // Get the list of non-text slides, including peeking clones. This doesn't\n    // work as a computed function\n    getSlideComponents: function () {\n      return [...(this.$slots.default || []), ...(this.$slots.clones || [])].filter(function (vnode) {\n        return !vnode.text;\n      });\n    },\n    // Makes a clone of the vnode properties we'll be updating so the changes\n    // get rendered. Based on:\n    // https://github.com/vuejs/vue/issues/6052#issuecomment-313705168\n    makeReactiveVnode: function (vnode) {\n      var newVnode;\n      if (!vnode.data) {\n        // Expect a data object.  When it doesn't exist, it's a sign this this\n        // vnode can't be manipulated vue-ssr-carousel.\n        console.error(\"vnode has no data\", vnode);\n      }\n      // Make the new vnode and data\n      newVnode = {\n        ...vnode\n      };\n      newVnode.data = {\n        ...vnode.data\n      };\n      // Clone style property. String styles will be on staticStyle so we can\n      // ignore them.\n      newVnode.data.style = {\n        ...vnode.data.style\n      };\n      // Clone attrs property\n      newVnode.data.attrs = {\n        ...vnode.data.attrs\n      };\n      // Return the clone\n      return newVnode;\n    },\n    // Prevent tabbing to interactive elements in slides with the passed in\n    // index values\n    denyTabindex: function (indices) {\n      return this.setTabindex(indices, -1);\n    },\n    // Allow tabindex on interactive elements in slides with the passed in\n    // index values\n    allowTabindex: function (indices) {\n      return this.setTabindex(indices, 0);\n    },\n    // Set tabindex value on interactive elements in slides\n    setTabindex: function (slideIndices, tabindexValue) {\n      var el, j, len, ref, results;\n      ref = this.getSlideElementsByIndices(slideIndices);\n      results = [];\n      for (j = 0, len = ref.length; j < len; j++) {\n        el = ref[j];\n        // Set tabindex value on the slide, like in the case that the slide is\n        // an <a>\n        if (el.matches(interactiveSelector)) {\n          el.tabIndex = tabindexValue;\n        }\n        // Set tabindex values on all interactive children\n        results.push(el.querySelectorAll(interactiveSelector).forEach(function (el) {\n          return el.tabIndex = tabindexValue;\n        }));\n      }\n      return results;\n    },\n    // Get the slide elements that match the array of indices\n    getSlideElementsByIndices: function (slideIndices) {\n      return Array.from(this.$el.children).filter(function (el, i) {\n        return indexOf.call(slideIndices, i) >= 0;\n      });\n    }\n  },\n  // Render the track and slotted slides\n  render: function (create) {\n    return create(this.trackHTMLElement, {\n      class: ['ssr-carousel-track', {\n        dragging: this.dragging\n      }],\n      style: this.styles\n    }, this.makeSlides());\n  }\n});\n// CONCATENATED MODULE: ./src/ssr-carousel-track.vue?vue&type=script&lang=coffee&\n /* harmony default export */ var src_ssr_carousel_trackvue_type_script_lang_coffee_ = (ssr_carousel_trackvue_type_script_lang_coffee_); \n// CONCATENATED MODULE: ./node_modules/mini-css-extract-plugin/dist/loader.js!./node_modules/css-loader/dist/cjs.js!./node_modules/vue-loader/lib/loaders/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js!./node_modules/stylus-loader!./node_modules/vue-loader/lib??vue-loader-options!./src/ssr-carousel-track.vue?vue&type=style&index=0&id=6dc0987a&prod&lang=stylus&\n// extracted by mini-css-extract-plugin\n\n// CONCATENATED MODULE: ./src/ssr-carousel-track.vue?vue&type=style&index=0&id=6dc0987a&prod&lang=stylus&\n\n// CONCATENATED MODULE: ./src/ssr-carousel-track.vue\nvar ssr_carousel_track_render, ssr_carousel_track_staticRenderFns\n\n\n\n\n\n/* normalize component */\n\nvar ssr_carousel_track_component = normalizeComponent(\n  src_ssr_carousel_trackvue_type_script_lang_coffee_,\n  ssr_carousel_track_render,\n  ssr_carousel_track_staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\n/* harmony default export */ var ssr_carousel_track = (ssr_carousel_track_component.exports);\n// CONCATENATED MODULE: ./src/concerns/accessibility.coffee\n/*\nCode related to supporting keyboard interaction and screen readers\n*/\n/* harmony default export */ var accessibility_coffee = ({\n  // The label to use for pagination\n  props: {\n    paginationLabel: String\n  },\n  // Store whether the user appears to be using keyboard to navigate\n  data: function () {\n    return {\n      usingKeyboard: false\n    };\n  },\n  computed: {\n    // Determine the descriptor to use in aria messages\n    pageLabel: function () {\n      switch (false) {\n        case !this.paginationLabel:\n          return this.paginationLabel;\n        case !this.paginateBySlide:\n          return \"Slide\";\n        default:\n          return \"Page\";\n      }\n    },\n    // Make the current slide message\n    // https://www.w3.org/WAI/tutorials/carousels/functionality/#announce-the-current-item\n    currentSlideMessage: function () {\n      return `${this.pageLabel} ${this.boundedIndex + 1} of ${this.pages}`;\n    }\n  },\n  watch: {\n    // When switching to keyboard navigation, I could never reproduce a scenario\n    // where the focused elements wasn't the first slide, so I'm resetting the\n    // active page to the first slide\n    usingKeyboard: function () {\n      if (this.usingKeyboard) {\n        return this.goto(0);\n      }\n    }\n  },\n  methods: {\n    // Once a user uses tab on the carousel, mark them as using their keyboard.\n    // This is cleared by the onPointerDown method.\n    onTab: function () {\n      return this.usingKeyboard = true;\n    }\n  }\n});\n// CONCATENATED MODULE: ./src/concerns/autoplay.coffee\n/*\nCode related to auotplay features of the carousel\n*/\n/* harmony default export */ var autoplay_coffee = ({\n  props: {\n    // A delay provided in seconds for the autoplay. 0 is disabled\n    autoplayDelay: {\n      type: Number,\n      default: 0\n    },\n    // Should we pause on hover\n    pauseOnFocus: {\n      type: Boolean,\n      default: true\n    }\n  },\n  // Start autolaying on mount\n  mounted: function () {\n    return this.autoplayStart();\n  },\n  beforeDestroy: function () {\n    return this.autoplayStop();\n  },\n  computed: {\n    // Conditions that result in pausing autoplay\n    autoplayPaused: function () {\n      switch (false) {\n        // Always pause when using keyboard navigation\n        case !this.usingKeyboard:\n          return true;\n        // Stop animation if window is hidden or if carousel is focused\n        case !this.pauseOnFocus:\n          return this.windowHidden || this.isFocused;\n      }\n    }\n  },\n  watch: {\n    // Respond to conditions that may automatically pause autoplaying\n    autoplayPaused: function (paused) {\n      if (paused) {\n        return this.autoplayStop();\n      } else {\n        return this.autoplayStart();\n      }\n    }\n  },\n  methods: {\n    autoplayStart: function () {\n      // Require a delay amount\n      if (!this.autoplayDelay) {\n        return;\n      }\n      // Don't loop if we only have one page\n      if (!this.pages) {\n        return;\n      }\n      // Start autoplaying\n      return this.autoPlayInterval = setInterval(() => {\n        if (!this.autoplayPaused) {\n          return this.autoplayNext();\n        }\n      }, this.autoplayDelay * 1000);\n    },\n    autoplayStop: function () {\n      return clearInterval(this.autoPlayInterval);\n    },\n    // Advance to the next slide\n    autoplayNext: function () {\n      if (this.shouldLoop || this.index < this.pages - 1) {\n        return this.next();\n      } else {\n        return this.goto(0); // Reset because loop wasn't enabled\n      }\n    }\n  }\n});\n// CONCATENATED MODULE: ./src/concerns/dimensions.coffee\n/*\nCode related to measuring the size of the carousel after mounting\n*/\n/* harmony default export */ var dimensions_coffee = ({\n  data: function () {\n    return {\n      viewportWidth: null,\n      // Width of the viewport, for media query calculation\n      carouselWidth: null,\n      // Width of a page of the carousel\n      gutterWidth: 0 // Computed width of gutters, since they support css vars\n    };\n  },\n\n  // Add resize listening\n  mounted: function () {\n    this.onResize();\n    return window.addEventListener('resize', this.onResize);\n  },\n  // Cleanup listeners\n  beforeDestroy: function () {\n    return window.removeEventListener('resize', this.onResize);\n  },\n  computed: {\n    // The width of a page of slides, which may be less than the carouselWidth\n    // if there is peeking. This includes the affect of gutters.\n    pageWidth: function () {\n      return this.carouselWidth - this.combinedPeek;\n    },\n    // Calculate the width of a slide based on client side measured pageWidth\n    // rather than measuring it explicitly in the DOM. This value includes the\n    // gutter.\n    slideWidth: function () {\n      return this.pageWidth / this.currentSlidesPerPage;\n    },\n    // Calculate the width of the whole track from the slideWidth.\n    trackWidth: function () {\n      if (this.isVariableWidth) {\n        return this.measuredTrackWidth + this.gutterWidth;\n      } else {\n        return this.slideWidth * this.slidesCount;\n      }\n    },\n    // Figure out the width of the last page, which may not have enough slides\n    // to fill it.\n    lastPageWidth: function () {\n      var slidesOnLastPage, slidesPerPage, width;\n      // Determine how many slides are on the final page of pagination. If the\n      // remainder was 0, that means the page is flush with slides, so swap\n      // the 0 for the max amount.\n      slidesPerPage = this.currentSlidesPerPage;\n      slidesOnLastPage = this.slidesCount % slidesPerPage;\n      if (slidesOnLastPage === 0) {\n        slidesOnLastPage = slidesPerPage;\n      }\n      // Turn the slide count into a width value\n      width = slidesOnLastPage * this.slideWidth;\n      return width;\n    },\n    // The ending x value, only used when not looping. The peeking values in\n    // here result in the final page using the left peeking value and the\n    // actualy peeking appearing to apply to the left. The +1 is to fix subpixel\n    // rounding issues.\n    endX: function () {\n      if (this.disabled) {\n        return 0;\n      } else {\n        return this.pageWidth - this.trackWidth - this.peekLeftPx + this.peekRightPx + 1;\n      }\n    },\n    // Check if the drag is currently out bounds\n    isOutOfBounds: function () {\n      return this.currentX > 0 || this.currentX < this.endX;\n    }\n  },\n  methods: {\n    // Measure the component width for various calculations. Using\n    // getBoundingClientRect so we can get fractional values.  We also need\n    // the width of the gutter since that's effectively part of the page.\n    onResize: function () {\n      var firstSlide, ref;\n      if (((ref = this.$el) != null ? ref.nodeType : void 0) !== Node.ELEMENT_NODE) {\n        return;\n      }\n      if (!(firstSlide = this.$refs.track.$el.firstElementChild)) {\n        return;\n      }\n      this.gutterWidth = parseInt(getComputedStyle(firstSlide).marginRight);\n      this.carouselWidth = this.$el.getBoundingClientRect().width + this.gutterWidth;\n      this.viewportWidth = window.innerWidth;\n      this.capturePeekingMeasurements();\n      if (this.isVariableWidth) {\n        return this.captureTrackWidth();\n      }\n    },\n    // Make the width style that gives a slide it's width given\n    // slidesPerPage. Reduce this width by the gutter if present\n    makeBreakpointSlideWidthStyle: function (breakpoint) {\n      if (this.isVariableWidth) {\n        return;\n      }\n      return `${this.scopeSelector} .ssr-carousel-slide {\n\twidth: ${this.makeSlideWidthCalc(breakpoint)};\n}`;\n    },\n    // Build the calc string which makes a percentage width for a slide and\n    // reduces it by combined peeking and gutter influence. The computed\n    // style this produces should have an equal value to the `slideWidth`\n    // computed property which is client side JS dependent.\n    makeSlideWidthCalc: function (breakpoint) {\n      var gutter, isDisabled, peekLeft, peekRight, slidesPerPage;\n      isDisabled = this.isDisabledAtBreakpoint(breakpoint);\n      slidesPerPage = this.getResponsiveValue('slidesPerPage', breakpoint);\n      gutter = this.getResponsiveValue('gutter', breakpoint);\n      // A common use case when not looping is to have a larger peek on just the\n      // right.  But when disabled, this looks strange.  So this balances out\n      // the peeking in the disbaled state.\n      peekLeft = this.getResponsiveValue('peekLeft', breakpoint);\n      if (this.matchPeekWhenDisabled && isDisabled) {\n        peekRight = peekLeft;\n      } else {\n        peekRight = this.getResponsiveValue('peekRight', breakpoint);\n      }\n      // Render the styles\n      return `calc( ${100 / slidesPerPage}% - (${this.autoUnit(peekLeft)} + ${this.autoUnit(peekRight)}) / ${slidesPerPage} - (${this.autoUnit(gutter)} * ${slidesPerPage - 1}) / ${slidesPerPage} )`;\n    }\n  }\n});\n// CONCATENATED MODULE: ./src/concerns/dragging.coffee\n/*\nCode related to handling dragging of the track\n*/\nvar notPassive, passive;\npassive = {\n  passive: true\n};\nnotPassive = {\n  passive: false\n};\n/* harmony default export */ var dragging_coffee = ({\n  props: {\n    // Boundary drag dampening modifier. Increase to allow greater travel outside\n    // the boundaries.\n    boundaryDampening: {\n      type: Number,\n      default: 0.6\n    },\n    // The percentage of a pageWidth that was dragged before we advance to\n    // another page on slide\n    dragAdvanceRatio: {\n      type: Number,\n      default: .33\n    },\n    // The ratio of X:Y mouse travel. Decrease this number to allow for greater\n    // y dragging before the drag is cancelled.\n    verticalDragTreshold: {\n      type: Number,\n      default: 1\n    },\n    // Turn off draggability\n    noDrag: Boolean\n  },\n  data: function () {\n    return {\n      pressing: false,\n      // The user pressing pointer down\n      dragging: false,\n      // The user has translated while pointer was down\n      isTouchDrag: false,\n      // Is the browser firing touch events\n      startPointer: null,\n      // Where was the mouse when the drag started\n      lastPointer: null,\n      // Where was the mouse on the last move event\n      dragVelocity: null,\n      // The px/tick while dragging, negative is rightward\n      dragDirectionRatio: null // The ratio of horizontal vs vertical dragging\n    };\n  },\n\n  // Cleanup listeners\n  beforeDestroy: function () {\n    window.removeEventListener('mousemove', this.onPointerMove, passive);\n    window.removeEventListener('mouseup', this.onPointerUp, passive);\n    window.removeEventListener('touchmove', this.onPointerMove, passive);\n    window.removeEventListener('touchend', this.onPointerUp, passive);\n    return window.removeEventListener('touchmove', this.onWinMove, notPassive);\n  },\n  computed: {\n    // The current slide or page index. It rounds differently depending on the\n    // direction of the velocity.  So that it eases to a stop in the direction\n    // the user was dragging.\n    dragIndex: function () {\n      switch (false) {\n        // If there is very little velocity, go to the closet page\n        case !(Math.abs(this.dragVelocity) <= 2):\n          return Math.round(this.fractionalIndex);\n        // User was moving forward\n        case !(this.dragVelocity < 0):\n          return Math.ceil(this.fractionalIndex);\n        default:\n          // User was moving backward\n          return Math.floor(this.fractionalIndex);\n      }\n    },\n    // Determine the current index given the currentX as a fraction. For\n    // instance, when dragging forward, it will be like 0.1 and when you've\n    // dragged almost a full page, forward it would be 0.9.  This got\n    // complicated because the final page may not have a full compliment of\n    // slides like if we have 2 per page and 3 slides.  When you have tweened\n    // to the 2nd page, the fractionalIndex should be 2 even though you\n    // haven't traveled the same width as it took to get from 1 to 2.\n    fractionalIndex: function () {\n      var distanceIntoPage, isLastPage, pageIndex, pageProgressPercent, pageWidth, remainingSlides, setIndex, slidesPerPage, widthDivisor, x;\n      if (!this.trackWidth) {\n        return 0;\n      }\n      // Work in positive numbers\n      x = this.currentX * -1;\n      // Figure out what set we're in, like if, through looping, we've gone\n      // through all the pages multiple times.\n      setIndex = Math.floor(x / this.trackWidth);\n      // Figure out the index of last page of the set that has been fully\n      // scrolled into. Not using modulo for this because I got rounding errors.\n      widthDivisor = this.paginateBySlide ? this.slideWidth : this.pageWidth;\n      pageIndex = Math.floor((x - setIndex * this.trackWidth) / widthDivisor);\n      // Figure out the progress into the current page\n      distanceIntoPage = x - setIndex * this.trackWidth - pageIndex * widthDivisor;\n      // Determine if we're on the last page. If we're not looping, an extra\n      // \"page\" of slides is treated as part of the last page because of how we\n      // end with the slides flush with the right edge.\n      slidesPerPage = this.currentSlidesPerPage;\n      remainingSlides = function () {\n        switch (false) {\n          case !this.shouldLoop:\n            return this.slidesCount - pageIndex * slidesPerPage;\n          default:\n            return this.slidesCount - (pageIndex + 1) * slidesPerPage;\n        }\n      }.call(this);\n      isLastPage = remainingSlides <= slidesPerPage;\n      // Make a percentage of travel into the page\n      pageWidth = isLastPage ? this.lastPageWidth : widthDivisor;\n      pageProgressPercent = distanceIntoPage / pageWidth;\n      // Return the final value by adding all the passed index values\n      return pageProgressPercent + setIndex * this.pages + pageIndex;\n    },\n    // Determine if the user is dragging vertically\n    isVerticalDrag: function () {\n      if (!this.dragDirectionRatio) {\n        return;\n      }\n      return this.dragDirectionRatio < this.verticalDragTreshold;\n    },\n    // If we're horiztonally swiping on a touch device, prevent vertical scroll\n    preventVerticalScroll: function () {\n      return this.pressing && this.isTouchDrag && !this.isVerticalDrag;\n    }\n  },\n  watch: {\n    // Watch for mouse move changes when the user starts dragging\n    pressing: function () {\n      var moveEvent, upEvent;\n      // Determine the type of event\n      [moveEvent, upEvent] = this.isTouchDrag ? ['touchmove', 'touchend'] : ['mousemove', 'mouseup'];\n      // Pointer is down, start watching for drags\n      if (this.pressing) {\n        window.addEventListener(moveEvent, this.onPointerMove, passive);\n        window.addEventListener(upEvent, this.onPointerUp, passive);\n        window.addEventListener('contextmenu', this.onPointerUp, passive);\n        this.dragVelocity = 0; // Reset any previous velocity\n        this.preventContentDrag();\n        this.stopTweening();\n      } else {\n        // Tween so the track is in bounds if it was out\n        // The pointer is up, so tween to final position\n        if (this.isOutOfBounds && !this.shouldLoop) {\n          if (this.currentX >= 0) {\n            this.gotoStart();\n          } else {\n            this.gotoEnd();\n          }\n          // If rendering variable width slides, don't come to a rest at an index\n        } else if (this.isVariableWidth) {\n          this.tweenToStop();\n          // If user was vertically dragging, reset the index\n        } else if (this.isVerticalDrag) {\n          this.goto(this.index);\n        } else {\n          // Handle normal swiping\n          this.goto(this.dragIndex);\n        }\n        // Cleanup vars and listeners\n        window.removeEventListener(moveEvent, this.onPointerMove, passive);\n        window.removeEventListener(upEvent, this.onPointerUp, passive);\n        window.removeEventListener('contextmenu', this.onPointerUp, passive);\n        this.dragging = false;\n        this.startPointer = this.lastPointer = this.dragDirectionRatio = null;\n      }\n      // Fire events\n      if (this.pressing) {\n        return this.$emit('press');\n      } else {\n        return this.$emit('release');\n      }\n    },\n    // Fire events related to dragging\n    dragging: function () {\n      if (this.dragging) {\n        return this.$emit('drag:start');\n      } else {\n        return this.$emit('drag:end');\n      }\n    },\n    // If the user is dragging vertically, end the drag based on the assumption\n    // that the user is attempting to scroll the page via touch rather than\n    // pan the carousel.\n    isVerticalDrag: function () {\n      if (!(this.isVerticalDrag && this.isTouchDrag)) {\n        return;\n      }\n      return this.pressing = false;\n    },\n    // Stop vertical scrolling by listening for touchmove events on the body\n    // and cancel them. Need to explicitly set pasive because some mobile\n    // browsers set to true by default.\n    preventVerticalScroll: function (shouldPrevent) {\n      if (shouldPrevent) {\n        return window.addEventListener('touchmove', this.stopEvent, notPassive);\n      } else {\n        return window.removeEventListener('touchmove', this.stopEvent, notPassive);\n      }\n    }\n  },\n  methods: {\n    // Cancel an Event\n    stopEvent: function (e) {\n      return e.preventDefault();\n    },\n    // Keep track of whether user is dragging\n    onPointerDown: function (pointerEvent) {\n      this.isTouchDrag = typeof TouchEvent !== \"undefined\" && TouchEvent !== null && pointerEvent instanceof TouchEvent;\n      this.startPointer = this.lastPointer = this.getPointerCoords(pointerEvent);\n      this.pressing = true;\n      return this.usingKeyboard = false;\n    },\n    // Keep track of release of press\n    onPointerUp: function () {\n      return this.pressing = false;\n    },\n    // Keep x values up to date while dragging\n    onPointerMove: function (pointerEvent) {\n      var pointer;\n      if (!this.dragging) {\n        // Mark the carousel as dragging, which is used to disable clicks\n        this.dragging = true;\n      }\n      // Calculated how much drag has happened since the list move\n      pointer = this.getPointerCoords(pointerEvent);\n      this.dragVelocity = pointer.x - this.lastPointer.x;\n      this.targetX += this.dragVelocity;\n      this.lastPointer = pointer;\n      // Caculate the drag direction ratio\n      this.dragDirectionRatio = Math.abs((pointer.x - this.startPointer.x) / (pointer.y - this.startPointer.y));\n      // Update the track position\n      return this.currentX = this.applyBoundaryDampening(this.targetX);\n    },\n    // Helper to get the x position of either a touch or mouse event\n    getPointerCoords: function (pointerEvent) {\n      var ref, ref1, ref2, ref3;\n      return {\n        x: ((ref = pointerEvent.touches) != null ? (ref1 = ref[0]) != null ? ref1.pageX : void 0 : void 0) || pointerEvent.pageX,\n        y: ((ref2 = pointerEvent.touches) != null ? (ref3 = ref2[0]) != null ? ref3.pageY : void 0 : void 0) || pointerEvent.pageY\n      };\n    },\n    // Prevent dragging from exceeding the min/max edges\n    applyBoundaryDampening: function (x) {\n      switch (false) {\n        case !this.shouldLoop:\n          return x;\n        // Don't apply dampening\n        case !(x > 0):\n          return Math.pow(x, this.boundaryDampening);\n        case !(x < this.endX):\n          return this.endX - Math.pow(this.endX - x, this.boundaryDampening);\n        default:\n          return this.applyXBoundaries(x);\n      }\n    },\n    // Constraint the x value to the min and max values\n    applyXBoundaries: function (x) {\n      if (this.shouldLoop) {\n        return x; // Don't apply boundaries\n      } else {\n        return Math.max(this.endX, Math.min(0, x));\n      }\n    },\n    // Prevent the anchors and images from being draggable (like via their\n    // ghost outlines). Using this approach because the draggable html attribute\n    // didn't work in FF.  This only needs to be run once.\n    preventContentDrag: function () {\n      if (this.contentDragPrevented) {\n        return;\n      }\n      this.$refs.track.$el.querySelectorAll('a, img').forEach(function (el) {\n        return el.addEventListener('dragstart', function (e) {\n          return e.preventDefault();\n        });\n      });\n      return this.contentDragPrevented = true;\n    }\n  }\n});\n// CONCATENATED MODULE: ./src/concerns/feathering.coffee\n/*\nCode related to implementing feathering effect.\n*/\n/* harmony default export */ var feathering_coffee = ({\n  props: {\n    // Shorthand for enabling boolean and setting it's width\n    feather: {\n      type: Boolean | String | Number,\n      default: false\n    }\n  },\n  methods: {\n    // Add feathering styles via breakpoint\n    makeBreakpointFeatheringStyle: function (breakpoint) {\n      var cssValue, feather;\n      // Disable feathering if not enough slides\n      if (this.isDisabledAtBreakpoint(breakpoint)) {\n        return;\n      }\n      // Get feathering amount\n      feather = this.getResponsiveValue('feather', breakpoint);\n      if (feather === false || feather === null) {\n        return;\n      }\n      if (!(feather && typeof feather !== 'boolean')) {\n        feather = 20;\n      }\n      feather = this.autoUnit(feather);\n      // Make the rule value\n      cssValue = `linear-gradient(to right,\n\ttransparent, black ${feather},\n\tblack calc(100% - ${feather}),\n\ttransparent)`;\n      // Write the style, with browser prefixes\n      return `${this.scopeSelector} .ssr-carousel-mask {\n\t-webkit-mask-image: ${cssValue};\n\tmask-image: ${cssValue};\n}`;\n    }\n  }\n});\n// CONCATENATED MODULE: ./src/concerns/focus.coffee\n/*\nCode related to focus and hover state\n*/\n/* harmony default export */ var focus_coffee = ({\n  // Some simple data about our component and window its mounted on\n  data: function () {\n    return {\n      hovered: false,\n      windowVisible: true\n    };\n  },\n  computed: {\n    isFocused: function () {\n      return this.windowVisible && this.hovered;\n    },\n    windowHidden: function () {\n      return !this.windowVisible;\n    }\n  },\n  methods: {\n    onEnter: function () {\n      return this.hovered = true;\n    },\n    onLeave: function () {\n      return this.hovered = false;\n    },\n    // Updates @windowVisible based on our document\n    updateVisibility: function () {\n      return this.windowVisible = !document.hidden;\n    }\n  },\n  // Watch the visibility updates of our document\n  mounted: function () {\n    if (!this.watchesHover) {\n      return;\n    }\n    return document.addEventListener('visibilitychange', this.updateVisibility);\n  },\n  beforeDestroy: function () {\n    return document.removeEventListener('visibilitychange', this.updateVisibility);\n  }\n});\n// CONCATENATED MODULE: ./src/concerns/gutters.coffee\n/*\nCode related to the gutters between slides\n*/\n/* harmony default export */ var gutters_coffee = ({\n  props: {\n    // The gutters between slides\n    gutter: {\n      type: Number | String,\n      default: 20\n    }\n  },\n  methods: {\n    // Apply gutters between slides via margins\n    makeBreakpointSlideGutterStyle: function (breakpoint) {\n      var gutter, lastChildGutter;\n      gutter = this.getResponsiveValue('gutter', breakpoint);\n      // If carousel would be disabled for not having enough slides, then remove\n      // gutter from last slide.\n      lastChildGutter = this.isDisabledAtBreakpoint(breakpoint) ? 0 : gutter;\n      // Render styles\n      return `${this.scopeSelector} .ssr-carousel-slide {\n\tmargin-right: ${this.autoUnit(gutter)};\n}\n${this.scopeSelector} .ssr-carousel-slide:is(:last-child) {\n\tmargin-right: ${this.autoUnit(lastChildGutter)};\n}`;\n    }\n  }\n});\n// CONCATENATED MODULE: ./src/concerns/looping.coffee\n/*\nCode related to looping / infinite scroll\n*/\n/* harmony default export */ var looping_coffee = ({\n  props: {\n    // Add prop to enable looping\n    loop: Boolean,\n    // Place the first slide in the center of the layout\n    center: Boolean\n  },\n  // Store the slide order indexes\n  data: function () {\n    return {\n      slideOrder: []\n    };\n  },\n  computed: {\n    // Disable looping when the user is using keyboard navigation\n    shouldLoop: function () {\n      return this.loop && !this.usingKeyboard;\n    },\n    // This represents the current (as in while scrolling / animating) left most\n    // slide index. This is used in looping calculation so that the reordering\n    // of slides isn't affected by paginatePerSlide setting.\n    currentSlideIndex: function () {\n      return Math.floor(this.currentX / this.slideWidth * -1);\n    },\n    // When looping, slides get re-ordered. This value is added to the\n    // track transform so that the slides don't feel like they were re-ordered.\n    trackLoopOffset: function () {\n      var offsetSlideCount;\n      if (!this.shouldLoop) {\n        return 0;\n      }\n      offsetSlideCount = this.currentSlideIndex;\n      if (this.hasLeftPeekClone) {\n        offsetSlideCount -= 1;\n      }\n      return offsetSlideCount * this.slideWidth;\n    },\n    // Get slideIndex of the right most and left most slides indexes\n    leftMostSlideIndex: function () {\n      return this.slideOrder.findIndex(index => {\n        return index === 0;\n      });\n    },\n    rightMostSlideIndex: function () {\n      return this.slideOrder.findIndex(index => {\n        return index === this.slideOrder.length - 1;\n      });\n    }\n  },\n  watch: {\n    // This represents the current (as in while scrolling / animating) left most\n    // slide index. This is used in looping calculation so that the reordering\n    // of slides isn't affected by paginatePerSlide setting.\n    currentSlideIndex: {\n      immediate: true,\n      handler: function () {\n        return this.setSlideOrder();\n      }\n    },\n    // Also update the slide order when the slides per page changes\n    currentSlidesPerPage: function () {\n      return this.setSlideOrder();\n    }\n  },\n  methods: {\n    // Calculating via watcher to prevent unnecesary recalculations (I noticed a\n    // bunch of calls when this was done via a computed property)\n    setSlideOrder: function () {\n      var count, indices, split;\n      // Make an array as long as the slides count with incrementing values\n      indices = [...Array(this.slidesCount).keys()];\n      count = indices.length;\n      // Shift the order to applying centering effect\n      if (this.center) {\n        split = Math.floor(this.currentSlidesPerPage / 2);\n        indices = [...indices.slice(split), ...indices.slice(0, split)];\n      }\n      // Re-order while looping\n      if (this.shouldLoop) {\n        split = (count - this.currentSlideIndex) % count;\n        indices = [...indices.slice(split), ...indices.slice(0, split)];\n      }\n      // Set the new index order\n      return this.slideOrder = indices;\n    },\n    // Reorder the initial slide state using CSS because the order is dependent\n    // on the slides per page which isn't known via JS until hydrating\n    makeBreakpointSlideOrderStyle: function (breakpoint) {\n      var i, rules, slidesPerPage, split;\n      if (!this.center) {\n        return;\n      }\n      slidesPerPage = this.getResponsiveValue('slidesPerPage', breakpoint);\n      split = Math.floor(slidesPerPage / 2);\n      rules = function () {\n        var j, ref, results;\n        results = [];\n        for (i = j = 0, ref = this.slidesCount; 0 <= ref ? j <= ref : j >= ref; i = 0 <= ref ? ++j : --j) {\n          results.push(`${this.scopeSelector} .ssr-carousel-slide:nth-child(${i + 1}) {\n\torder: ${(i + split) % this.slidesCount};\n}`);\n        }\n        return results;\n      }.call(this);\n      return rules.join('');\n    }\n  }\n});\n// CONCATENATED MODULE: ./src/concerns/pagination.coffee\n/*\nCode related to dealing with advancing between pages\n*/\n/* harmony default export */ var pagination_coffee = ({\n  props: {\n    // If true, advance whole pages when navigating\n    paginateBySlide: Boolean,\n    // Syncs to the `index` value via v-model\n    value: {\n      type: Number,\n      default: 0\n    }\n  },\n  data: function () {\n    return {\n      index: this.value,\n      // The current page; when looping may exceed slideCount\n      currentX: 0,\n      // The actual left offset of the slides container\n      targetX: 0 // Where we may be tweening the slide to\n    };\n  },\n\n  computed: {\n    // The current number of pages\n    pages: function () {\n      switch (false) {\n        // When looping and paginating per slide, make a dot per slide\n        case !(this.paginateBySlide && this.shouldLoop):\n          return this.slidesCount;\n        // Else, restrict pages so you the last slide is flush with right edge\n        case !this.paginateBySlide:\n          return this.slidesCount - this.currentSlidesPerPage + 1;\n        default:\n          // When not paginating by slide, the amount of pages is related to the\n          // current number of slides shown per page.\n          return Math.ceil(this.slidesCount / this.currentSlidesPerPage);\n      }\n    },\n    // Disable carousel-ness when there aren't enough slides\n    disabled: function () {\n      if (this.isVariableWidth) {\n        return Math.round(this.trackWidth) <= Math.round(this.carouselWidth);\n      } else {\n        return this.slidesCount <= this.currentSlidesPerPage;\n      }\n    },\n    // Get just the slotted slides that are components, ignoring text nodes\n    // which may exist as a result of whitespace\n    slides: function () {\n      return (this.$slots.default || []).filter(function (vnode) {\n        return !vnode.text;\n      });\n    },\n    // Get the total number of slides\n    slidesCount: function () {\n      return this.slides.length;\n    },\n    // Apply boundaries to the index, which will exceed them when looping\n    boundedIndex: function () {\n      var boundedIndex;\n      boundedIndex = this.index % this.pages;\n      if (boundedIndex < 0) {\n        return this.pages + boundedIndex;\n      } else {\n        return boundedIndex;\n      }\n    },\n    // The current incomplete page offset\n    currentIncompletePageOffset: function () {\n      return this.makeIncompletePageOffset(this.index);\n    },\n    // Get an array of slide offsets of the slides that are 100% in the\n    // viewport. Aka, the count will be equal the currentSlidesPerPage per page.\n    activeSlides: function () {\n      var ref, ref1, start;\n      if (this.isVariableWidth) {\n        return function () {\n          var results = [];\n          for (var i = 0, ref = this.slidesCount; 0 <= ref ? i < ref : i > ref; 0 <= ref ? i++ : i--) {\n            results.push(i);\n          }\n          return results;\n        }.apply(this);\n      }\n      // Get the offset of the leftmost slide in the current viewport\n      start = this.paginateBySlide ? this.boundedIndex : this.boundedIndex * this.currentSlidesPerPage;\n      // Adjust the start if not looping and on the last page of slides and there\n      // aren't enough slides to make a full page\n      if (!this.shouldLoop) {\n        start -= this.boundedIndex % this.currentSlidesPerPage;\n      }\n      return function () {\n        var results = [];\n        for (var i = start, ref1 = start + this.currentSlidesPerPage; start <= ref1 ? i < ref1 : i > ref1; start <= ref1 ? i++ : i--) {\n          results.push(i);\n        }\n        return results;\n      }.apply(this).reduce((slides, offset) => {\n        // When looping, use modulo to loop back around\n        if (this.shouldLoop) {\n          slides.push(offset % this.slidesCount);\n          // Else, cap the offset to the last slide\n        } else if (offset < this.slidesCount) {\n          slides.push(offset);\n        }\n        // Return updated slides\n        return slides;\n      }, []);\n    }\n  },\n  watch: {\n    // Treat v-model input as a \"goto\" request\n    value: function () {\n      // If the value exceeds the bounds, immediately emit a new input event\n      // with the corrected value\n      if (this.value !== this.applyIndexBoundaries(this.value)) {\n        return this.$emit('input', this.boundedIndex);\n        // Else if the incoming value is different than the current value\n        // then tween to it\n      } else if (this.value !== this.boundedIndex) {\n        return this.goto(this.value);\n      }\n    },\n    // Emit events on index change\n    boundedIndex: function () {\n      this.$emit('change', {\n        index: this.boundedIndex\n      });\n      return this.$emit('input', this.boundedIndex); // For v-model\n    }\n  },\n\n  methods: {\n    // Advance methods\n    next: function () {\n      return this.goto(this.index + 1);\n    },\n    back: function () {\n      return this.goto(this.index - 1);\n    },\n    // The dots are ignorant of looping, so convert their bounded index to the\n    // true index so we don't animate through a ton of pages going to the\n    // clicked dot.\n    gotoDot: function (dotIndex) {\n      return this.goto(dotIndex - this.boundedIndex + this.index);\n    },\n    // Go to a specific index\n    goto: function (index) {\n      this.index = this.applyIndexBoundaries(index);\n      return this.tweenToIndex(this.index);\n    },\n    // Go to the beginning of track\n    gotoStart: function () {\n      if (this.isVariableWidth) {\n        return this.tweenToX(0);\n      } else {\n        return this.goto(0);\n      }\n    },\n    // Go to the end of the track\n    gotoEnd: function () {\n      if (this.isVariableWidth) {\n        return this.tweenToX(this.endX);\n      } else {\n        return this.goto(this.pages - 1);\n      }\n    },\n    // Tween to a specific index\n    tweenToIndex: function (index) {\n      this.targetX = this.getXForIndex(index);\n      return this.startTweening();\n    },\n    // Jump to an index with no tween\n    jumpToIndex: function (index) {\n      return this.currentX = this.targetX = this.getXForIndex(index);\n    },\n    // Calculate the X value given an index\n    getXForIndex: function (index) {\n      var x;\n      // Figure out the new x position\n      x = this.paginateBySlide ? index * this.slideWidth * -1 : index * this.pageWidth * -1;\n      // Apply adjustments to x value and persist\n      x += this.makeIncompletePageOffset(index);\n      return Math.round(this.applyXBoundaries(x));\n    },\n    // Creates a px value to represent adjustments that should be made to\n    // account for incommplete pages of slides when looping is enabled. Like\n    // when there is 3 slotted slides and 2 slides per page and you have looped\n    // over to the 2nd page index of 0. The track needs to be shifted to the\n    // left by one slideWidth in this case.\n    makeIncompletePageOffset: function (index) {\n      var incompleteWidth;\n      if (!(this.shouldLoop && !this.paginateBySlide)) {\n        return 0;\n      }\n      incompleteWidth = this.pageWidth - this.lastPageWidth;\n      return Math.floor(index / this.pages) * incompleteWidth;\n    },\n    // Apply boundaries to the index\n    applyIndexBoundaries: function (index) {\n      if (this.shouldLoop) {\n        return index;\n      } else {\n        return Math.max(0, Math.min(this.pages - 1, index));\n      }\n    }\n  }\n});\n// CONCATENATED MODULE: ./src/concerns/peeking.coffee\n/*\nCode related to allowing edge slides to peek in from the side, including empty\ngutter space.\n*/\n/* harmony default export */ var peeking_coffee = ({\n  props: {\n    // Use gutter's as the peeking value\n    peekGutter: Boolean,\n    // Set both peeking values at once\n    peek: {\n      type: Number | String,\n      default: function () {\n        // Prevent subpixel rounding issues from causing a sliver of offscreen\n        // slide from peaking in.\n        if (!this.peekGutter) {\n          return 0;\n        } else {\n          return `calc(${this.gutter} - 1px)`;\n        }\n      }\n    },\n    // Distinct left/right peeking values\n    peekLeft: {\n      type: Number | String,\n      default: function () {\n        return this.peek;\n      }\n    },\n    peekRight: {\n      type: Number | String,\n      default: function () {\n        return this.peek;\n      }\n    },\n    // When true, the peekLeft is used for the peekRight if the carousel is\n    // disabled.  This behavior is expecting that there may be a different\n    // peekRight (to hint at additional slides) but when there aren't more slide\n    // to peek in, the peek value should functional like padding.\n    matchPeekWhenDisabled: {\n      type: Boolean,\n      default: true\n    },\n    // Disable the overflow:hidden on the mask\n    overflowVisible: Boolean\n  },\n  data: function () {\n    return {\n      // Store clones of the slides used for peeking\n      clones: [],\n      // Store computed peek values\n      peekLeftPx: 0,\n      peekRightPx: 0\n    };\n  },\n  computed: {\n    // Determine if clones should be created\n    hasPeekClones: function () {\n      return this.hasLeftPeekClone || this.hasRightPeekClone;\n    },\n    hasPeekPrerequisites: function () {\n      return this.shouldLoop && this.slidesCount > 1;\n    },\n    hasLeftPeekClone: function () {\n      return this.hasPeekPrerequisites && this.peekLeft;\n    },\n    hasRightPeekClone: function () {\n      return this.hasPeekPrerequisites && this.peekRight;\n    },\n    // Figure out which slide indexes to show in the left and right peek slots\n    leftPeekingSlideIndex: function () {\n      if (this.hasLeftPeekClone) {\n        return this.rightMostSlideIndex;\n      }\n    },\n    rightPeekingSlideIndex: function () {\n      if (this.hasRightPeekClone) {\n        return this.leftMostSlideIndex;\n      }\n    },\n    // Combine the peeking values, which is needed commonly\n    combinedPeek: function () {\n      return this.peekLeftPx + this.peekRightPx;\n    },\n    // Make the styles object for reading computed styles\n    peekStyles: function () {\n      var breakpoint;\n      breakpoint = this.currentResponsiveBreakpoint;\n      return {\n        left: this.autoUnit(this.getResponsiveValue('peekLeft', breakpoint)),\n        right: this.autoUnit(this.getResponsiveValue('peekRight', breakpoint))\n      };\n    }\n  },\n  watch: {\n    // Recapture peeking values if the source props change\n    peekLeft: function () {\n      return this.capturePeekingMeasurements();\n    },\n    peekRight: function () {\n      return this.capturePeekingMeasurements();\n    },\n    peek: function () {\n      return this.capturePeekingMeasurements();\n    },\n    peekGutter: function () {\n      return this.capturePeekingMeasurements();\n    },\n    responsive: function () {\n      return this.capturePeekingMeasurements(); // Easier to respond to all\n    }\n  },\n\n  methods: {\n    // Capture measurements of peeking values\n    capturePeekingMeasurements: function () {\n      if (!this.$refs.peekValues) {\n        return;\n      }\n      return this.$nextTick(function () {\n        // Wait for getResponsiveValue on @peekStyles\n        var styles;\n        styles = getComputedStyle(this.$refs.peekValues);\n        this.peekLeftPx = parseInt(styles.left);\n        return this.peekRightPx = parseInt(styles.right);\n      });\n    },\n    // Calculate the offset that gets added to the current position to account\n    // for prepended slides from peeking. This replicates the JS required to\n    // make `trackLoopOffset` using CSS only so there is now reflow when JS\n    // hydrates.  This gets overridden by the track's inline translateX style.\n    makeBreakpointTrackTransformStyle: function (breakpoint) {\n      var gutter, peekLeft, rule;\n      if (this.isDisabledAtBreakpoint(breakpoint)) {\n        return;\n      }\n      peekLeft = this.getResponsiveValue('peekLeft', breakpoint);\n      // If no peeking slide, just add the offset\n      rule = !this.hasLeftPeekClone ? `transform: translateX(${// Otherwise, offset by one slide width (including it's gutter)\n      this.autoUnit(peekLeft)});` : (gutter = this.getResponsiveValue('gutter', breakpoint), `transform: translateX(calc( ${this.autoUnit(peekLeft)} - (${this.makeSlideWidthCalc(breakpoint)} + ${this.autoUnit(gutter)}) ));`);\n      // Wrap rule in selector\n      return `${this.scopeSelector} .ssr-carousel-track { ${rule} }`;\n    }\n  }\n});\n// CONCATENATED MODULE: ./src/concerns/responsive.coffee\n/*\nCode related to changing the slides per page at different viewport widths\n*/\n/* harmony default export */ var responsive_coffee = ({\n  props: {\n    // How many slides are visible at once in the viewport if no responsive\n    // rules apply\n    slidesPerPage: {\n      type: Number,\n      default: 1\n    },\n    // Provide different slides per page at different viewport widths\n    responsive: {\n      type: Array,\n      default: function () {\n        return [];\n      }\n    }\n  },\n  computed: {\n    // Make the css scopeId from things that can influence the styles, like the\n    // slides count and props.\n    scopeId: function () {\n      return this.hashString(this.slidesCount + '|' + JSON.stringify(this.$props));\n    },\n    // Massage media queries into the responsive prop\n    responsiveRules: function () {\n      return this.responsive.map(breakpoint => {\n        return {\n          ...breakpoint,\n          mediaQuery: this.makeMediaQuery(breakpoint),\n          active: this.isBreakpointActive(breakpoint),\n          // Unpack shorthands\n          peekLeft: breakpoint.peekLeft || breakpoint.peek || (breakpoint.peekGutter ? breakpoint.gutter : void 0),\n          peekRight: breakpoint.peekRight || breakpoint.peek || (breakpoint.peekGutter ? breakpoint.gutter : void 0)\n        };\n      });\n    },\n    // Get current responsive values\n    currentSlidesPerPage: function () {\n      return this.getResponsiveValue('slidesPerPage', this.currentResponsiveBreakpoint);\n    },\n    // Get the current responsive rule by looping backwards through the\n    // responsiveRules to return the last matching rule.\n    currentResponsiveBreakpoint: function () {\n      var match;\n      if (match = [...this.responsiveRules].reverse().find(function ({\n        active\n      }) {\n        return active;\n      })) {\n        return match; // Return the matching rule\n        // Defaults\n      } else {\n        return {\n          slidesPerPage: this.slidesPerPage,\n          gutter: this.gutter,\n          peekLeft: this.peekLeft || this.peek || (this.peekGutter ? this.gutter : void 0),\n          peekRight: this.peekRight || this.peek || (this.peekGutter ? this.gutter : void 0),\n          feather: this.feather\n        };\n      }\n    },\n    // Make the scoping selecotr\n    scopeSelector: function () {\n      return `[data-ssrc-id='${this.scopeId}']`;\n    },\n    // Assemble all the dynamic instance styles\n    instanceStyles: function () {\n      return this.makeBreakpointStyles(this.$props) + this.responsiveRules.map(breakpoint => {\n        return `@media ${breakpoint.mediaQuery} { ${this.makeBreakpointStyles(breakpoint)} }`;\n      }).join(' ');\n    }\n  },\n  watch: {\n    // Fix alignment of slides while resizing\n    pageWidth: function () {\n      return this.jumpToIndex(this.index);\n    },\n    // If resizing the browser leads to disabling, reset the slide to the first\n    // page.  Like if a user had switched to the 2nd page on mobile and then\n    // resized to desktop\n    disabled: function () {\n      if (this.disabled) {\n        return this.goto(0);\n      }\n    }\n  },\n  methods: {\n    // Take an item form the responsive array and make a media query from it\n    makeMediaQuery: function (breakpoint) {\n      var rules;\n      rules = [];\n      if (breakpoint.maxWidth) {\n        rules.push(`(max-width: ${breakpoint.maxWidth}px)`);\n      }\n      if (breakpoint.minWidth) {\n        rules.push(`(min-width: ${breakpoint.minWidth}px)`);\n      }\n      return rules.join(' and ');\n    },\n    // Make the block of styles for a breakpoint\n    makeBreakpointStyles: function (breakpoint) {\n      return [this.makeBreakpointDisablingRules(breakpoint), this.makeBreakpointFeatheringStyle(breakpoint), this.makeBreakpointTrackTransformStyle(breakpoint), this.makeBreakpointSlideWidthStyle(breakpoint), this.makeBreakpointSlideGutterStyle(breakpoint), this.makeBreakpointSlideOrderStyle(breakpoint)].join(' ');\n    },\n    // Apply disabling styles via breakpoint when there are not enough slides\n    // for the slidesPerPage\n    makeBreakpointDisablingRules: function (breakpoint) {\n      var slidesPerPage;\n      slidesPerPage = this.getResponsiveValue('slidesPerPage', breakpoint);\n      // Disabled, center slides and hide carousel UI\n      if (this.slidesCount <= slidesPerPage) {\n        return `${this.scopeSelector} .ssr-carousel-track { justify-content: center; }\n${this.scopeSelector} .ssr-carousel-arrows,\n${this.scopeSelector} .ssr-carousel-dots { display: none; }`;\n      } else {\n        // Enabled, restore default styles\n        return `${this.scopeSelector} .ssr-carousel-track { justify-content: start; }\n${this.scopeSelector} .ssr-carousel-arrows { display: block; }\n${this.scopeSelector} .ssr-carousel-dots { display: flex; }`;\n      }\n    },\n    // Check if carousel disabled at the breakpoint\n    isDisabledAtBreakpoint: function (breakpoint) {\n      var slidesPerPage;\n      slidesPerPage = this.getResponsiveValue('slidesPerPage', breakpoint);\n      return this.slidesCount <= slidesPerPage;\n    },\n    // Check if a breakpoint would apply currently. Not using window.matchQuery\n    // so I can consume via a compued property\n    isBreakpointActive: function (breakpoint) {\n      var val;\n      switch (false) {\n        case !!this.viewportWidth:\n          return false;\n        case !((val = breakpoint.maxWidth) && this.viewportWidth > val):\n          return false;\n        case !((val = breakpoint.minWidth) && this.viewportWidth < val):\n          return false;\n        default:\n          return true;\n      }\n    },\n    // Find the first breakpoint with a property set\n    getResponsiveValue: function (property, breakpoint) {\n      var ruleMatch, val;\n      if ((val = breakpoint[property]) != null) {\n        // If this breakpoint has a value, use it\n        return val;\n      }\n      if (!this.responsiveRules.length) {\n        // If no responsive rules, use default\n        return this[property];\n      }\n      // Check responsive rules to see if any of them contain a value for the\n      // property\n      ruleMatch = this.responsiveRules.find(function (rule) {\n        // Rule must contain this property\n        if (!rule[property]) {\n          return;\n        }\n        if (breakpoint.maxWidth && rule.minWidth && rule.minWidth < breakpoint.maxWidth) {\n          // Match if rule's min-width is less than the target max-width\n          return true;\n        }\n        if (breakpoint.maxWidth && rule.maxWidth && rule.maxWidth < breakpoint.maxWidth) {\n          // Match if rule's max-width is less than the target max-width\n          return true;\n        }\n        if (breakpoint.minWidth && rule.minWidth && rule.minWidth > breakpoint.minWidth) {\n          // Match if rule's min-width is greater than the target min-width\n          return true;\n        }\n        if (breakpoint.minWidth && rule.maxWidth && rule.minWidth > breakpoint.minWidth) {\n          // Match if rule's max-width is greater than the target min-width\n          return true;\n        }\n      });\n      // Return matching property or fallback to the main component prop\n      if (ruleMatch) {\n        return ruleMatch[property];\n      } else {\n        return this[property];\n      }\n    },\n    // Make a hash from a string, adapted from:\n    // https://stackoverflow.com/a/33647870/59160\n    hashString: function (str) {\n      var hash, i, len;\n      hash = 0;\n      i = 0;\n      len = str.length;\n      while (i < len) {\n        hash = (hash << 5) - hash + str.charCodeAt(i++) << 0;\n      }\n      return hash.toString(36);\n    },\n    // Add px unit to a value if numeric\n    autoUnit: function (val) {\n      if (!val) {\n        return '0px';\n      }\n      if (String(val).match(/^[\\d\\-\\.]+$/)) {\n        return `${val}px`;\n      } else {\n        return val;\n      }\n    }\n  }\n});\n// CONCATENATED MODULE: ./src/concerns/tweening.coffee\n/*\nCode related to tweening the position of the track\n*/\n/* harmony default export */ var tweening_coffee = ({\n  props: {\n    // How quickly the carousel slides to a stop. Increase to tween to as stop\n    // quicker.\n    tweenDampening: {\n      type: Number,\n      default: 0.12\n    },\n    // A multiplier that is applied to the dragVelocity when using tweenToStop\n    tweenInertia: {\n      type: Number,\n      default: 3\n    }\n  },\n  data: function () {\n    return {\n      currentX: 0,\n      // The actual left offset of the slides container\n      targetX: 0,\n      // Where we may be tweening the slide to\n      tweening: false // If there is a current RAF based tween running\n    };\n  },\n\n  // Stop any animations that are in flight\n  beforeDestroy: function () {\n    return window.cancelAnimationFrame(this.rafId);\n  },\n  watch: {\n    // Start RAF based tweener\n    tweening: function () {\n      if (this.tweening) {\n        this.$emit('tween:start', {\n          index: this.index\n        });\n        return this.tweenToTarget();\n      } else {\n        window.cancelAnimationFrame(this.rafId);\n        return this.$emit('tween:end', {\n          index: this.index\n        });\n      }\n    }\n  },\n  methods: {\n    // Convenience method to tween to a targetX\n    tweenToX: function (x) {\n      this.targetX = Math.round(x);\n      return this.startTweening();\n    },\n    // Start tweening to target location if necessary and if not already\n    // tweening\n    startTweening: function () {\n      if (this.tweening) {\n        return;\n      }\n      if (this.currentX === this.targetX) {\n        return;\n      }\n      return this.tweening = true;\n    },\n    // The watcher on this will kill active tweens\n    stopTweening: function () {\n      return this.tweening = false;\n    },\n    // Tween the currentX to the targetX\n    tweenToTarget: function () {\n      // Apply tween math\n      this.currentX = this.currentX + (this.targetX - this.currentX) * this.tweenDampening;\n      if (Math.abs(this.targetX - this.currentX) < 1) {\n        // Stops tweening\n        this.currentX = this.targetX;\n        return this.tweening = false;\n      } else {\n        return this.rafId = window.requestAnimationFrame(this.tweenToTarget);\n      }\n    },\n    // Tween to stop based on inertia\n    tweenToStop: function () {\n      this.targetX = this.applyXBoundaries(this.currentX + this.dragVelocity * this.tweenInertia);\n      return this.startTweening();\n    }\n  }\n});\n// CONCATENATED MODULE: ./src/concerns/variable-width.coffee\n/*\nFunctionality related to supporting variable width slides\n*/\n/* harmony default export */ var variable_width_coffee = ({\n  data: function () {\n    return {\n      measuredTrackWidth: 0\n    };\n  },\n  computed: {\n    // Is the carousel in variable width mode\n    isVariableWidth: function () {\n      return this.slidesPerPage === null;\n    }\n  },\n  methods: {\n    // Measure the width of the track\n    captureTrackWidth: function () {\n      if (!this.$refs.track) {\n        return;\n      }\n      return this.measuredTrackWidth = this.$refs.track.$el.scrollWidth;\n    }\n  }\n});\n// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/coffee-loader!./node_modules/vue-loader/lib??vue-loader-options!./src/ssr-carousel.vue?vue&type=script&lang=coffee&\n// Child components\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n/* harmony default export */ var ssr_carouselvue_type_script_lang_coffee_ = ({\n  // Component definition\n  name: 'SsrCarousel',\n  // Load concerns\n  mixins: [accessibility_coffee, autoplay_coffee, dimensions_coffee, dragging_coffee, feathering_coffee, focus_coffee, gutters_coffee, looping_coffee, pagination_coffee, responsive_coffee, peeking_coffee,\n  // After `responsive` so prop can access `gutter` prop\n  tweening_coffee, variable_width_coffee],\n  components: {\n    SsrCarouselArrows: ssr_carousel_arrows,\n    SsrCarouselDots: ssr_carousel_dots,\n    SsrCarouselTrack: ssr_carousel_track\n  },\n  props: {\n    // UI enabling controls\n    showArrows: Boolean,\n    showDots: Boolean\n  },\n  computed: {\n    // Combine the different factors that come together to determine the x\n    // transfrom of the track.  We don't return a value until the carousel\n    // width is measured since the calculation depends on that.\n    trackTranslateX: function () {\n      if (!(this.carouselWidth && !this.disabled)) {\n        return;\n      }\n      return this.currentX + this.trackLoopOffset + this.peekLeftPx; // The value from tweening or dragging // Offset from re-ordering slides for looping // Offset slides for the left peek\n    },\n\n    // Determine whether to create hover event bindings\n    watchesHover: function () {\n      return this.autoplayDelay > 0;\n    },\n    // Create event bindings\n    maskListeners: function () {\n      if (this.disabled) {\n        return {};\n      }\n      return {\n        ...(this.noDrag ? {} : {\n          mousedown: this.onPointerDown,\n          touchstart: this.onPointerDown\n        }),\n        ...(!this.watchesHover ? {} : {\n          mouseenter: this.onEnter,\n          mouseleave: this.onLeave\n        })\n      };\n    }\n  }\n});\n// CONCATENATED MODULE: ./src/ssr-carousel.vue?vue&type=script&lang=coffee&\n /* harmony default export */ var src_ssr_carouselvue_type_script_lang_coffee_ = (ssr_carouselvue_type_script_lang_coffee_); \n// CONCATENATED MODULE: ./node_modules/mini-css-extract-plugin/dist/loader.js!./node_modules/css-loader/dist/cjs.js!./node_modules/vue-loader/lib/loaders/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js!./node_modules/stylus-loader!./node_modules/vue-loader/lib??vue-loader-options!./src/ssr-carousel.vue?vue&type=style&index=0&id=40da5be2&prod&lang=stylus&\n// extracted by mini-css-extract-plugin\n\n// CONCATENATED MODULE: ./src/ssr-carousel.vue?vue&type=style&index=0&id=40da5be2&prod&lang=stylus&\n\n// CONCATENATED MODULE: ./src/ssr-carousel.vue\n\n\n\n\n\n\n/* normalize component */\n\nvar ssr_carousel_component = normalizeComponent(\n  src_ssr_carouselvue_type_script_lang_coffee_,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\n/* harmony default export */ var ssr_carousel = __webpack_exports__[\"default\"] = (ssr_carousel_component.exports);\n\n/***/ })\n/******/ ]);"],"sourceRoot":""}