{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/@splidejs/splide-extension-video/dist/js/splide-extension-video.esm.js","webpack:///(webpack)/buildin/module.js","webpack:///./app/javascript/slideShow.js","webpack:///./app/javascript/packs/programs/show.js","webpack:///./node_modules/@splidejs/splide/dist/js/splide.esm.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","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","factory","_typeof","iterator","obj","constructor","window","g","this","Function","e","__webpack_exports__","global","setImmediate","_classCallCheck","instance","Constructor","TypeError","_defineProperties","target","props","length","descriptor","configurable","writable","isNode","toString","getMethodName","prop","type","indexOf","toLowerCase","concat","substr","toUpperCase","isDomElement","element","Boolean","nodeType","ownerDocument","defaultView","isInteger","isNaN","parseFloat","isFinite","Math","floor","isVimeoUrl","url","test","getVimeoUrl","oEmbedParameters","arguments","undefined","id","idOrUrl","Error","replace","arrayIndexOfSupport","Array","postMessageSupport","postMessage","commonjsGlobal","self","WeakMap","genId","checkInstance","x","methodName","isObject","prefix","rand","random","substring","entry","_id","npo_src","fn","createCommonjsModule","context","definition","builtInProp","cycle","scheduling_queue","ToString","timer","setTimeout","val","config","err","schedule","add","drain","isThenable","_then","o_type","then","notify","chain","notifyIsolated","state","success","failure","cb","ret","reject","msg","promise","resolve","triggered","def","def_wrapper","MakeDefWrapper","apply","iteratePromises","arr","resolver","rejecter","idx","MakeDef","Promise","executor","__NPO__","push","first","last","item","Item","next","f","PromisePrototype","len","msgs","count","callbackMap","storeCallback","player","callback","playerCallbacks","set","getCallbacks","removeCallback","index","splice","swapCallbacks","oldElement","newElement","delete","getOEmbedParameters","defaults","reduce","params","param","getAttribute","createEmbed","_ref","html","querySelector","div","document","createElement","innerHTML","appendChild","firstChild","setAttribute","getOEmbedData","videoUrl","encodeURIComponent","xhr","XDomainRequest","XMLHttpRequest","open","onload","status","json","JSON","parse","responseText","domain_status_code","error","onerror","send","parseMessageData","data","console","warn","method","contentWindow","message","ieVersion","navigator","userAgent","stringify","origin","processData","callbacks","event","forEach","shift","shiftCallbacks","playerMap","readyMap","Player","_this","options","jQuery","getElementById","win","nodeName","iframe","has","readyPromise","onMessage","source","isReadyEvent","isPingResponse","addEventListener","attachEvent","_originalElement","catch","protoProps","staticProps","_this2","args","ready","_this3","_this4","eventName","callMethod","time","language","kind","_this5","removeAttribute","parentNode","removeChild","autopause","color","currentTime","loop","muted","playbackRate","volume","parent","elements","slice","querySelectorAll","handleError","initializeEmbeds","VimeoPlayerResizeEmbeds_","iframes","parentElement","style","paddingBottom","bottom","resizeEmbeds","scope","Timeout","clearFn","_clearFn","clearTimeout","setInterval","clearInterval","timeout","close","unref","ref","enroll","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","active","_onTimeout","clearImmediate","process","registerImmediate","channel","messagePrefix","onGlobalMessage","nextHandle","tasksByHandle","currentlyRunningATask","doc","attachTo","getPrototypeOf","handle","nextTick","runIfPresent","importScripts","postMessageIsAsynchronous","oldOnMessage","onmessage","canUsePostMessage","MessageChannel","port1","port2","documentElement","script","onreadystatechange","task","run","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","marker","runClearTimeout","array","noop","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","each","keys","some","base_provider_BaseProvider","BaseProvider","Splide","Components","players","_proto","createPlayers","attributeName","Elements","getSlides","Slide","Grid","slide","colClass","createPlayer","destroy","js_elements","tag","remove","elm","init","initElements","toggleWrapper","togglePlayButton","container","className","classes","split","children","map","filter","child","classList","contains","findContainer","wrapper","playButton","show","display","hide","initialState","curr","is","base_player_BasePlayer","BasePlayer","videoId","findVideoId","handleClick","toggleRootClass","video","disableOverlayUI","isAutoplay","isActive","play","setup","isPendingPlay","pause","onMouseDown","onMouseUp","shouldHandleClick","readyCallback","playVideo","pauseVideo","autoplay","root","onPlay","onPause","onEnded","removeEventListener","PLAYER_PROPS","player_Player","_BasePlayer","subClass","superClass","__proto__","_options$playerOption","playerOptions","htmlVideo","src","controls","hideControls","max","min","mute","load","html_video_HTMLVideo","_BaseProvider","HTMLVideo","_extends","assign","youtube_player_Player","youtube","YT","playerVars","iv_load_policy","playlist","rel","events","onPlayerReady","onPlayerStateChange","setVolume","_YT$PlayerState","PlayerState","PLAYING","PAUSED","ENDED","match","YOUTUBE_API_SRC","youtube_YouTube","YouTube","oldCallback","bindAPICallback","loadAPI","shouldLoadAPI","firstScriptTag","getElementsByTagName","insertBefore","loaded","onReady","scripts","onYouTubeIframeAPIReady","player_es","player_extends","vimeo_player_Player","vimeo","setMuted","PROVIDERS","HtmlVideo","Vimeo","DEFAULTS","splide_extension_video_extends","PLAYING_STATUS_CLASS_NAME","activeSlide","Providers","mount","Provider","webpackPolyfill","deprecate","paths","slideShow","thumbnailSlider","rewind","fixedWidth","fixedHeight","isNavigation","gap","focus","arrows","pagination","cover","breakpoints","heightRatio","playsinline","sync","SplideVideo","__webpack_modules__","311","__unused_webpack_module","states_namespaceObject","_CREATED","_DESTROYED","_IDLE","_MOUNTED","_MOVING","values","subject","merge","from","to","toArray","isArray","between","m1","m2","sprintf","format","replacements","unit","pad","number","toPixel","applyStyle","position","width","append","clientWidth","dom_remove","find","selector","tagOrClassName","hasClass","tagName","attrs","domify","elms","before","styles","addOrRemoveClasses","addClass","removeClass","names","getRect","getBoundingClientRect","SLIDE","LOOP","FADE","list","endCallback","start","destIndex","newIndex","prevIndex","coord","done","edgeIndex","Controller","speed","rewindSpeed","transition","easing","transform","y","fade","slides","track","height","clientHeight","MESSAGE_PREFIX","exist","ROOT","STATUS_CLASSES","visible","loading","waitForTransition","autoWidth","autoHeight","perPage","perMove","clones","padding","arrowPath","interval","pauseOnHover","pauseOnFocus","resetProgress","lazyLoad","preloadPages","keyboard","drag","dragAngleThreshold","swipeDistanceThreshold","flickVelocityThreshold","flickPower","flickMaxPages","direction","accessibility","slideFocus","trimSpace","updateOnMove","throttle","slider","arrow","prev","page","clone","progress","bar","spinner","sr","i18n","slideX","pageX","Element","Event","unsubscribe","handler","_len","_key","core_event","State","STATES","_o","_i","_c","_e","_t","Extensions","Transition","components","Component","compose","component","required","mounted","visibility","splide","sibling","_this$Event","go","control","wait","refresh","completely","reverse","parseInt","created","RTL","TTB","STYLE_RESTORE_EVENTS","components_elements","Slides","uid","getClasses","findParts","collect","register","realIndex","SlideObject","STATUS_UPDATE_EVENTS","isClone","update","restoreStyles","_update","isVisible","ceil","trackRect","slideRect","top","left","right","isWithin","within","diff","abs","forVisibility","elements_slide","getSlide","includeClones","getSlidesByPage","toIndex","images","img","rootClass","controller","isLoop","newOptions","silently","trim","Track","matches","String","indicator","sign","toPage","parsePage","hasFocus","pageLength","edge","isRtl","Layout","isVertical","isFade","isRTL","isLoopPending","jump","newPosition","getTrimmedPosition","toCoord","onTransitionEnd","translate","cancel","toPosition","innerSize","totalSize","size","minDistance","Infinity","slideIndex","distance","slideSize","offset","cloneCount","Clones","getCloneCount","cloneDeeply","generateClones","baseCount","dimension","fixedSize","cloneNode","func","layout","resize","totalHeight","totalWidth","slideHeight","slideWidth","margin","paddingTop","offsetHeight","vertical","paddingLeft","paddingRight","listRect","offsetWidth","horizontal","getOwnPropertyDescriptor","maxWidth","drag_abs","startCoord","startInfo","currentInfo","isDragging","axis","Drag","disabled","move","passive","end","preventDefault","analyze","cancelable","_start","_end","log","resist","angle","atan","PI","shouldMove","info","velocity","absV","destination","timeStamp","touches","_ref2","clientX","clientY","_ref3","_ref3$x","fromX","_ref3$y","duration","click","onClick","stopPropagation","stopImmediatePropagation","capture","PAUSE_FLAGS","updateDisabled","_Components$Controlle","nextIndex","isEnough","createArrow","firstElementChild","appendArrows","ATTRIBUTES_UPDATE_EVENT","UPDATE_EVENT","Pagination","items","li","button","createPagination","updateAttributes","getItem","SRC_DATA_NAME","SRCSET_DATA_NAME","ARIA_CURRENRT","ARIA_CONTROLS","ARIA_LABEL","ARIA_HIDDEN","TAB_INDEX","KEY_MAP","ltr","ArrowLeft","ArrowRight","Left","Right","rtl","ttb","ArrowUp","ArrowDown","Up","Down","a11y","allAttributes","updateSlide","initArrows","updateArrows","prevLabel","nextLabel","initPagination","activeItem","label","join","updatePagination","initNavigation","main","isButton","mainSlide","updateNavigation","Arrows","SYNC_EVENT","CLICK_EVENTS","TRIGGER_KEYS","COMPLETE","Options","Breakpoints","initialOptions","prevPoint","throttledCheck","check","point","mql","matchMedia","sort","Click","Autoplay","flags","elapse","rate","requestAnimationFrame","_pause","step","timestamp","reset","createInterval","switchOn","flag","Cover","uncover","background","LazyLoad","isSequential","image","loadNext","srcset","Keyboard","Sync","syncMain","syncSibling","moveSibling","A11y","module_Splide","_Core","__webpack_module_cache__"],"mappings":"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","file":"js/programs/show-c5d75f2c6cb1766613e7.js","sourcesContent":[" \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 = \"//d3t8mepmqududz.cloudfront.net/packs/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 280);\n","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n(function webpackUniversalModuleDefinition(root, factory) {\n  if ((typeof exports === \"undefined\" ? \"undefined\" : _typeof(exports)) === 'object' && (typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) === 'object') module.exports = factory();else if (typeof define === 'function' && define.amd) define([], factory);else if ((typeof exports === \"undefined\" ? \"undefined\" : _typeof(exports)) === 'object') exports[\"Splide\"] = factory();else root[\"Splide\"] = factory();\n})(window, function () {\n  return (\n    /******/\n    function (modules) {\n      // webpackBootstrap\n\n      /******/\n      // The module cache\n\n      /******/\n      var installedModules = {};\n      /******/\n\n      /******/\n      // The require function\n\n      /******/\n\n      function __webpack_require__(moduleId) {\n        /******/\n\n        /******/\n        // Check if module is in cache\n\n        /******/\n        if (installedModules[moduleId]) {\n          /******/\n          return installedModules[moduleId].exports;\n          /******/\n        }\n        /******/\n        // Create a new module (and put it into the cache)\n\n        /******/\n\n\n        var module = installedModules[moduleId] = {\n          /******/\n          i: moduleId,\n\n          /******/\n          l: false,\n\n          /******/\n          exports: {}\n          /******/\n\n        };\n        /******/\n\n        /******/\n        // Execute the module function\n\n        /******/\n\n        modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n        /******/\n\n        /******/\n        // Flag the module as loaded\n\n        /******/\n\n        module.l = true;\n        /******/\n\n        /******/\n        // Return the exports of the module\n\n        /******/\n\n        return module.exports;\n        /******/\n      }\n      /******/\n\n      /******/\n\n      /******/\n      // expose the modules object (__webpack_modules__)\n\n      /******/\n\n\n      __webpack_require__.m = modules;\n      /******/\n\n      /******/\n      // expose the module cache\n\n      /******/\n\n      __webpack_require__.c = installedModules;\n      /******/\n\n      /******/\n      // define getter function for harmony exports\n\n      /******/\n\n      __webpack_require__.d = function (exports, name, getter) {\n        /******/\n        if (!__webpack_require__.o(exports, name)) {\n          /******/\n          Object.defineProperty(exports, name, {\n            enumerable: true,\n            get: getter\n          });\n          /******/\n        }\n        /******/\n\n      };\n      /******/\n\n      /******/\n      // define __esModule on exports\n\n      /******/\n\n\n      __webpack_require__.r = function (exports) {\n        /******/\n        if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n          /******/\n          Object.defineProperty(exports, Symbol.toStringTag, {\n            value: 'Module'\n          });\n          /******/\n        }\n        /******/\n\n\n        Object.defineProperty(exports, '__esModule', {\n          value: true\n        });\n        /******/\n      };\n      /******/\n\n      /******/\n      // create a fake namespace object\n\n      /******/\n      // mode & 1: value is a module id, require it\n\n      /******/\n      // mode & 2: merge all properties of value into the ns\n\n      /******/\n      // mode & 4: return value when already ns object\n\n      /******/\n      // mode & 8|1: behave like require\n\n      /******/\n\n\n      __webpack_require__.t = function (value, mode) {\n        /******/\n        if (mode & 1) value = __webpack_require__(value);\n        /******/\n\n        if (mode & 8) return value;\n        /******/\n\n        if (mode & 4 && _typeof(value) === 'object' && value && value.__esModule) return value;\n        /******/\n\n        var ns = Object.create(null);\n        /******/\n\n        __webpack_require__.r(ns);\n        /******/\n\n\n        Object.defineProperty(ns, 'default', {\n          enumerable: true,\n          value: value\n        });\n        /******/\n\n        if (mode & 2 && typeof value != 'string') for (var key in value) {\n          __webpack_require__.d(ns, key, function (key) {\n            return value[key];\n          }.bind(null, key));\n        }\n        /******/\n\n        return ns;\n        /******/\n      };\n      /******/\n\n      /******/\n      // getDefaultExport function for compatibility with non-harmony modules\n\n      /******/\n\n\n      __webpack_require__.n = function (module) {\n        /******/\n        var getter = module && module.__esModule ?\n        /******/\n        function getDefault() {\n          return module['default'];\n        } :\n        /******/\n        function getModuleExports() {\n          return module;\n        };\n        /******/\n\n        __webpack_require__.d(getter, 'a', getter);\n        /******/\n\n\n        return getter;\n        /******/\n      };\n      /******/\n\n      /******/\n      // Object.prototype.hasOwnProperty.call\n\n      /******/\n\n\n      __webpack_require__.o = function (object, property) {\n        return Object.prototype.hasOwnProperty.call(object, property);\n      };\n      /******/\n\n      /******/\n      // __webpack_public_path__\n\n      /******/\n\n\n      __webpack_require__.p = \"\";\n      /******/\n\n      /******/\n\n      /******/\n      // Load entry module and return exports\n\n      /******/\n\n      return __webpack_require__(__webpack_require__.s = 5);\n      /******/\n    }([\n      /* 0 */\n\n      /***/\n\n      /* 1 */\n\n      /***/\n\n      /* 2 */\n\n      /***/\n\n      /* 3 */\n\n      /***/\n\n      /* 4 */\n\n      /***/\n\n      /* 5 */\n\n      /***/\n\n      /******/\n    function (module, exports) {\n      var g; // This works in non-strict mode\n\n      g = function () {\n        return this;\n      }();\n\n      try {\n        // This works if eval is allowed (see CSP)\n        g = g || new Function(\"return this\")();\n      } catch (e) {\n        // This works if the window reference is available\n        if ((typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) === \"object\") g = window;\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\n\n      module.exports = g;\n      /***/\n    }, function (module, __webpack_exports__, __webpack_require__) {\n      \"use strict\";\n      /* WEBPACK VAR INJECTION */\n\n      (function (global, setImmediate) {\n        /*! @vimeo/player v2.10.0 | (c) 2019 Vimeo | MIT License | https://github.com/vimeo/player.js */\n        function _classCallCheck(instance, Constructor) {\n          if (!(instance instanceof Constructor)) {\n            throw new TypeError(\"Cannot call a class as a function\");\n          }\n        }\n\n        function _defineProperties(target, props) {\n          for (var i = 0; i < props.length; i++) {\n            var descriptor = props[i];\n            descriptor.enumerable = descriptor.enumerable || false;\n            descriptor.configurable = true;\n            if (\"value\" in descriptor) descriptor.writable = true;\n            Object.defineProperty(target, descriptor.key, descriptor);\n          }\n        }\n\n        function _createClass(Constructor, protoProps, staticProps) {\n          if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n          if (staticProps) _defineProperties(Constructor, staticProps);\n          return Constructor;\n        }\n        /**\n         * @module lib/functions\n         */\n\n        /**\n         * Check to see this is a node environment.\n         * @type {Boolean}\n         */\n\n        /* global global */\n\n\n        var isNode = typeof global !== 'undefined' && {}.toString.call(global) === '[object global]';\n        /**\n         * Get the name of the method for a given getter or setter.\n         *\n         * @param {string} prop The name of the property.\n         * @param {string} type Either “get” or “set”.\n         * @return {string}\n         */\n\n        function getMethodName(prop, type) {\n          if (prop.indexOf(type.toLowerCase()) === 0) {\n            return prop;\n          }\n\n          return \"\".concat(type.toLowerCase()).concat(prop.substr(0, 1).toUpperCase()).concat(prop.substr(1));\n        }\n        /**\n         * Check to see if the object is a DOM Element.\n         *\n         * @param {*} element The object to check.\n         * @return {boolean}\n         */\n\n\n        function isDomElement(element) {\n          return Boolean(element && element.nodeType === 1 && 'nodeName' in element && element.ownerDocument && element.ownerDocument.defaultView);\n        }\n        /**\n         * Check to see whether the value is a number.\n         *\n         * @see http://dl.dropboxusercontent.com/u/35146/js/tests/isNumber.html\n         * @param {*} value The value to check.\n         * @param {boolean} integer Check if the value is an integer.\n         * @return {boolean}\n         */\n\n\n        function isInteger(value) {\n          // eslint-disable-next-line eqeqeq\n          return !isNaN(parseFloat(value)) && isFinite(value) && Math.floor(value) == value;\n        }\n        /**\n         * Check to see if the URL is a Vimeo url.\n         *\n         * @param {string} url The url string.\n         * @return {boolean}\n         */\n\n\n        function isVimeoUrl(url) {\n          return /^(https?:)?\\/\\/((player|www)\\.)?vimeo\\.com(?=$|\\/)/.test(url);\n        }\n        /**\n         * Get the Vimeo URL from an element.\n         * The element must have either a data-vimeo-id or data-vimeo-url attribute.\n         *\n         * @param {object} oEmbedParameters The oEmbed parameters.\n         * @return {string}\n         */\n\n\n        function getVimeoUrl() {\n          var oEmbedParameters = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n          var id = oEmbedParameters.id;\n          var url = oEmbedParameters.url;\n          var idOrUrl = id || url;\n\n          if (!idOrUrl) {\n            throw new Error('An id or url must be passed, either in an options object or as a data-vimeo-id or data-vimeo-url attribute.');\n          }\n\n          if (isInteger(idOrUrl)) {\n            return \"https://vimeo.com/\".concat(idOrUrl);\n          }\n\n          if (isVimeoUrl(idOrUrl)) {\n            return idOrUrl.replace('http:', 'https:');\n          }\n\n          if (id) {\n            throw new TypeError(\"\\u201C\".concat(id, \"\\u201D is not a valid video id.\"));\n          }\n\n          throw new TypeError(\"\\u201C\".concat(idOrUrl, \"\\u201D is not a vimeo.com url.\"));\n        }\n\n        var arrayIndexOfSupport = typeof Array.prototype.indexOf !== 'undefined';\n        var postMessageSupport = typeof window !== 'undefined' && typeof window.postMessage !== 'undefined';\n\n        if (!isNode && (!arrayIndexOfSupport || !postMessageSupport)) {\n          throw new Error('Sorry, the Vimeo Player API is not available in this browser.');\n        }\n\n        var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};\n\n        function createCommonjsModule(fn, module) {\n          return module = {\n            exports: {}\n          }, fn(module, module.exports), module.exports;\n        }\n        /*!\n         * weakmap-polyfill v2.0.0 - ECMAScript6 WeakMap polyfill\n         * https://github.com/polygonplanet/weakmap-polyfill\n         * Copyright (c) 2015-2016 polygon planet <polygon.planet.aqua@gmail.com>\n         * @license MIT\n         */\n\n\n        (function (self) {\n          if (self.WeakMap) {\n            return;\n          }\n\n          var hasOwnProperty = Object.prototype.hasOwnProperty;\n\n          var defineProperty = function defineProperty(object, name, value) {\n            if (Object.defineProperty) {\n              Object.defineProperty(object, name, {\n                configurable: true,\n                writable: true,\n                value: value\n              });\n            } else {\n              object[name] = value;\n            }\n          };\n\n          self.WeakMap = function () {\n            // ECMA-262 23.3 WeakMap Objects\n            function WeakMap() {\n              if (this === void 0) {\n                throw new TypeError(\"Constructor WeakMap requires 'new'\");\n              }\n\n              defineProperty(this, '_id', genId('_WeakMap')); // ECMA-262 23.3.1.1 WeakMap([iterable])\n\n              if (arguments.length > 0) {\n                // Currently, WeakMap `iterable` argument is not supported\n                throw new TypeError('WeakMap iterable is not supported');\n              }\n            } // ECMA-262 23.3.3.2 WeakMap.prototype.delete(key)\n\n\n            defineProperty(WeakMap.prototype, 'delete', function (key) {\n              checkInstance(this, 'delete');\n\n              if (!isObject(key)) {\n                return false;\n              }\n\n              var entry = key[this._id];\n\n              if (entry && entry[0] === key) {\n                delete key[this._id];\n                return true;\n              }\n\n              return false;\n            }); // ECMA-262 23.3.3.3 WeakMap.prototype.get(key)\n\n            defineProperty(WeakMap.prototype, 'get', function (key) {\n              checkInstance(this, 'get');\n\n              if (!isObject(key)) {\n                return void 0;\n              }\n\n              var entry = key[this._id];\n\n              if (entry && entry[0] === key) {\n                return entry[1];\n              }\n\n              return void 0;\n            }); // ECMA-262 23.3.3.4 WeakMap.prototype.has(key)\n\n            defineProperty(WeakMap.prototype, 'has', function (key) {\n              checkInstance(this, 'has');\n\n              if (!isObject(key)) {\n                return false;\n              }\n\n              var entry = key[this._id];\n\n              if (entry && entry[0] === key) {\n                return true;\n              }\n\n              return false;\n            }); // ECMA-262 23.3.3.5 WeakMap.prototype.set(key, value)\n\n            defineProperty(WeakMap.prototype, 'set', function (key, value) {\n              checkInstance(this, 'set');\n\n              if (!isObject(key)) {\n                throw new TypeError('Invalid value used as weak map key');\n              }\n\n              var entry = key[this._id];\n\n              if (entry && entry[0] === key) {\n                entry[1] = value;\n                return this;\n              }\n\n              defineProperty(key, this._id, [key, value]);\n              return this;\n            });\n\n            function checkInstance(x, methodName) {\n              if (!isObject(x) || !hasOwnProperty.call(x, '_id')) {\n                throw new TypeError(methodName + ' method called on incompatible receiver ' + _typeof(x));\n              }\n            }\n\n            function genId(prefix) {\n              return prefix + '_' + rand() + '.' + rand();\n            }\n\n            function rand() {\n              return Math.random().toString().substring(2);\n            }\n\n            defineProperty(WeakMap, '_polyfill', true);\n            return WeakMap;\n          }();\n\n          function isObject(x) {\n            return Object(x) === x;\n          }\n        })(typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : typeof commonjsGlobal !== 'undefined' ? commonjsGlobal : commonjsGlobal);\n\n        var npo_src = createCommonjsModule(function (module) {\n          /*! Native Promise Only\n              v0.8.1 (c) Kyle Simpson\n              MIT License: http://getify.mit-license.org\n          */\n          (function UMD(name, context, definition) {\n            // special form of UMD for polyfilling across evironments\n            context[name] = context[name] || definition();\n\n            if (module.exports) {\n              module.exports = context[name];\n            }\n          })(\"Promise\", typeof commonjsGlobal != \"undefined\" ? commonjsGlobal : commonjsGlobal, function DEF() {\n            var builtInProp,\n                cycle,\n                scheduling_queue,\n                ToString = Object.prototype.toString,\n                timer = typeof setImmediate != \"undefined\" ? function timer(fn) {\n              return setImmediate(fn);\n            } : setTimeout; // dammit, IE8.\n\n            try {\n              Object.defineProperty({}, \"x\", {});\n\n              builtInProp = function builtInProp(obj, name, val, config) {\n                return Object.defineProperty(obj, name, {\n                  value: val,\n                  writable: true,\n                  configurable: config !== false\n                });\n              };\n            } catch (err) {\n              builtInProp = function builtInProp(obj, name, val) {\n                obj[name] = val;\n                return obj;\n              };\n            } // Note: using a queue instead of array for efficiency\n\n\n            scheduling_queue = function Queue() {\n              var first, last, item;\n\n              function Item(fn, self) {\n                this.fn = fn;\n                this.self = self;\n                this.next = void 0;\n              }\n\n              return {\n                add: function add(fn, self) {\n                  item = new Item(fn, self);\n\n                  if (last) {\n                    last.next = item;\n                  } else {\n                    first = item;\n                  }\n\n                  last = item;\n                  item = void 0;\n                },\n                drain: function drain() {\n                  var f = first;\n                  first = last = cycle = void 0;\n\n                  while (f) {\n                    f.fn.call(f.self);\n                    f = f.next;\n                  }\n                }\n              };\n            }();\n\n            function schedule(fn, self) {\n              scheduling_queue.add(fn, self);\n\n              if (!cycle) {\n                cycle = timer(scheduling_queue.drain);\n              }\n            } // promise duck typing\n\n\n            function isThenable(o) {\n              var _then,\n                  o_type = _typeof(o);\n\n              if (o != null && (o_type == \"object\" || o_type == \"function\")) {\n                _then = o.then;\n              }\n\n              return typeof _then == \"function\" ? _then : false;\n            }\n\n            function notify() {\n              for (var i = 0; i < this.chain.length; i++) {\n                notifyIsolated(this, this.state === 1 ? this.chain[i].success : this.chain[i].failure, this.chain[i]);\n              }\n\n              this.chain.length = 0;\n            } // NOTE: This is a separate function to isolate\n            // the `try..catch` so that other code can be\n            // optimized better\n\n\n            function notifyIsolated(self, cb, chain) {\n              var ret, _then;\n\n              try {\n                if (cb === false) {\n                  chain.reject(self.msg);\n                } else {\n                  if (cb === true) {\n                    ret = self.msg;\n                  } else {\n                    ret = cb.call(void 0, self.msg);\n                  }\n\n                  if (ret === chain.promise) {\n                    chain.reject(TypeError(\"Promise-chain cycle\"));\n                  } else if (_then = isThenable(ret)) {\n                    _then.call(ret, chain.resolve, chain.reject);\n                  } else {\n                    chain.resolve(ret);\n                  }\n                }\n              } catch (err) {\n                chain.reject(err);\n              }\n            }\n\n            function resolve(msg) {\n              var _then,\n                  self = this; // already triggered?\n\n\n              if (self.triggered) {\n                return;\n              }\n\n              self.triggered = true; // unwrap\n\n              if (self.def) {\n                self = self.def;\n              }\n\n              try {\n                if (_then = isThenable(msg)) {\n                  schedule(function () {\n                    var def_wrapper = new MakeDefWrapper(self);\n\n                    try {\n                      _then.call(msg, function $resolve$() {\n                        resolve.apply(def_wrapper, arguments);\n                      }, function $reject$() {\n                        reject.apply(def_wrapper, arguments);\n                      });\n                    } catch (err) {\n                      reject.call(def_wrapper, err);\n                    }\n                  });\n                } else {\n                  self.msg = msg;\n                  self.state = 1;\n\n                  if (self.chain.length > 0) {\n                    schedule(notify, self);\n                  }\n                }\n              } catch (err) {\n                reject.call(new MakeDefWrapper(self), err);\n              }\n            }\n\n            function reject(msg) {\n              var self = this; // already triggered?\n\n              if (self.triggered) {\n                return;\n              }\n\n              self.triggered = true; // unwrap\n\n              if (self.def) {\n                self = self.def;\n              }\n\n              self.msg = msg;\n              self.state = 2;\n\n              if (self.chain.length > 0) {\n                schedule(notify, self);\n              }\n            }\n\n            function iteratePromises(Constructor, arr, resolver, rejecter) {\n              for (var idx = 0; idx < arr.length; idx++) {\n                (function IIFE(idx) {\n                  Constructor.resolve(arr[idx]).then(function $resolver$(msg) {\n                    resolver(idx, msg);\n                  }, rejecter);\n                })(idx);\n              }\n            }\n\n            function MakeDefWrapper(self) {\n              this.def = self;\n              this.triggered = false;\n            }\n\n            function MakeDef(self) {\n              this.promise = self;\n              this.state = 0;\n              this.triggered = false;\n              this.chain = [];\n              this.msg = void 0;\n            }\n\n            function Promise(executor) {\n              if (typeof executor != \"function\") {\n                throw TypeError(\"Not a function\");\n              }\n\n              if (this.__NPO__ !== 0) {\n                throw TypeError(\"Not a promise\");\n              } // instance shadowing the inherited \"brand\"\n              // to signal an already \"initialized\" promise\n\n\n              this.__NPO__ = 1;\n              var def = new MakeDef(this);\n\n              this[\"then\"] = function then(success, failure) {\n                var o = {\n                  success: typeof success == \"function\" ? success : true,\n                  failure: typeof failure == \"function\" ? failure : false\n                }; // Note: `then(..)` itself can be borrowed to be used against\n                // a different promise constructor for making the chained promise,\n                // by substituting a different `this` binding.\n\n                o.promise = new this.constructor(function extractChain(resolve, reject) {\n                  if (typeof resolve != \"function\" || typeof reject != \"function\") {\n                    throw TypeError(\"Not a function\");\n                  }\n\n                  o.resolve = resolve;\n                  o.reject = reject;\n                });\n                def.chain.push(o);\n\n                if (def.state !== 0) {\n                  schedule(notify, def);\n                }\n\n                return o.promise;\n              };\n\n              this[\"catch\"] = function $catch$(failure) {\n                return this.then(void 0, failure);\n              };\n\n              try {\n                executor.call(void 0, function publicResolve(msg) {\n                  resolve.call(def, msg);\n                }, function publicReject(msg) {\n                  reject.call(def, msg);\n                });\n              } catch (err) {\n                reject.call(def, err);\n              }\n            }\n\n            var PromisePrototype = builtInProp({}, \"constructor\", Promise,\n            /*configurable=*/\n            false); // Note: Android 4 cannot use `Object.defineProperty(..)` here\n\n            Promise.prototype = PromisePrototype; // built-in \"brand\" to signal an \"uninitialized\" promise\n\n            builtInProp(PromisePrototype, \"__NPO__\", 0,\n            /*configurable=*/\n            false);\n            builtInProp(Promise, \"resolve\", function Promise$resolve(msg) {\n              var Constructor = this; // spec mandated checks\n              // note: best \"isPromise\" check that's practical for now\n\n              if (msg && _typeof(msg) == \"object\" && msg.__NPO__ === 1) {\n                return msg;\n              }\n\n              return new Constructor(function executor(resolve, reject) {\n                if (typeof resolve != \"function\" || typeof reject != \"function\") {\n                  throw TypeError(\"Not a function\");\n                }\n\n                resolve(msg);\n              });\n            });\n            builtInProp(Promise, \"reject\", function Promise$reject(msg) {\n              return new this(function executor(resolve, reject) {\n                if (typeof resolve != \"function\" || typeof reject != \"function\") {\n                  throw TypeError(\"Not a function\");\n                }\n\n                reject(msg);\n              });\n            });\n            builtInProp(Promise, \"all\", function Promise$all(arr) {\n              var Constructor = this; // spec mandated checks\n\n              if (ToString.call(arr) != \"[object Array]\") {\n                return Constructor.reject(TypeError(\"Not an array\"));\n              }\n\n              if (arr.length === 0) {\n                return Constructor.resolve([]);\n              }\n\n              return new Constructor(function executor(resolve, reject) {\n                if (typeof resolve != \"function\" || typeof reject != \"function\") {\n                  throw TypeError(\"Not a function\");\n                }\n\n                var len = arr.length,\n                    msgs = Array(len),\n                    count = 0;\n                iteratePromises(Constructor, arr, function resolver(idx, msg) {\n                  msgs[idx] = msg;\n\n                  if (++count === len) {\n                    resolve(msgs);\n                  }\n                }, reject);\n              });\n            });\n            builtInProp(Promise, \"race\", function Promise$race(arr) {\n              var Constructor = this; // spec mandated checks\n\n              if (ToString.call(arr) != \"[object Array]\") {\n                return Constructor.reject(TypeError(\"Not an array\"));\n              }\n\n              return new Constructor(function executor(resolve, reject) {\n                if (typeof resolve != \"function\" || typeof reject != \"function\") {\n                  throw TypeError(\"Not a function\");\n                }\n\n                iteratePromises(Constructor, arr, function resolver(idx, msg) {\n                  resolve(msg);\n                }, reject);\n              });\n            });\n            return Promise;\n          });\n        });\n        /**\n         * @module lib/callbacks\n         */\n\n        var callbackMap = new WeakMap();\n        /**\n         * Store a callback for a method or event for a player.\n         *\n         * @param {Player} player The player object.\n         * @param {string} name The method or event name.\n         * @param {(function(this:Player, *): void|{resolve: function, reject: function})} callback\n         *        The callback to call or an object with resolve and reject functions for a promise.\n         * @return {void}\n         */\n\n        function storeCallback(player, name, callback) {\n          var playerCallbacks = callbackMap.get(player.element) || {};\n\n          if (!(name in playerCallbacks)) {\n            playerCallbacks[name] = [];\n          }\n\n          playerCallbacks[name].push(callback);\n          callbackMap.set(player.element, playerCallbacks);\n        }\n        /**\n         * Get the callbacks for a player and event or method.\n         *\n         * @param {Player} player The player object.\n         * @param {string} name The method or event name\n         * @return {function[]}\n         */\n\n\n        function getCallbacks(player, name) {\n          var playerCallbacks = callbackMap.get(player.element) || {};\n          return playerCallbacks[name] || [];\n        }\n        /**\n         * Remove a stored callback for a method or event for a player.\n         *\n         * @param {Player} player The player object.\n         * @param {string} name The method or event name\n         * @param {function} [callback] The specific callback to remove.\n         * @return {boolean} Was this the last callback?\n         */\n\n\n        function removeCallback(player, name, callback) {\n          var playerCallbacks = callbackMap.get(player.element) || {};\n\n          if (!playerCallbacks[name]) {\n            return true;\n          } // If no callback is passed, remove all callbacks for the event\n\n\n          if (!callback) {\n            playerCallbacks[name] = [];\n            callbackMap.set(player.element, playerCallbacks);\n            return true;\n          }\n\n          var index = playerCallbacks[name].indexOf(callback);\n\n          if (index !== -1) {\n            playerCallbacks[name].splice(index, 1);\n          }\n\n          callbackMap.set(player.element, playerCallbacks);\n          return playerCallbacks[name] && playerCallbacks[name].length === 0;\n        }\n        /**\n         * Return the first stored callback for a player and event or method.\n         *\n         * @param {Player} player The player object.\n         * @param {string} name The method or event name.\n         * @return {function} The callback, or false if there were none\n         */\n\n\n        function shiftCallbacks(player, name) {\n          var playerCallbacks = getCallbacks(player, name);\n\n          if (playerCallbacks.length < 1) {\n            return false;\n          }\n\n          var callback = playerCallbacks.shift();\n          removeCallback(player, name, callback);\n          return callback;\n        }\n        /**\n         * Move callbacks associated with an element to another element.\n         *\n         * @param {HTMLElement} oldElement The old element.\n         * @param {HTMLElement} newElement The new element.\n         * @return {void}\n         */\n\n\n        function swapCallbacks(oldElement, newElement) {\n          var playerCallbacks = callbackMap.get(oldElement);\n          callbackMap.set(newElement, playerCallbacks);\n          callbackMap.delete(oldElement);\n        }\n        /**\n         * @module lib/embed\n         */\n\n\n        var oEmbedParameters = ['autopause', 'autoplay', 'background', 'byline', 'color', 'controls', 'dnt', 'height', 'id', 'loop', 'maxheight', 'maxwidth', 'muted', 'playsinline', 'portrait', 'responsive', 'speed', 'texttrack', 'title', 'transparent', 'url', 'width'];\n        /**\n         * Get the 'data-vimeo'-prefixed attributes from an element as an object.\n         *\n         * @param {HTMLElement} element The element.\n         * @param {Object} [defaults={}] The default values to use.\n         * @return {Object<string, string>}\n         */\n\n        function getOEmbedParameters(element) {\n          var defaults = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n          return oEmbedParameters.reduce(function (params, param) {\n            var value = element.getAttribute(\"data-vimeo-\".concat(param));\n\n            if (value || value === '') {\n              params[param] = value === '' ? 1 : value;\n            }\n\n            return params;\n          }, defaults);\n        }\n        /**\n         * Create an embed from oEmbed data inside an element.\n         *\n         * @param {object} data The oEmbed data.\n         * @param {HTMLElement} element The element to put the iframe in.\n         * @return {HTMLIFrameElement} The iframe embed.\n         */\n\n\n        function createEmbed(_ref, element) {\n          var html = _ref.html;\n\n          if (!element) {\n            throw new TypeError('An element must be provided');\n          }\n\n          if (element.getAttribute('data-vimeo-initialized') !== null) {\n            return element.querySelector('iframe');\n          }\n\n          var div = document.createElement('div');\n          div.innerHTML = html;\n          element.appendChild(div.firstChild);\n          element.setAttribute('data-vimeo-initialized', 'true');\n          return element.querySelector('iframe');\n        }\n        /**\n         * Make an oEmbed call for the specified URL.\n         *\n         * @param {string} videoUrl The vimeo.com url for the video.\n         * @param {Object} [params] Parameters to pass to oEmbed.\n         * @param {HTMLElement} element The element.\n         * @return {Promise}\n         */\n\n\n        function getOEmbedData(videoUrl) {\n          var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n          var element = arguments.length > 2 ? arguments[2] : undefined;\n          return new Promise(function (resolve, reject) {\n            if (!isVimeoUrl(videoUrl)) {\n              throw new TypeError(\"\\u201C\".concat(videoUrl, \"\\u201D is not a vimeo.com url.\"));\n            }\n\n            var url = \"https://vimeo.com/api/oembed.json?url=\".concat(encodeURIComponent(videoUrl));\n\n            for (var param in params) {\n              if (params.hasOwnProperty(param)) {\n                url += \"&\".concat(param, \"=\").concat(encodeURIComponent(params[param]));\n              }\n            }\n\n            var xhr = 'XDomainRequest' in window ? new XDomainRequest() : new XMLHttpRequest();\n            xhr.open('GET', url, true);\n\n            xhr.onload = function () {\n              if (xhr.status === 404) {\n                reject(new Error(\"\\u201C\".concat(videoUrl, \"\\u201D was not found.\")));\n                return;\n              }\n\n              if (xhr.status === 403) {\n                reject(new Error(\"\\u201C\".concat(videoUrl, \"\\u201D is not embeddable.\")));\n                return;\n              }\n\n              try {\n                var json = JSON.parse(xhr.responseText); // Check api response for 403 on oembed\n\n                if (json.domain_status_code === 403) {\n                  // We still want to create the embed to give users visual feedback\n                  createEmbed(json, element);\n                  reject(new Error(\"\\u201C\".concat(videoUrl, \"\\u201D is not embeddable.\")));\n                  return;\n                }\n\n                resolve(json);\n              } catch (error) {\n                reject(error);\n              }\n            };\n\n            xhr.onerror = function () {\n              var status = xhr.status ? \" (\".concat(xhr.status, \")\") : '';\n              reject(new Error(\"There was an error fetching the embed code from Vimeo\".concat(status, \".\")));\n            };\n\n            xhr.send();\n          });\n        }\n        /**\n         * Initialize all embeds within a specific element\n         *\n         * @param {HTMLElement} [parent=document] The parent element.\n         * @return {void}\n         */\n\n\n        function initializeEmbeds() {\n          var parent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document;\n          var elements = [].slice.call(parent.querySelectorAll('[data-vimeo-id], [data-vimeo-url]'));\n\n          var handleError = function handleError(error) {\n            if ('console' in window && console.error) {\n              console.error(\"There was an error creating an embed: \".concat(error));\n            }\n          };\n\n          elements.forEach(function (element) {\n            try {\n              // Skip any that have data-vimeo-defer\n              if (element.getAttribute('data-vimeo-defer') !== null) {\n                return;\n              }\n\n              var params = getOEmbedParameters(element);\n              var url = getVimeoUrl(params);\n              getOEmbedData(url, params, element).then(function (data) {\n                return createEmbed(data, element);\n              }).catch(handleError);\n            } catch (error) {\n              handleError(error);\n            }\n          });\n        }\n        /**\n         * Resize embeds when messaged by the player.\n         *\n         * @param {HTMLElement} [parent=document] The parent element.\n         * @return {void}\n         */\n\n\n        function resizeEmbeds() {\n          var parent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document; // Prevent execution if users include the player.js script multiple times.\n\n          if (window.VimeoPlayerResizeEmbeds_) {\n            return;\n          }\n\n          window.VimeoPlayerResizeEmbeds_ = true;\n\n          var onMessage = function onMessage(event) {\n            if (!isVimeoUrl(event.origin)) {\n              return;\n            } // 'spacechange' is fired only on embeds with cards\n\n\n            if (!event.data || event.data.event !== 'spacechange') {\n              return;\n            }\n\n            var iframes = parent.querySelectorAll('iframe');\n\n            for (var i = 0; i < iframes.length; i++) {\n              if (iframes[i].contentWindow !== event.source) {\n                continue;\n              } // Change padding-bottom of the enclosing div to accommodate\n              // card carousel without distorting aspect ratio\n\n\n              var space = iframes[i].parentElement;\n              space.style.paddingBottom = \"\".concat(event.data.data[0].bottom, \"px\");\n              break;\n            }\n          };\n\n          if (window.addEventListener) {\n            window.addEventListener('message', onMessage, false);\n          } else if (window.attachEvent) {\n            window.attachEvent('onmessage', onMessage);\n          }\n        }\n        /**\n         * @module lib/postmessage\n         */\n\n        /**\n         * Parse a message received from postMessage.\n         *\n         * @param {*} data The data received from postMessage.\n         * @return {object}\n         */\n\n\n        function parseMessageData(data) {\n          if (typeof data === 'string') {\n            try {\n              data = JSON.parse(data);\n            } catch (error) {\n              // If the message cannot be parsed, throw the error as a warning\n              console.warn(error);\n              return {};\n            }\n          }\n\n          return data;\n        }\n        /**\n         * Post a message to the specified target.\n         *\n         * @param {Player} player The player object to use.\n         * @param {string} method The API method to call.\n         * @param {object} params The parameters to send to the player.\n         * @return {void}\n         */\n\n\n        function postMessage(player, method, params) {\n          if (!player.element.contentWindow || !player.element.contentWindow.postMessage) {\n            return;\n          }\n\n          var message = {\n            method: method\n          };\n\n          if (params !== undefined) {\n            message.value = params;\n          } // IE 8 and 9 do not support passing messages, so stringify them\n\n\n          var ieVersion = parseFloat(navigator.userAgent.toLowerCase().replace(/^.*msie (\\d+).*$/, '$1'));\n\n          if (ieVersion >= 8 && ieVersion < 10) {\n            message = JSON.stringify(message);\n          }\n\n          player.element.contentWindow.postMessage(message, player.origin);\n        }\n        /**\n         * Parse the data received from a message event.\n         *\n         * @param {Player} player The player that received the message.\n         * @param {(Object|string)} data The message data. Strings will be parsed into JSON.\n         * @return {void}\n         */\n\n\n        function processData(player, data) {\n          data = parseMessageData(data);\n          var callbacks = [];\n          var param;\n\n          if (data.event) {\n            if (data.event === 'error') {\n              var promises = getCallbacks(player, data.data.method);\n              promises.forEach(function (promise) {\n                var error = new Error(data.data.message);\n                error.name = data.data.name;\n                promise.reject(error);\n                removeCallback(player, data.data.method, promise);\n              });\n            }\n\n            callbacks = getCallbacks(player, \"event:\".concat(data.event));\n            param = data.data;\n          } else if (data.method) {\n            var callback = shiftCallbacks(player, data.method);\n\n            if (callback) {\n              callbacks.push(callback);\n              param = data.value;\n            }\n          }\n\n          callbacks.forEach(function (callback) {\n            try {\n              if (typeof callback === 'function') {\n                callback.call(player, param);\n                return;\n              }\n\n              callback.resolve(param);\n            } catch (e) {// empty\n            }\n          });\n        }\n\n        var playerMap = new WeakMap();\n        var readyMap = new WeakMap();\n\n        var Player = /*#__PURE__*/function () {\n          /**\n           * Create a Player.\n           *\n           * @param {(HTMLIFrameElement|HTMLElement|string|jQuery)} element A reference to the Vimeo\n           *        player iframe, and id, or a jQuery object.\n           * @param {object} [options] oEmbed parameters to use when creating an embed in the element.\n           * @return {Player}\n           */\n          function Player(element) {\n            var _this = this;\n\n            var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n            _classCallCheck(this, Player);\n            /* global jQuery */\n\n\n            if (window.jQuery && element instanceof jQuery) {\n              if (element.length > 1 && window.console && console.warn) {\n                console.warn('A jQuery object with multiple elements was passed, using the first element.');\n              }\n\n              element = element[0];\n            } // Find an element by ID\n\n\n            if (typeof document !== 'undefined' && typeof element === 'string') {\n              element = document.getElementById(element);\n            } // Not an element!\n\n\n            if (!isDomElement(element)) {\n              throw new TypeError('You must pass either a valid element or a valid id.');\n            }\n\n            var win = element.ownerDocument.defaultView; // Already initialized an embed in this div, so grab the iframe\n\n            if (element.nodeName !== 'IFRAME') {\n              var iframe = element.querySelector('iframe');\n\n              if (iframe) {\n                element = iframe;\n              }\n            } // iframe url is not a Vimeo url\n\n\n            if (element.nodeName === 'IFRAME' && !isVimeoUrl(element.getAttribute('src') || '')) {\n              throw new Error('The player element passed isn’t a Vimeo embed.');\n            } // If there is already a player object in the map, return that\n\n\n            if (playerMap.has(element)) {\n              return playerMap.get(element);\n            }\n\n            this.element = element;\n            this.origin = '*';\n            var readyPromise = new npo_src(function (resolve, reject) {\n              var onMessage = function onMessage(event) {\n                if (!isVimeoUrl(event.origin) || _this.element.contentWindow !== event.source) {\n                  return;\n                }\n\n                if (_this.origin === '*') {\n                  _this.origin = event.origin;\n                }\n\n                var data = parseMessageData(event.data);\n                var isError = data && data.event === 'error';\n                var isReadyError = isError && data.data && data.data.method === 'ready';\n\n                if (isReadyError) {\n                  var error = new Error(data.data.message);\n                  error.name = data.data.name;\n                  reject(error);\n                  return;\n                }\n\n                var isReadyEvent = data && data.event === 'ready';\n                var isPingResponse = data && data.method === 'ping';\n\n                if (isReadyEvent || isPingResponse) {\n                  _this.element.setAttribute('data-ready', 'true');\n\n                  resolve();\n                  return;\n                }\n\n                processData(_this, data);\n              };\n\n              if (win.addEventListener) {\n                win.addEventListener('message', onMessage, false);\n              } else if (win.attachEvent) {\n                win.attachEvent('onmessage', onMessage);\n              }\n\n              if (_this.element.nodeName !== 'IFRAME') {\n                var params = getOEmbedParameters(element, options);\n                var url = getVimeoUrl(params);\n                getOEmbedData(url, params, element).then(function (data) {\n                  var iframe = createEmbed(data, element); // Overwrite element with the new iframe,\n                  // but store reference to the original element\n\n                  _this.element = iframe;\n                  _this._originalElement = element;\n                  swapCallbacks(element, iframe);\n                  playerMap.set(_this.element, _this);\n                  return data;\n                }).catch(reject);\n              }\n            }); // Store a copy of this Player in the map\n\n            readyMap.set(this, readyPromise);\n            playerMap.set(this.element, this); // Send a ping to the iframe so the ready promise will be resolved if\n            // the player is already ready.\n\n            if (this.element.nodeName === 'IFRAME') {\n              postMessage(this, 'ping');\n            }\n\n            return this;\n          }\n          /**\n           * Get a promise for a method.\n           *\n           * @param {string} name The API method to call.\n           * @param {Object} [args={}] Arguments to send via postMessage.\n           * @return {Promise}\n           */\n\n\n          _createClass(Player, [{\n            key: \"callMethod\",\n            value: function callMethod(name) {\n              var _this2 = this;\n\n              var args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n              return new npo_src(function (resolve, reject) {\n                // We are storing the resolve/reject handlers to call later, so we\n                // can’t return here.\n                // eslint-disable-next-line promise/always-return\n                return _this2.ready().then(function () {\n                  storeCallback(_this2, name, {\n                    resolve: resolve,\n                    reject: reject\n                  });\n                  postMessage(_this2, name, args);\n                }).catch(reject);\n              });\n            }\n            /**\n             * Get a promise for the value of a player property.\n             *\n             * @param {string} name The property name\n             * @return {Promise}\n             */\n\n          }, {\n            key: \"get\",\n            value: function get(name) {\n              var _this3 = this;\n\n              return new npo_src(function (resolve, reject) {\n                name = getMethodName(name, 'get'); // We are storing the resolve/reject handlers to call later, so we\n                // can’t return here.\n                // eslint-disable-next-line promise/always-return\n\n                return _this3.ready().then(function () {\n                  storeCallback(_this3, name, {\n                    resolve: resolve,\n                    reject: reject\n                  });\n                  postMessage(_this3, name);\n                }).catch(reject);\n              });\n            }\n            /**\n             * Get a promise for setting the value of a player property.\n             *\n             * @param {string} name The API method to call.\n             * @param {mixed} value The value to set.\n             * @return {Promise}\n             */\n\n          }, {\n            key: \"set\",\n            value: function set(name, value) {\n              var _this4 = this;\n\n              return new npo_src(function (resolve, reject) {\n                name = getMethodName(name, 'set');\n\n                if (value === undefined || value === null) {\n                  throw new TypeError('There must be a value to set.');\n                } // We are storing the resolve/reject handlers to call later, so we\n                // can’t return here.\n                // eslint-disable-next-line promise/always-return\n\n\n                return _this4.ready().then(function () {\n                  storeCallback(_this4, name, {\n                    resolve: resolve,\n                    reject: reject\n                  });\n                  postMessage(_this4, name, value);\n                }).catch(reject);\n              });\n            }\n            /**\n             * Add an event listener for the specified event. Will call the\n             * callback with a single parameter, `data`, that contains the data for\n             * that event.\n             *\n             * @param {string} eventName The name of the event.\n             * @param {function(*)} callback The function to call when the event fires.\n             * @return {void}\n             */\n\n          }, {\n            key: \"on\",\n            value: function on(eventName, callback) {\n              if (!eventName) {\n                throw new TypeError('You must pass an event name.');\n              }\n\n              if (!callback) {\n                throw new TypeError('You must pass a callback function.');\n              }\n\n              if (typeof callback !== 'function') {\n                throw new TypeError('The callback must be a function.');\n              }\n\n              var callbacks = getCallbacks(this, \"event:\".concat(eventName));\n\n              if (callbacks.length === 0) {\n                this.callMethod('addEventListener', eventName).catch(function () {// Ignore the error. There will be an error event fired that\n                  // will trigger the error callback if they are listening.\n                });\n              }\n\n              storeCallback(this, \"event:\".concat(eventName), callback);\n            }\n            /**\n             * Remove an event listener for the specified event. Will remove all\n             * listeners for that event if a `callback` isn’t passed, or only that\n             * specific callback if it is passed.\n             *\n             * @param {string} eventName The name of the event.\n             * @param {function} [callback] The specific callback to remove.\n             * @return {void}\n             */\n\n          }, {\n            key: \"off\",\n            value: function off(eventName, callback) {\n              if (!eventName) {\n                throw new TypeError('You must pass an event name.');\n              }\n\n              if (callback && typeof callback !== 'function') {\n                throw new TypeError('The callback must be a function.');\n              }\n\n              var lastCallback = removeCallback(this, \"event:\".concat(eventName), callback); // If there are no callbacks left, remove the listener\n\n              if (lastCallback) {\n                this.callMethod('removeEventListener', eventName).catch(function (e) {// Ignore the error. There will be an error event fired that\n                  // will trigger the error callback if they are listening.\n                });\n              }\n            }\n            /**\n             * A promise to load a new video.\n             *\n             * @promise LoadVideoPromise\n             * @fulfill {number} The video with this id successfully loaded.\n             * @reject {TypeError} The id was not a number.\n             */\n\n            /**\n             * Load a new video into this embed. The promise will be resolved if\n             * the video is successfully loaded, or it will be rejected if it could\n             * not be loaded.\n             *\n             * @param {number|object} options The id of the video or an object with embed options.\n             * @return {LoadVideoPromise}\n             */\n\n          }, {\n            key: \"loadVideo\",\n            value: function loadVideo(options) {\n              return this.callMethod('loadVideo', options);\n            }\n            /**\n             * A promise to perform an action when the Player is ready.\n             *\n             * @todo document errors\n             * @promise LoadVideoPromise\n             * @fulfill {void}\n             */\n\n            /**\n             * Trigger a function when the player iframe has initialized. You do not\n             * need to wait for `ready` to trigger to begin adding event listeners\n             * or calling other methods.\n             *\n             * @return {ReadyPromise}\n             */\n\n          }, {\n            key: \"ready\",\n            value: function ready() {\n              var readyPromise = readyMap.get(this) || new npo_src(function (resolve, reject) {\n                reject(new Error('Unknown player. Probably unloaded.'));\n              });\n              return npo_src.resolve(readyPromise);\n            }\n            /**\n             * A promise to add a cue point to the player.\n             *\n             * @promise AddCuePointPromise\n             * @fulfill {string} The id of the cue point to use for removeCuePoint.\n             * @reject {RangeError} the time was less than 0 or greater than the\n             *         video’s duration.\n             * @reject {UnsupportedError} Cue points are not supported with the current\n             *         player or browser.\n             */\n\n            /**\n             * Add a cue point to the player.\n             *\n             * @param {number} time The time for the cue point.\n             * @param {object} [data] Arbitrary data to be returned with the cue point.\n             * @return {AddCuePointPromise}\n             */\n\n          }, {\n            key: \"addCuePoint\",\n            value: function addCuePoint(time) {\n              var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n              return this.callMethod('addCuePoint', {\n                time: time,\n                data: data\n              });\n            }\n            /**\n             * A promise to remove a cue point from the player.\n             *\n             * @promise AddCuePointPromise\n             * @fulfill {string} The id of the cue point that was removed.\n             * @reject {InvalidCuePoint} The cue point with the specified id was not\n             *         found.\n             * @reject {UnsupportedError} Cue points are not supported with the current\n             *         player or browser.\n             */\n\n            /**\n             * Remove a cue point from the video.\n             *\n             * @param {string} id The id of the cue point to remove.\n             * @return {RemoveCuePointPromise}\n             */\n\n          }, {\n            key: \"removeCuePoint\",\n            value: function removeCuePoint(id) {\n              return this.callMethod('removeCuePoint', id);\n            }\n            /**\n             * A representation of a text track on a video.\n             *\n             * @typedef {Object} VimeoTextTrack\n             * @property {string} language The ISO language code.\n             * @property {string} kind The kind of track it is (captions or subtitles).\n             * @property {string} label The human‐readable label for the track.\n             */\n\n            /**\n             * A promise to enable a text track.\n             *\n             * @promise EnableTextTrackPromise\n             * @fulfill {VimeoTextTrack} The text track that was enabled.\n             * @reject {InvalidTrackLanguageError} No track was available with the\n             *         specified language.\n             * @reject {InvalidTrackError} No track was available with the specified\n             *         language and kind.\n             */\n\n            /**\n             * Enable the text track with the specified language, and optionally the\n             * specified kind (captions or subtitles).\n             *\n             * When set via the API, the track language will not change the viewer’s\n             * stored preference.\n             *\n             * @param {string} language The two‐letter language code.\n             * @param {string} [kind] The kind of track to enable (captions or subtitles).\n             * @return {EnableTextTrackPromise}\n             */\n\n          }, {\n            key: \"enableTextTrack\",\n            value: function enableTextTrack(language, kind) {\n              if (!language) {\n                throw new TypeError('You must pass a language.');\n              }\n\n              return this.callMethod('enableTextTrack', {\n                language: language,\n                kind: kind\n              });\n            }\n            /**\n             * A promise to disable the active text track.\n             *\n             * @promise DisableTextTrackPromise\n             * @fulfill {void} The track was disabled.\n             */\n\n            /**\n             * Disable the currently-active text track.\n             *\n             * @return {DisableTextTrackPromise}\n             */\n\n          }, {\n            key: \"disableTextTrack\",\n            value: function disableTextTrack() {\n              return this.callMethod('disableTextTrack');\n            }\n            /**\n             * A promise to pause the video.\n             *\n             * @promise PausePromise\n             * @fulfill {void} The video was paused.\n             */\n\n            /**\n             * Pause the video if it’s playing.\n             *\n             * @return {PausePromise}\n             */\n\n          }, {\n            key: \"pause\",\n            value: function pause() {\n              return this.callMethod('pause');\n            }\n            /**\n             * A promise to play the video.\n             *\n             * @promise PlayPromise\n             * @fulfill {void} The video was played.\n             */\n\n            /**\n             * Play the video if it’s paused. **Note:** on iOS and some other\n             * mobile devices, you cannot programmatically trigger play. Once the\n             * viewer has tapped on the play button in the player, however, you\n             * will be able to use this function.\n             *\n             * @return {PlayPromise}\n             */\n\n          }, {\n            key: \"play\",\n            value: function play() {\n              return this.callMethod('play');\n            }\n            /**\n             * A promise to unload the video.\n             *\n             * @promise UnloadPromise\n             * @fulfill {void} The video was unloaded.\n             */\n\n            /**\n             * Return the player to its initial state.\n             *\n             * @return {UnloadPromise}\n             */\n\n          }, {\n            key: \"unload\",\n            value: function unload() {\n              return this.callMethod('unload');\n            }\n            /**\n             * Cleanup the player and remove it from the DOM\n             *\n             * It won't be usable and a new one should be constructed\n             *  in order to do any operations.\n             *\n             * @return {Promise}\n             */\n\n          }, {\n            key: \"destroy\",\n            value: function destroy() {\n              var _this5 = this;\n\n              return new npo_src(function (resolve) {\n                readyMap.delete(_this5);\n                playerMap.delete(_this5.element);\n\n                if (_this5._originalElement) {\n                  playerMap.delete(_this5._originalElement);\n\n                  _this5._originalElement.removeAttribute('data-vimeo-initialized');\n                }\n\n                if (_this5.element && _this5.element.nodeName === 'IFRAME' && _this5.element.parentNode) {\n                  _this5.element.parentNode.removeChild(_this5.element);\n                }\n\n                resolve();\n              });\n            }\n            /**\n             * A promise to get the autopause behavior of the video.\n             *\n             * @promise GetAutopausePromise\n             * @fulfill {boolean} Whether autopause is turned on or off.\n             * @reject {UnsupportedError} Autopause is not supported with the current\n             *         player or browser.\n             */\n\n            /**\n             * Get the autopause behavior for this player.\n             *\n             * @return {GetAutopausePromise}\n             */\n\n          }, {\n            key: \"getAutopause\",\n            value: function getAutopause() {\n              return this.get('autopause');\n            }\n            /**\n             * A promise to set the autopause behavior of the video.\n             *\n             * @promise SetAutopausePromise\n             * @fulfill {boolean} Whether autopause is turned on or off.\n             * @reject {UnsupportedError} Autopause is not supported with the current\n             *         player or browser.\n             */\n\n            /**\n             * Enable or disable the autopause behavior of this player.\n             *\n             * By default, when another video is played in the same browser, this\n             * player will automatically pause. Unless you have a specific reason\n             * for doing so, we recommend that you leave autopause set to the\n             * default (`true`).\n             *\n             * @param {boolean} autopause\n             * @return {SetAutopausePromise}\n             */\n\n          }, {\n            key: \"setAutopause\",\n            value: function setAutopause(autopause) {\n              return this.set('autopause', autopause);\n            }\n            /**\n             * A promise to get the buffered property of the video.\n             *\n             * @promise GetBufferedPromise\n             * @fulfill {Array} Buffered Timeranges converted to an Array.\n             */\n\n            /**\n             * Get the buffered property of the video.\n             *\n             * @return {GetBufferedPromise}\n             */\n\n          }, {\n            key: \"getBuffered\",\n            value: function getBuffered() {\n              return this.get('buffered');\n            }\n            /**\n             * A promise to get the color of the player.\n             *\n             * @promise GetColorPromise\n             * @fulfill {string} The hex color of the player.\n             */\n\n            /**\n             * Get the color for this player.\n             *\n             * @return {GetColorPromise}\n             */\n\n          }, {\n            key: \"getColor\",\n            value: function getColor() {\n              return this.get('color');\n            }\n            /**\n             * A promise to set the color of the player.\n             *\n             * @promise SetColorPromise\n             * @fulfill {string} The color was successfully set.\n             * @reject {TypeError} The string was not a valid hex or rgb color.\n             * @reject {ContrastError} The color was set, but the contrast is\n             *         outside of the acceptable range.\n             * @reject {EmbedSettingsError} The owner of the player has chosen to\n             *         use a specific color.\n             */\n\n            /**\n             * Set the color of this player to a hex or rgb string. Setting the\n             * color may fail if the owner of the video has set their embed\n             * preferences to force a specific color.\n             *\n             * @param {string} color The hex or rgb color string to set.\n             * @return {SetColorPromise}\n             */\n\n          }, {\n            key: \"setColor\",\n            value: function setColor(color) {\n              return this.set('color', color);\n            }\n            /**\n             * A representation of a cue point.\n             *\n             * @typedef {Object} VimeoCuePoint\n             * @property {number} time The time of the cue point.\n             * @property {object} data The data passed when adding the cue point.\n             * @property {string} id The unique id for use with removeCuePoint.\n             */\n\n            /**\n             * A promise to get the cue points of a video.\n             *\n             * @promise GetCuePointsPromise\n             * @fulfill {VimeoCuePoint[]} The cue points added to the video.\n             * @reject {UnsupportedError} Cue points are not supported with the current\n             *         player or browser.\n             */\n\n            /**\n             * Get an array of the cue points added to the video.\n             *\n             * @return {GetCuePointsPromise}\n             */\n\n          }, {\n            key: \"getCuePoints\",\n            value: function getCuePoints() {\n              return this.get('cuePoints');\n            }\n            /**\n             * A promise to get the current time of the video.\n             *\n             * @promise GetCurrentTimePromise\n             * @fulfill {number} The current time in seconds.\n             */\n\n            /**\n             * Get the current playback position in seconds.\n             *\n             * @return {GetCurrentTimePromise}\n             */\n\n          }, {\n            key: \"getCurrentTime\",\n            value: function getCurrentTime() {\n              return this.get('currentTime');\n            }\n            /**\n             * A promise to set the current time of the video.\n             *\n             * @promise SetCurrentTimePromise\n             * @fulfill {number} The actual current time that was set.\n             * @reject {RangeError} the time was less than 0 or greater than the\n             *         video’s duration.\n             */\n\n            /**\n             * Set the current playback position in seconds. If the player was\n             * paused, it will remain paused. Likewise, if the player was playing,\n             * it will resume playing once the video has buffered.\n             *\n             * You can provide an accurate time and the player will attempt to seek\n             * to as close to that time as possible. The exact time will be the\n             * fulfilled value of the promise.\n             *\n             * @param {number} currentTime\n             * @return {SetCurrentTimePromise}\n             */\n\n          }, {\n            key: \"setCurrentTime\",\n            value: function setCurrentTime(currentTime) {\n              return this.set('currentTime', currentTime);\n            }\n            /**\n             * A promise to get the duration of the video.\n             *\n             * @promise GetDurationPromise\n             * @fulfill {number} The duration in seconds.\n             */\n\n            /**\n             * Get the duration of the video in seconds. It will be rounded to the\n             * nearest second before playback begins, and to the nearest thousandth\n             * of a second after playback begins.\n             *\n             * @return {GetDurationPromise}\n             */\n\n          }, {\n            key: \"getDuration\",\n            value: function getDuration() {\n              return this.get('duration');\n            }\n            /**\n             * A promise to get the ended state of the video.\n             *\n             * @promise GetEndedPromise\n             * @fulfill {boolean} Whether or not the video has ended.\n             */\n\n            /**\n             * Get the ended state of the video. The video has ended if\n             * `currentTime === duration`.\n             *\n             * @return {GetEndedPromise}\n             */\n\n          }, {\n            key: \"getEnded\",\n            value: function getEnded() {\n              return this.get('ended');\n            }\n            /**\n             * A promise to get the loop state of the player.\n             *\n             * @promise GetLoopPromise\n             * @fulfill {boolean} Whether or not the player is set to loop.\n             */\n\n            /**\n             * Get the loop state of the player.\n             *\n             * @return {GetLoopPromise}\n             */\n\n          }, {\n            key: \"getLoop\",\n            value: function getLoop() {\n              return this.get('loop');\n            }\n            /**\n             * A promise to set the loop state of the player.\n             *\n             * @promise SetLoopPromise\n             * @fulfill {boolean} The loop state that was set.\n             */\n\n            /**\n             * Set the loop state of the player. When set to `true`, the player\n             * will start over immediately once playback ends.\n             *\n             * @param {boolean} loop\n             * @return {SetLoopPromise}\n             */\n\n          }, {\n            key: \"setLoop\",\n            value: function setLoop(loop) {\n              return this.set('loop', loop);\n            }\n            /**\n             * A promise to set the muted state of the player.\n             *\n             * @promise SetMutedPromise\n             * @fulfill {boolean} The muted state that was set.\n             */\n\n            /**\n             * Set the muted state of the player. When set to `true`, the player\n             * volume will be muted.\n             *\n             * @param {boolean} muted\n             * @return {SetMutedPromise}\n             */\n\n          }, {\n            key: \"setMuted\",\n            value: function setMuted(muted) {\n              return this.set('muted', muted);\n            }\n            /**\n             * A promise to get the muted state of the player.\n             *\n             * @promise GetMutedPromise\n             * @fulfill {boolean} Whether or not the player is muted.\n             */\n\n            /**\n             * Get the muted state of the player.\n             *\n             * @return {GetMutedPromise}\n             */\n\n          }, {\n            key: \"getMuted\",\n            value: function getMuted() {\n              return this.get('muted');\n            }\n            /**\n             * A promise to get the paused state of the player.\n             *\n             * @promise GetLoopPromise\n             * @fulfill {boolean} Whether or not the video is paused.\n             */\n\n            /**\n             * Get the paused state of the player.\n             *\n             * @return {GetLoopPromise}\n             */\n\n          }, {\n            key: \"getPaused\",\n            value: function getPaused() {\n              return this.get('paused');\n            }\n            /**\n             * A promise to get the playback rate of the player.\n             *\n             * @promise GetPlaybackRatePromise\n             * @fulfill {number} The playback rate of the player on a scale from 0.5 to 2.\n             */\n\n            /**\n             * Get the playback rate of the player on a scale from `0.5` to `2`.\n             *\n             * @return {GetPlaybackRatePromise}\n             */\n\n          }, {\n            key: \"getPlaybackRate\",\n            value: function getPlaybackRate() {\n              return this.get('playbackRate');\n            }\n            /**\n             * A promise to set the playbackrate of the player.\n             *\n             * @promise SetPlaybackRatePromise\n             * @fulfill {number} The playback rate was set.\n             * @reject {RangeError} The playback rate was less than 0.5 or greater than 2.\n             */\n\n            /**\n             * Set the playback rate of the player on a scale from `0.5` to `2`. When set\n             * via the API, the playback rate will not be synchronized to other\n             * players or stored as the viewer's preference.\n             *\n             * @param {number} playbackRate\n             * @return {SetPlaybackRatePromise}\n             */\n\n          }, {\n            key: \"setPlaybackRate\",\n            value: function setPlaybackRate(playbackRate) {\n              return this.set('playbackRate', playbackRate);\n            }\n            /**\n             * A promise to get the played property of the video.\n             *\n             * @promise GetPlayedPromise\n             * @fulfill {Array} Played Timeranges converted to an Array.\n             */\n\n            /**\n             * Get the played property of the video.\n             *\n             * @return {GetPlayedPromise}\n             */\n\n          }, {\n            key: \"getPlayed\",\n            value: function getPlayed() {\n              return this.get('played');\n            }\n            /**\n             * A promise to get the seekable property of the video.\n             *\n             * @promise GetSeekablePromise\n             * @fulfill {Array} Seekable Timeranges converted to an Array.\n             */\n\n            /**\n             * Get the seekable property of the video.\n             *\n             * @return {GetSeekablePromise}\n             */\n\n          }, {\n            key: \"getSeekable\",\n            value: function getSeekable() {\n              return this.get('seekable');\n            }\n            /**\n             * A promise to get the seeking property of the player.\n             *\n             * @promise GetSeekingPromise\n             * @fulfill {boolean} Whether or not the player is currently seeking.\n             */\n\n            /**\n             * Get if the player is currently seeking.\n             *\n             * @return {GetSeekingPromise}\n             */\n\n          }, {\n            key: \"getSeeking\",\n            value: function getSeeking() {\n              return this.get('seeking');\n            }\n            /**\n             * A promise to get the text tracks of a video.\n             *\n             * @promise GetTextTracksPromise\n             * @fulfill {VimeoTextTrack[]} The text tracks associated with the video.\n             */\n\n            /**\n             * Get an array of the text tracks that exist for the video.\n             *\n             * @return {GetTextTracksPromise}\n             */\n\n          }, {\n            key: \"getTextTracks\",\n            value: function getTextTracks() {\n              return this.get('textTracks');\n            }\n            /**\n             * A promise to get the embed code for the video.\n             *\n             * @promise GetVideoEmbedCodePromise\n             * @fulfill {string} The `<iframe>` embed code for the video.\n             */\n\n            /**\n             * Get the `<iframe>` embed code for the video.\n             *\n             * @return {GetVideoEmbedCodePromise}\n             */\n\n          }, {\n            key: \"getVideoEmbedCode\",\n            value: function getVideoEmbedCode() {\n              return this.get('videoEmbedCode');\n            }\n            /**\n             * A promise to get the id of the video.\n             *\n             * @promise GetVideoIdPromise\n             * @fulfill {number} The id of the video.\n             */\n\n            /**\n             * Get the id of the video.\n             *\n             * @return {GetVideoIdPromise}\n             */\n\n          }, {\n            key: \"getVideoId\",\n            value: function getVideoId() {\n              return this.get('videoId');\n            }\n            /**\n             * A promise to get the title of the video.\n             *\n             * @promise GetVideoTitlePromise\n             * @fulfill {number} The title of the video.\n             */\n\n            /**\n             * Get the title of the video.\n             *\n             * @return {GetVideoTitlePromise}\n             */\n\n          }, {\n            key: \"getVideoTitle\",\n            value: function getVideoTitle() {\n              return this.get('videoTitle');\n            }\n            /**\n             * A promise to get the native width of the video.\n             *\n             * @promise GetVideoWidthPromise\n             * @fulfill {number} The native width of the video.\n             */\n\n            /**\n             * Get the native width of the currently‐playing video. The width of\n             * the highest‐resolution available will be used before playback begins.\n             *\n             * @return {GetVideoWidthPromise}\n             */\n\n          }, {\n            key: \"getVideoWidth\",\n            value: function getVideoWidth() {\n              return this.get('videoWidth');\n            }\n            /**\n             * A promise to get the native height of the video.\n             *\n             * @promise GetVideoHeightPromise\n             * @fulfill {number} The native height of the video.\n             */\n\n            /**\n             * Get the native height of the currently‐playing video. The height of\n             * the highest‐resolution available will be used before playback begins.\n             *\n             * @return {GetVideoHeightPromise}\n             */\n\n          }, {\n            key: \"getVideoHeight\",\n            value: function getVideoHeight() {\n              return this.get('videoHeight');\n            }\n            /**\n             * A promise to get the vimeo.com url for the video.\n             *\n             * @promise GetVideoUrlPromise\n             * @fulfill {number} The vimeo.com url for the video.\n             * @reject {PrivacyError} The url isn’t available because of the video’s privacy setting.\n             */\n\n            /**\n             * Get the vimeo.com url for the video.\n             *\n             * @return {GetVideoUrlPromise}\n             */\n\n          }, {\n            key: \"getVideoUrl\",\n            value: function getVideoUrl() {\n              return this.get('videoUrl');\n            }\n            /**\n             * A promise to get the volume level of the player.\n             *\n             * @promise GetVolumePromise\n             * @fulfill {number} The volume level of the player on a scale from 0 to 1.\n             */\n\n            /**\n             * Get the current volume level of the player on a scale from `0` to `1`.\n             *\n             * Most mobile devices do not support an independent volume from the\n             * system volume. In those cases, this method will always return `1`.\n             *\n             * @return {GetVolumePromise}\n             */\n\n          }, {\n            key: \"getVolume\",\n            value: function getVolume() {\n              return this.get('volume');\n            }\n            /**\n             * A promise to set the volume level of the player.\n             *\n             * @promise SetVolumePromise\n             * @fulfill {number} The volume was set.\n             * @reject {RangeError} The volume was less than 0 or greater than 1.\n             */\n\n            /**\n             * Set the volume of the player on a scale from `0` to `1`. When set\n             * via the API, the volume level will not be synchronized to other\n             * players or stored as the viewer’s preference.\n             *\n             * Most mobile devices do not support setting the volume. An error will\n             * *not* be triggered in that situation.\n             *\n             * @param {number} volume\n             * @return {SetVolumePromise}\n             */\n\n          }, {\n            key: \"setVolume\",\n            value: function setVolume(volume) {\n              return this.set('volume', volume);\n            }\n          }]);\n\n          return Player;\n        }(); // Setup embed only if this is not a node environment\n\n\n        if (!isNode) {\n          initializeEmbeds();\n          resizeEmbeds();\n        }\n        /* harmony default export */\n\n\n        __webpack_exports__[\"a\"] = Player;\n        /* WEBPACK VAR INJECTION */\n      }).call(this, __webpack_require__(0), __webpack_require__(2).setImmediate);\n      /***/\n    }, function (module, exports, __webpack_require__) {\n      /* WEBPACK VAR INJECTION */\n      (function (global) {\n        var scope = typeof global !== \"undefined\" && global || typeof self !== \"undefined\" && self || window;\n        var apply = Function.prototype.apply; // DOM APIs, for completeness\n\n        exports.setTimeout = function () {\n          return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n        };\n\n        exports.setInterval = function () {\n          return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n        };\n\n        exports.clearTimeout = exports.clearInterval = function (timeout) {\n          if (timeout) {\n            timeout.close();\n          }\n        };\n\n        function Timeout(id, clearFn) {\n          this._id = id;\n          this._clearFn = clearFn;\n        }\n\n        Timeout.prototype.unref = Timeout.prototype.ref = function () {};\n\n        Timeout.prototype.close = function () {\n          this._clearFn.call(scope, this._id);\n        }; // Does not start the time, just sets up the members needed.\n\n\n        exports.enroll = function (item, msecs) {\n          clearTimeout(item._idleTimeoutId);\n          item._idleTimeout = msecs;\n        };\n\n        exports.unenroll = function (item) {\n          clearTimeout(item._idleTimeoutId);\n          item._idleTimeout = -1;\n        };\n\n        exports._unrefActive = exports.active = function (item) {\n          clearTimeout(item._idleTimeoutId);\n          var msecs = item._idleTimeout;\n\n          if (msecs >= 0) {\n            item._idleTimeoutId = setTimeout(function onTimeout() {\n              if (item._onTimeout) item._onTimeout();\n            }, msecs);\n          }\n        }; // setimmediate attaches itself to the global object\n\n\n        __webpack_require__(3); // On some exotic environments, it's not clear which object `setimmediate` was\n        // able to install onto.  Search each possibility in the same order as the\n        // `setimmediate` library.\n\n\n        exports.setImmediate = typeof self !== \"undefined\" && self.setImmediate || typeof global !== \"undefined\" && global.setImmediate || this && this.setImmediate;\n        exports.clearImmediate = typeof self !== \"undefined\" && self.clearImmediate || typeof global !== \"undefined\" && global.clearImmediate || this && this.clearImmediate;\n        /* WEBPACK VAR INJECTION */\n      }).call(this, __webpack_require__(0));\n      /***/\n    }, function (module, exports, __webpack_require__) {\n      /* WEBPACK VAR INJECTION */\n      (function (global, process) {\n        (function (global, undefined) {\n          \"use strict\";\n\n          if (global.setImmediate) {\n            return;\n          }\n\n          var nextHandle = 1; // Spec says greater than zero\n\n          var tasksByHandle = {};\n          var currentlyRunningATask = false;\n          var doc = global.document;\n          var registerImmediate;\n\n          function setImmediate(callback) {\n            // Callback can either be a function or a string\n            if (typeof callback !== \"function\") {\n              callback = new Function(\"\" + callback);\n            } // Copy function arguments\n\n\n            var args = new Array(arguments.length - 1);\n\n            for (var i = 0; i < args.length; i++) {\n              args[i] = arguments[i + 1];\n            } // Store and register the task\n\n\n            var task = {\n              callback: callback,\n              args: args\n            };\n            tasksByHandle[nextHandle] = task;\n            registerImmediate(nextHandle);\n            return nextHandle++;\n          }\n\n          function clearImmediate(handle) {\n            delete tasksByHandle[handle];\n          }\n\n          function run(task) {\n            var callback = task.callback;\n            var args = task.args;\n\n            switch (args.length) {\n              case 0:\n                callback();\n                break;\n\n              case 1:\n                callback(args[0]);\n                break;\n\n              case 2:\n                callback(args[0], args[1]);\n                break;\n\n              case 3:\n                callback(args[0], args[1], args[2]);\n                break;\n\n              default:\n                callback.apply(undefined, args);\n                break;\n            }\n          }\n\n          function runIfPresent(handle) {\n            // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n            // So if we're currently running a task, we'll need to delay this invocation.\n            if (currentlyRunningATask) {\n              // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n              // \"too much recursion\" error.\n              setTimeout(runIfPresent, 0, handle);\n            } else {\n              var task = tasksByHandle[handle];\n\n              if (task) {\n                currentlyRunningATask = true;\n\n                try {\n                  run(task);\n                } finally {\n                  clearImmediate(handle);\n                  currentlyRunningATask = false;\n                }\n              }\n            }\n          }\n\n          function installNextTickImplementation() {\n            registerImmediate = function registerImmediate(handle) {\n              process.nextTick(function () {\n                runIfPresent(handle);\n              });\n            };\n          }\n\n          function canUsePostMessage() {\n            // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n            // where `global.postMessage` means something completely different and can't be used for this purpose.\n            if (global.postMessage && !global.importScripts) {\n              var postMessageIsAsynchronous = true;\n              var oldOnMessage = global.onmessage;\n\n              global.onmessage = function () {\n                postMessageIsAsynchronous = false;\n              };\n\n              global.postMessage(\"\", \"*\");\n              global.onmessage = oldOnMessage;\n              return postMessageIsAsynchronous;\n            }\n          }\n\n          function installPostMessageImplementation() {\n            // Installs an event handler on `global` for the `message` event: see\n            // * https://developer.mozilla.org/en/DOM/window.postMessage\n            // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n            var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n\n            var onGlobalMessage = function onGlobalMessage(event) {\n              if (event.source === global && typeof event.data === \"string\" && event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n              }\n            };\n\n            if (global.addEventListener) {\n              global.addEventListener(\"message\", onGlobalMessage, false);\n            } else {\n              global.attachEvent(\"onmessage\", onGlobalMessage);\n            }\n\n            registerImmediate = function registerImmediate(handle) {\n              global.postMessage(messagePrefix + handle, \"*\");\n            };\n          }\n\n          function installMessageChannelImplementation() {\n            var channel = new MessageChannel();\n\n            channel.port1.onmessage = function (event) {\n              var handle = event.data;\n              runIfPresent(handle);\n            };\n\n            registerImmediate = function registerImmediate(handle) {\n              channel.port2.postMessage(handle);\n            };\n          }\n\n          function installReadyStateChangeImplementation() {\n            var html = doc.documentElement;\n\n            registerImmediate = function registerImmediate(handle) {\n              // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n              // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n              var script = doc.createElement(\"script\");\n\n              script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n              };\n\n              html.appendChild(script);\n            };\n          }\n\n          function installSetTimeoutImplementation() {\n            registerImmediate = function registerImmediate(handle) {\n              setTimeout(runIfPresent, 0, handle);\n            };\n          } // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n\n\n          var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n          attachTo = attachTo && attachTo.setTimeout ? attachTo : global; // Don't get fooled by e.g. browserify environments.\n\n          if ({}.toString.call(global.process) === \"[object process]\") {\n            // For Node.js before 0.9\n            installNextTickImplementation();\n          } else if (canUsePostMessage()) {\n            // For non-IE10 modern browsers\n            installPostMessageImplementation();\n          } else if (global.MessageChannel) {\n            // For web workers, where supported\n            installMessageChannelImplementation();\n          } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n            // For IE 6–8\n            installReadyStateChangeImplementation();\n          } else {\n            // For older browsers\n            installSetTimeoutImplementation();\n          }\n\n          attachTo.setImmediate = setImmediate;\n          attachTo.clearImmediate = clearImmediate;\n        })(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self);\n        /* WEBPACK VAR INJECTION */\n\n      }).call(this, __webpack_require__(0), __webpack_require__(4));\n      /***/\n    }, function (module, exports) {\n      // shim for using process in browser\n      var process = module.exports = {}; // cached from whatever global is present so that test runners that stub it\n      // don't break things.  But we need to wrap it in a try catch in case it is\n      // wrapped in strict mode code which doesn't define any globals.  It's inside a\n      // function because try/catches deoptimize in certain engines.\n\n      var cachedSetTimeout;\n      var cachedClearTimeout;\n\n      function defaultSetTimout() {\n        throw new Error('setTimeout has not been defined');\n      }\n\n      function defaultClearTimeout() {\n        throw new Error('clearTimeout has not been defined');\n      }\n\n      (function () {\n        try {\n          if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n          } else {\n            cachedSetTimeout = defaultSetTimout;\n          }\n        } catch (e) {\n          cachedSetTimeout = defaultSetTimout;\n        }\n\n        try {\n          if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n          } else {\n            cachedClearTimeout = defaultClearTimeout;\n          }\n        } catch (e) {\n          cachedClearTimeout = defaultClearTimeout;\n        }\n      })();\n\n      function runTimeout(fun) {\n        if (cachedSetTimeout === setTimeout) {\n          //normal enviroments in sane situations\n          return setTimeout(fun, 0);\n        } // if setTimeout wasn't available but was latter defined\n\n\n        if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n          cachedSetTimeout = setTimeout;\n          return setTimeout(fun, 0);\n        }\n\n        try {\n          // when when somebody has screwed with setTimeout but no I.E. maddness\n          return cachedSetTimeout(fun, 0);\n        } catch (e) {\n          try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n          } catch (e) {\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n          }\n        }\n      }\n\n      function runClearTimeout(marker) {\n        if (cachedClearTimeout === clearTimeout) {\n          //normal enviroments in sane situations\n          return clearTimeout(marker);\n        } // if clearTimeout wasn't available but was latter defined\n\n\n        if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n          cachedClearTimeout = clearTimeout;\n          return clearTimeout(marker);\n        }\n\n        try {\n          // when when somebody has screwed with setTimeout but no I.E. maddness\n          return cachedClearTimeout(marker);\n        } catch (e) {\n          try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n          } catch (e) {\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n          }\n        }\n      }\n\n      var queue = [];\n      var draining = false;\n      var currentQueue;\n      var queueIndex = -1;\n\n      function cleanUpNextTick() {\n        if (!draining || !currentQueue) {\n          return;\n        }\n\n        draining = false;\n\n        if (currentQueue.length) {\n          queue = currentQueue.concat(queue);\n        } else {\n          queueIndex = -1;\n        }\n\n        if (queue.length) {\n          drainQueue();\n        }\n      }\n\n      function drainQueue() {\n        if (draining) {\n          return;\n        }\n\n        var timeout = runTimeout(cleanUpNextTick);\n        draining = true;\n        var len = queue.length;\n\n        while (len) {\n          currentQueue = queue;\n          queue = [];\n\n          while (++queueIndex < len) {\n            if (currentQueue) {\n              currentQueue[queueIndex].run();\n            }\n          }\n\n          queueIndex = -1;\n          len = queue.length;\n        }\n\n        currentQueue = null;\n        draining = false;\n        runClearTimeout(timeout);\n      }\n\n      process.nextTick = function (fun) {\n        var args = new Array(arguments.length - 1);\n\n        if (arguments.length > 1) {\n          for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n          }\n        }\n\n        queue.push(new Item(fun, args));\n\n        if (queue.length === 1 && !draining) {\n          runTimeout(drainQueue);\n        }\n      }; // v8 likes predictible objects\n\n\n      function Item(fun, array) {\n        this.fun = fun;\n        this.array = array;\n      }\n\n      Item.prototype.run = function () {\n        this.fun.apply(null, this.array);\n      };\n\n      process.title = 'browser';\n      process.browser = true;\n      process.env = {};\n      process.argv = [];\n      process.version = ''; // empty string to avoid regexp issues\n\n      process.versions = {};\n\n      function noop() {}\n\n      process.on = noop;\n      process.addListener = noop;\n      process.once = noop;\n      process.off = noop;\n      process.removeListener = noop;\n      process.removeAllListeners = noop;\n      process.emit = noop;\n      process.prependListener = noop;\n      process.prependOnceListener = noop;\n\n      process.listeners = function (name) {\n        return [];\n      };\n\n      process.binding = function (name) {\n        throw new Error('process.binding is not supported');\n      };\n\n      process.cwd = function () {\n        return '/';\n      };\n\n      process.chdir = function (dir) {\n        throw new Error('process.chdir is not supported');\n      };\n\n      process.umask = function () {\n        return 0;\n      };\n      /***/\n\n    }, function (module, __webpack_exports__, __webpack_require__) {\n      \"use strict\"; // ESM COMPAT FLAG\n\n      __webpack_require__.r(__webpack_exports__); // CONCATENATED MODULE: ./src/js/utils/index.js\n\n      /**\r\n       * Utility export functions.\r\n       *\r\n       * @author    Naotoshi Fujita\r\n       * @copyright Naotoshi Fujita. All rights reserved.\r\n       */\n\n      /**\r\n       * Iterate an object like Array.forEach.\r\n       *\r\n       * @param {Object}   obj      - An object.\r\n       * @param {function} callback - A export function handling each value. Arguments are value, property and index.\r\n       */\n\n\n      function each(obj, callback) {\n        Object.keys(obj).some(function (key, index) {\n          return callback(obj[key], key, index);\n        });\n      } // CONCATENATED MODULE: ./src/js/providers/base/base-provider.js\n\n      /**\r\n       * The base class for the provider.\r\n       *\r\n       * @author    Naotoshi Fujita\r\n       * @copyright Naotoshi Fujita. All rights reserved.\r\n       */\n\n      /**\r\n       * The sub component for the provider.\r\n       */\n\n\n      var base_provider_BaseProvider = /*#__PURE__*/function () {\n        /**\r\n         * BaseProvider constructor.\r\n         *\r\n         * @param {Splide} Splide     - A Splide instance.\r\n         * @param {Object} Components - An object containing components.\r\n         */\n        function BaseProvider(Splide, Components) {\n          this.Splide = Splide;\n          this.Components = Components;\n          this.players = [];\n        }\n        /**\r\n         * Create all players.\r\n         *\r\n         * @param {Player} Player        - A Player class.\r\n         * @param {string} attributeName - attribute name for a video URL.\r\n         */\n\n\n        var _proto = BaseProvider.prototype;\n\n        _proto.createPlayers = function createPlayers(Player, attributeName) {\n          var _this = this;\n\n          this.Components.Elements.getSlides(true).forEach(function (Slide) {\n            if (_this.Components.Grid) {\n              each(Slide.slide.querySelectorAll(\".\" + _this.Components.Grid.colClass), function (slide) {\n                _this.createPlayer(slide, Player, attributeName);\n              });\n            }\n\n            _this.createPlayer(Slide.slide, Player, attributeName);\n          });\n        }\n        /**\r\n         * Create a player.\r\n         *\r\n         * @param {Element} slide         - A slide element.\r\n         * @param {Player}  Player        - A Player class.\r\n         * @param {string}  attributeName - attribute name for a video URL.\r\n         */\n        ;\n\n        _proto.createPlayer = function createPlayer(slide, Player, attributeName) {\n          var data = slide.getAttribute(attributeName);\n\n          if (data) {\n            this.players.push(new Player(this.Splide, this.Components, slide));\n          }\n        }\n        /**\r\n         * Destroy.\r\n         */\n        ;\n\n        _proto.destroy = function destroy() {\n          this.players.forEach(function (player) {\n            player.destroy();\n          });\n        };\n\n        return BaseProvider;\n      }(); // CONCATENATED MODULE: ./src/js/elements/index.js\n\n      /**\r\n       * The sub component for creating UI elements.\r\n       *\r\n       * @author    Naotoshi Fujita\r\n       * @copyright Naotoshi Fujita. All rights reserved.\r\n       */\n\n      /**\r\n       * The class name of the wrapper element that will be containing video iframe.\r\n       *\r\n       * @type {string}\r\n       */\n\n\n      var WRAPPER_CLASS = 'splide__video';\n      /**\r\n       * The play button class name.\r\n       *\r\n       * @type {string}\r\n       */\n\n      var PLAY_BUTTON_CLASS = 'splide__video__play';\n      /**\r\n       * The sub component for creating UI elements.\r\n       *\r\n       * @param {Splide}  Splide - A Splide instance.\r\n       * @param {Element} slide  - A target slide element.\r\n       *\r\n       * @return {Object}\r\n       */\n\n      /* harmony default export */\n\n      var js_elements = function js_elements(Splide, slide) {\n        /**\r\n         * Elements sub component.\r\n         *\r\n         * @type {Object}\r\n         */\n        var Elements = {\n          /**\r\n           * Initialization.\r\n           */\n          init: function init() {\n            this.initElements();\n            this.toggleWrapper(false);\n            this.togglePlayButton(false);\n          },\n\n          /**\r\n           * Create some elements.\r\n           */\n          initElements: function initElements() {\n            var container = findContainer(slide);\n            this.parent = container || slide;\n            this.className = Splide.classes[container ? 'container' : 'slide'].split(' ')[0] + \"--has-video\";\n            this.parent.classList.add(this.className);\n            this.wrapper = create('div');\n            this.iframe = create('div');\n            this.playButton = create('button');\n            this.wrapper.classList.add(WRAPPER_CLASS);\n            this.playButton.classList.add(PLAY_BUTTON_CLASS);\n            this.wrapper.appendChild(this.iframe);\n            this.parent.appendChild(this.wrapper);\n            this.parent.appendChild(this.playButton);\n          },\n\n          /**\r\n           * Destroy elements.\r\n           */\n          destroy: function destroy() {\n            this.parent.classList.remove(this.className);\n            remove(this.wrapper);\n            remove(this.playButton);\n          },\n\n          /**\r\n           * Toggle the play button.\r\n           *\r\n           * @param {boolean} show - Set true to show the button.\r\n           */\n          togglePlayButton: function togglePlayButton(show) {\n            this.playButton.style.display = show ? 'flex' : 'none';\n          },\n\n          /**\r\n           * Toggle the wrapper element.\r\n           *\r\n           * @param {boolean} show - Set true to show the wrapper.\r\n           */\n          toggleWrapper: function toggleWrapper(show) {\n            this.wrapper.style.display = show ? 'block' : 'none';\n          },\n\n          /**\r\n           * Hide the play button and show the wrapper element.\r\n           */\n          hide: function hide() {\n            this.togglePlayButton(false);\n            this.toggleWrapper(true);\n          },\n\n          /**\r\n           * Show the play button and hide the wrapper element.\r\n           */\n          show: function show() {\n            this.togglePlayButton(true);\n            this.toggleWrapper(false);\n          }\n        };\n        /**\r\n         * Find a container element.\r\n         *\r\n         * @param {Element} slide - A slide element.\r\n         *\r\n         * @return {Element} - A container element if found. Null otherwise.\r\n         */\n\n        function findContainer(slide) {\n          return findChild(slide, Splide.classes['container'].split(' ')[0] || '');\n        }\n        /**\r\n         * Find a child which has the given class name.\r\n         *\r\n         * @param {Element} parent    - A parent element.\r\n         * @param {string}  className - A class name.\r\n         *\r\n         * @return {Element|null} - A found child element if available or null if not.\r\n         */\n\n\n        function findChild(parent, className) {\n          return Object.keys(parent.children).map(function (key) {\n            return parent.children[key];\n          }).filter(function (child) {\n            return child.classList.contains(className);\n          })[0] || null;\n        }\n        /**\r\n         * Create a new element.\r\n         *\r\n         * @param {string} tag - A tag name for the element.\r\n         *\r\n         * @return {Element} - A created element.\r\n         */\n\n\n        function create(tag) {\n          return document.createElement(tag);\n        }\n        /**\r\n         * Remove the given element.\r\n         *\r\n         * @param {Element} elm - An element being removed.\r\n         */\n\n\n        function remove(elm) {\n          var parent = elm.parentElement;\n\n          if (parent) {\n            parent.removeChild(elm);\n          }\n        }\n\n        return Elements;\n      }; // CONCATENATED MODULE: ./src/js/utils/state.js\n\n      /**\r\n       * The function providing a super simple state system.\r\n       *\r\n       * @author    Naotoshi Fujita\r\n       * @copyright Naotoshi Fujita. All rights reserved.\r\n       */\n\n      /**\r\n       * The function providing a super simple state system.\r\n       *\r\n       * @param {string|number} initialState - Provide the initial state value.\r\n       */\n\n      /* harmony default export */\n\n\n      var state = function state(initialState) {\n        /**\r\n         * Store the current state.\r\n         *\r\n         * @type {string|number}\r\n         */\n        var curr = initialState;\n        return {\n          /**\r\n           * Change state.\r\n           *\r\n           * @param {string|number} state - A new state.\r\n           */\n          set: function set(state) {\n            curr = state;\n          },\n\n          /**\r\n           * Verify if the current state is given one or not.\r\n           *\r\n           * @param {string|number} states - A state name(s) to be verified.\r\n           *\r\n           * @return {boolean} - True if the current state is the given one.\r\n           */\n          is: function is() {\n            for (var i = 0; i < arguments.length; i++) {\n              if ((i < 0 || arguments.length <= i ? undefined : arguments[i]) === curr) {\n                return true;\n              }\n            }\n\n            return false;\n          }\n        };\n      }; // CONCATENATED MODULE: ./src/js/constants/states.js\n\n      /**\r\n       * Export state constants.\r\n       *\r\n       * @author    Naotoshi Fujita\r\n       * @copyright Naotoshi Fujita. All rights reserved.\r\n       */\n\n      /**\r\n       * The player is not initialized.\r\n       *\r\n       * @type {number}\r\n       */\n\n\n      var NOT_INITIALIZED = 1;\n      /**\r\n       * The player is being created.\r\n       *\r\n       * @type {number}\r\n       */\n\n      var CREATING_PLAYER = 2;\n      /**\r\n       * Playing video is requested while creating a player.\r\n       *\r\n       * @type {number}\r\n       */\n\n      var PENDING_PLAY = 3;\n      /**\r\n       * Ready to play a video.\r\n       *\r\n       * @type {number}\r\n       */\n\n      var IDLE = 4;\n      /**\r\n       * Loading a video.\r\n       *\r\n       * @type {number}\r\n       */\n\n      var LOADING = 5;\n      /**\r\n       * Play request has been sent to the player, but it is aborted.\r\n       *\r\n       * @type {number}\r\n       */\n\n      var PLAY_REQUEST_ABORTED = 6;\n      /**\r\n       * Playing a video.\r\n       *\r\n       * @type {number}\r\n       */\n\n      var PLAYING = 7; // CONCATENATED MODULE: ./src/js/providers/base/base-player.js\n\n      /**\r\n       * The base class of the video player.\r\n       *\r\n       * @author    Naotoshi Fujita\r\n       * @copyright Naotoshi Fujita. All rights reserved.\r\n       */\n\n      /**\r\n       * The base class of the video player.\r\n       */\n\n      var base_player_BasePlayer = /*#__PURE__*/function () {\n        /**\r\n         * BasePlayer constructor.\r\n         *\r\n         * @param {Splide}  Splide     - A Splide instance.\r\n         * @param {Object}  Components - An object containing components.\r\n         * @param {Element} slide      - A target slide element.\r\n         */\n        function BasePlayer(Splide, Components, slide) {\n          this.Splide = Splide;\n          this.Components = Components;\n          this.slide = slide;\n          this.player = null;\n          this.elements = null;\n          this.state = new state(NOT_INITIALIZED);\n          this.videoId = this.findVideoId();\n\n          if (this.videoId) {\n            this.init();\n            this.bind();\n            this.handleClick();\n          }\n        }\n        /**\r\n         * Initialization.\r\n         */\n\n\n        var _proto = BasePlayer.prototype;\n\n        _proto.init = function init() {\n          this.elements = new js_elements(this.Splide, this.slide);\n          this.elements.init();\n          this.toggleRootClass(true);\n          this.elements.togglePlayButton(!this.Splide.options.video.disableOverlayUI);\n\n          if (this.isAutoplay() && this.isActive()) {\n            this.play();\n          }\n        }\n        /**\r\n         * Setup.\r\n         * This must be called after MOUNTED state.\r\n         */\n        ;\n\n        _proto.setup = function setup() {\n          var _this = this;\n\n          this.state.set(CREATING_PLAYER);\n          this.player = this.createPlayer(function () {\n            var isPendingPlay = _this.state.is(PENDING_PLAY);\n\n            _this.state.set(IDLE);\n\n            if (isPendingPlay) {\n              _this.play();\n            }\n          });\n        }\n        /**\r\n         * Listen to some events.\r\n         */\n        ;\n\n        _proto.bind = function bind() {\n          var _this2 = this;\n\n          this.Splide.on('active', function (Slide) {\n            if (_this2.isAutoplay()) {\n              if (Slide.slide === _this2.slide) {\n                _this2.play();\n              } else {\n                _this2.pause();\n              }\n            }\n          }).on('move', function () {\n            _this2.pause();\n          }).on('video:click', function (Player) {\n            if (Player.slide !== _this2.slide) {\n              _this2.pause();\n            }\n          });\n        }\n        /**\r\n         * In the fade mode, events will be fired in the order of drag -> dragged -> click,\r\n         * which unexpectedly plays the previous video.\r\n         */\n        ;\n\n        _proto.handleClick = function handleClick() {\n          var _this3 = this; // Listen to native events for grid slides.\n\n\n          this.slide.addEventListener('mousedown', this.onMouseDown.bind(this));\n          this.slide.addEventListener('touchstart', this.onMouseDown.bind(this));\n          this.slide.addEventListener('mouseup', this.onMouseUp.bind(this));\n          this.slide.addEventListener('touchend', this.onMouseUp.bind(this)); // Interrupt playing the video because the slider starts being dragged.\n\n          this.Splide.on('drag', function () {\n            _this3.shouldHandleClick = false;\n          });\n        }\n        /**\r\n         * Create a player.\r\n         * This must be overridden in a child class.\r\n         *\r\n         * @param {function} readyCallback\r\n         *\r\n         * @return {null} - Always null.\r\n         */\n        ;\n\n        _proto.createPlayer = function createPlayer(readyCallback) {\n          if (readyCallback === void 0) {\n            readyCallback = null;\n          }\n\n          return null;\n        }\n        /**\r\n         * Play the video.\r\n         */\n        ;\n\n        _proto.play = function play() {\n          var _this4 = this;\n\n          if (this.state.is(NOT_INITIALIZED)) {\n            this.setup();\n          }\n\n          if (this.state.is(PLAYING, PENDING_PLAY)) {\n            return;\n          } // Hide immediately for UX.\n\n\n          setTimeout(function () {\n            _this4.elements.hide();\n          }); // Pending play because the player is being created now.\n\n          if (this.state.is(CREATING_PLAYER)) {\n            this.state.set(PENDING_PLAY);\n            return;\n          } // Play request is canceled but requested again.\n\n\n          if (this.state.is(PLAY_REQUEST_ABORTED)) {\n            this.state.set(LOADING);\n            return;\n          }\n\n          this.playVideo();\n          this.state.set(LOADING);\n        }\n        /**\r\n         * Pause the video.\r\n         */\n        ;\n\n        _proto.pause = function pause() {\n          if (!this.Splide.options.video.disableOverlayUI) {\n            this.elements.show();\n          } // Cancel the \"pending play\" status.\n\n\n          if (this.state.is(PENDING_PLAY)) {\n            this.state.set(CREATING_PLAYER);\n            return;\n          } // The video is paused while being loaded.\n\n\n          if (this.state.is(LOADING)) {\n            this.state.set(PLAY_REQUEST_ABORTED);\n            return;\n          }\n\n          if (this.state.is(PLAYING)) {\n            this.state.set(IDLE);\n            this.pauseVideo();\n          }\n        }\n        /**\r\n         * Play video. Override this if necessary.\r\n         */\n        ;\n\n        _proto.playVideo = function playVideo() {\n          this.player.play();\n        }\n        /**\r\n         * Pause video. Override this if necessary.\r\n         */\n        ;\n\n        _proto.pauseVideo = function pauseVideo() {\n          this.player.pause();\n        }\n        /**\r\n         * Check if the slide is active or not.\r\n         */\n        ;\n\n        _proto.isActive = function isActive() {\n          return this.slide.classList.contains('is-active');\n        }\n        /**\r\n         * Check whether a video should be played automatically.\r\n         *\r\n         * @return {boolean}\r\n         */\n        ;\n\n        _proto.isAutoplay = function isAutoplay() {\n          return this.Splide.options.video.autoplay;\n        }\n        /**\r\n         * Find the video ID from the HTML.\r\n         *\r\n         * @return {string|number}\r\n         */\n        ;\n\n        _proto.findVideoId = function findVideoId() {\n          return '';\n        }\n        /**\r\n         * Toggle the root class.\r\n         *\r\n         * @param {boolean} add - Whether to add a class or not.\r\n         */\n        ;\n\n        _proto.toggleRootClass = function toggleRootClass(add) {\n          this.Splide.root.classList[add ? 'add' : 'remove'](this.Splide.classes.root.split(' ')[0] + '--has-video');\n        }\n        /**\r\n         * Called on mousedown or touchstart.\r\n         * Request playing the video on mouseup or touchend.\r\n         * This may be interrupted a drag event.\r\n         */\n        ;\n\n        _proto.onMouseDown = function onMouseDown() {\n          this.shouldHandleClick = true;\n        }\n        /**\r\n         * Called on mouseup or touchend.\r\n         * If the shouldHandleClick is still true, play the video.\r\n         */\n        ;\n\n        _proto.onMouseUp = function onMouseUp() {\n          if (this.shouldHandleClick) {\n            this.Splide.emit('video:click', this);\n            this.play();\n          }\n        }\n        /**\r\n         * Called when the player is playing a video.\r\n         */\n        ;\n\n        _proto.onPlay = function onPlay() {\n          if (this.state.is(PLAY_REQUEST_ABORTED)) {\n            this.state.set(PLAYING);\n            this.pause();\n          } else {\n            this.Splide.emit('video:play', this);\n            this.state.set(PLAYING);\n          }\n        }\n        /**\r\n         * Called when the player is paused a video.\r\n         */\n        ;\n\n        _proto.onPause = function onPause() {\n          this.Splide.emit('video:pause', this);\n          this.state.set(IDLE);\n        }\n        /**\r\n         * Called when the video is ended.\r\n         */\n        ;\n\n        _proto.onEnded = function onEnded() {\n          this.Splide.emit('video:ended', this);\n          this.state.set(IDLE);\n        }\n        /**\r\n         * Destroy the player.\r\n         */\n        ;\n\n        _proto.destroy = function destroy() {\n          if (this.player) {\n            this.player.destroy();\n            this.player = null;\n          }\n\n          this.toggleRootClass(false);\n          this.elements.destroy();\n          this.slide.removeEventListener('mousedown', this.onMouseDown.bind(this));\n          this.slide.removeEventListener('touchstart', this.onMouseDown.bind(this));\n          this.slide.removeEventListener('mouseup', this.onMouseUp.bind(this));\n          this.slide.removeEventListener('touchend', this.onMouseUp.bind(this));\n        };\n\n        return BasePlayer;\n      }(); // CONCATENATED MODULE: ./src/js/providers/html-video/player.js\n\n\n      function _createSuper(Derived) {\n        return function () {\n          var Super = _getPrototypeOf(Derived),\n              result;\n\n          if (_isNativeReflectConstruct()) {\n            var NewTarget = _getPrototypeOf(this).constructor;\n\n            result = Reflect.construct(Super, arguments, NewTarget);\n          } else {\n            result = Super.apply(this, arguments);\n          }\n\n          return _possibleConstructorReturn(this, result);\n        };\n      }\n\n      function _possibleConstructorReturn(self, call) {\n        if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n          return call;\n        }\n\n        return _assertThisInitialized(self);\n      }\n\n      function _assertThisInitialized(self) {\n        if (self === void 0) {\n          throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n        }\n\n        return self;\n      }\n\n      function _isNativeReflectConstruct() {\n        if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n        if (Reflect.construct.sham) return false;\n        if (typeof Proxy === \"function\") return true;\n\n        try {\n          Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));\n          return true;\n        } catch (e) {\n          return false;\n        }\n      }\n\n      function _getPrototypeOf(o) {\n        _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n          return o.__proto__ || Object.getPrototypeOf(o);\n        };\n        return _getPrototypeOf(o);\n      }\n\n      function _inheritsLoose(subClass, superClass) {\n        subClass.prototype = Object.create(superClass.prototype);\n        subClass.prototype.constructor = subClass;\n        subClass.__proto__ = superClass;\n      }\n      /**\r\n       * The class for controlling a HTML video.\r\n       *\r\n       * @author    Naotoshi Fujita\r\n       * @copyright Naotoshi Fujita. All rights reserved.\r\n       */\n\n      /**\r\n       * Valid player props.\r\n       * https://developer.mozilla.org/en-US/docs/Web/HTML/Element/video\r\n       *\r\n       * @type {string[]}\r\n       */\n\n\n      var PLAYER_PROPS = ['autoplay', 'autoPictureInPicture', 'controls', 'controlslist', 'crossorigin', 'currentTime', 'disablePictureInPicture', 'disableRemotePlayback', 'height', 'intrinsicsize', 'loop', 'muted', 'playsinline', 'poster', 'preload', 'width'];\n      /**\r\n       * The class for controlling a HTML video.\r\n       */\n\n      var player_Player = /*#__PURE__*/function (_BasePlayer) {\n        _inheritsLoose(Player, _BasePlayer);\n\n        var _super = _createSuper(Player);\n\n        function Player() {\n          return _BasePlayer.apply(this, arguments) || this;\n        }\n\n        var _proto = Player.prototype;\n        /**\r\n         * Create a player.\r\n         *\r\n         * @param {function} readyCallback - Callback function triggered when the player gets ready.\r\n         *\r\n         * @return {object|null} - A created player object.\r\n         */\n\n        _proto.createPlayer = function createPlayer(readyCallback) {\n          if (readyCallback === void 0) {\n            readyCallback = null;\n          }\n\n          var options = this.Splide.options.video;\n          var _options$playerOption = options.playerOptions.htmlVideo,\n              htmlVideo = _options$playerOption === void 0 ? {} : _options$playerOption;\n          var player = document.createElement('video');\n          player.src = this.videoId;\n          this.elements.iframe.appendChild(player);\n          player.controls = !options.hideControls;\n          player.loop = options.loop;\n          player.volume = Math.max(Math.min(options.volume, 1), 0);\n          player.muted = options.mute;\n          each(htmlVideo, function (value, key) {\n            if (PLAYER_PROPS.indexOf(key) > -1) {\n              player[key] = value;\n            }\n          });\n          player.addEventListener('play', this.onPlay.bind(this));\n          player.addEventListener('pause', this.onPause.bind(this));\n          player.addEventListener('ended', this.onEnded.bind(this));\n\n          if (readyCallback) {\n            player.addEventListener('loadeddata', readyCallback);\n          }\n\n          return player;\n        }\n        /**\r\n         * Find the video ID from the HTML.\r\n         * Use the given path or URL as ID for a raw video.\r\n         *\r\n         * @return {string} - Video ID(path or URL).\r\n         */\n        ;\n\n        _proto.findVideoId = function findVideoId() {\n          return this.slide.getAttribute('data-splide-html-video');\n        }\n        /**\r\n         * Destroy.\r\n         */\n        ;\n\n        _proto.destroy = function destroy() {\n          if (this.player) {\n            this.player.pause();\n            this.player.removeAttribute('src');\n            this.player.load();\n            this.elements.iframe.removeChild(this.player);\n            this.player = null;\n          }\n\n          this.elements.destroy();\n        };\n\n        return Player;\n      }(base_player_BasePlayer); // CONCATENATED MODULE: ./src/js/providers/html-video/index.js\n\n\n      function html_video_createSuper(Derived) {\n        return function () {\n          var Super = html_video_getPrototypeOf(Derived),\n              result;\n\n          if (html_video_isNativeReflectConstruct()) {\n            var NewTarget = html_video_getPrototypeOf(this).constructor;\n            result = Reflect.construct(Super, arguments, NewTarget);\n          } else {\n            result = Super.apply(this, arguments);\n          }\n\n          return html_video_possibleConstructorReturn(this, result);\n        };\n      }\n\n      function html_video_possibleConstructorReturn(self, call) {\n        if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n          return call;\n        }\n\n        return html_video_assertThisInitialized(self);\n      }\n\n      function html_video_assertThisInitialized(self) {\n        if (self === void 0) {\n          throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n        }\n\n        return self;\n      }\n\n      function html_video_isNativeReflectConstruct() {\n        if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n        if (Reflect.construct.sham) return false;\n        if (typeof Proxy === \"function\") return true;\n\n        try {\n          Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));\n          return true;\n        } catch (e) {\n          return false;\n        }\n      }\n\n      function html_video_getPrototypeOf(o) {\n        html_video_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n          return o.__proto__ || Object.getPrototypeOf(o);\n        };\n        return html_video_getPrototypeOf(o);\n      }\n\n      function html_video_inheritsLoose(subClass, superClass) {\n        subClass.prototype = Object.create(superClass.prototype);\n        subClass.prototype.constructor = subClass;\n        subClass.__proto__ = superClass;\n      }\n      /**\r\n       * The sub component for embedding a HTML video.\r\n       *\r\n       * @author    Naotoshi Fujita\r\n       * @copyright Naotoshi Fujita. All rights reserved.\r\n       */\n\n      /**\r\n       * The sub component for embedding a HTML video.\r\n       */\n\n\n      var html_video_HTMLVideo = /*#__PURE__*/function (_BaseProvider) {\n        html_video_inheritsLoose(HTMLVideo, _BaseProvider);\n\n        var _super = html_video_createSuper(HTMLVideo);\n        /**\r\n         * HTMLVideo constructor.\r\n         *\r\n         * @param {Splide} Splide     - A Splide instance.\r\n         * @param {Object} Components - An object containing components.\r\n         */\n\n\n        function HTMLVideo(Splide, Components) {\n          var _this;\n\n          _this = _BaseProvider.call(this, Splide, Components) || this;\n\n          _this.createPlayers(player_Player, 'data-splide-html-video');\n\n          return _this;\n        }\n\n        return HTMLVideo;\n      }(base_provider_BaseProvider); // CONCATENATED MODULE: ./src/js/providers/youtube/player.js\n\n\n      function _extends() {\n        _extends = Object.assign || function (target) {\n          for (var i = 1; i < arguments.length; i++) {\n            var source = arguments[i];\n\n            for (var key in source) {\n              if (Object.prototype.hasOwnProperty.call(source, key)) {\n                target[key] = source[key];\n              }\n            }\n          }\n\n          return target;\n        };\n\n        return _extends.apply(this, arguments);\n      }\n\n      function player_createSuper(Derived) {\n        return function () {\n          var Super = player_getPrototypeOf(Derived),\n              result;\n\n          if (player_isNativeReflectConstruct()) {\n            var NewTarget = player_getPrototypeOf(this).constructor;\n            result = Reflect.construct(Super, arguments, NewTarget);\n          } else {\n            result = Super.apply(this, arguments);\n          }\n\n          return player_possibleConstructorReturn(this, result);\n        };\n      }\n\n      function player_possibleConstructorReturn(self, call) {\n        if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n          return call;\n        }\n\n        return player_assertThisInitialized(self);\n      }\n\n      function player_assertThisInitialized(self) {\n        if (self === void 0) {\n          throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n        }\n\n        return self;\n      }\n\n      function player_isNativeReflectConstruct() {\n        if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n        if (Reflect.construct.sham) return false;\n        if (typeof Proxy === \"function\") return true;\n\n        try {\n          Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));\n          return true;\n        } catch (e) {\n          return false;\n        }\n      }\n\n      function player_getPrototypeOf(o) {\n        player_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n          return o.__proto__ || Object.getPrototypeOf(o);\n        };\n        return player_getPrototypeOf(o);\n      }\n\n      function player_inheritsLoose(subClass, superClass) {\n        subClass.prototype = Object.create(superClass.prototype);\n        subClass.prototype.constructor = subClass;\n        subClass.__proto__ = superClass;\n      }\n      /**\r\n       * The class for controlling YouTube video.\r\n       *\r\n       * @author    Naotoshi Fujita\r\n       * @copyright Naotoshi Fujita. All rights reserved.\r\n       */\n\n      /**\r\n       * The class for controlling YouTube video.\r\n       */\n\n\n      var youtube_player_Player = /*#__PURE__*/function (_BasePlayer) {\n        player_inheritsLoose(Player, _BasePlayer);\n\n        var _super = player_createSuper(Player);\n\n        function Player() {\n          return _BasePlayer.apply(this, arguments) || this;\n        }\n\n        var _proto = Player.prototype;\n        /**\r\n         * Create a player.\r\n         *\r\n         * @param {function} readyCallback - Callback function triggered when the player gets ready.\r\n         *\r\n         * @return {object|null} - A created player object.\r\n         */\n\n        _proto.createPlayer = function createPlayer(readyCallback) {\n          var _this = this;\n\n          if (readyCallback === void 0) {\n            readyCallback = null;\n          }\n\n          var options = this.Splide.options.video;\n          var _options$playerOption = options.playerOptions.youtube,\n              youtube = _options$playerOption === void 0 ? {} : _options$playerOption;\n          var player = new YT.Player(this.elements.iframe, {\n            videoId: this.videoId,\n            playerVars: _extends({\n              controls: options.hideControls ? 0 : 1,\n              iv_load_policy: 3,\n              loop: options.loop,\n              playlist: options.loop ? this.videoId : '',\n              rel: 0,\n              autoplay: false\n            }, youtube),\n            events: {\n              'onReady': function onReady(e) {\n                _this.onPlayerReady(e);\n\n                if (readyCallback) {\n                  readyCallback();\n                }\n              },\n              'onStateChange': this.onPlayerStateChange.bind(this)\n            }\n          });\n          return player;\n        }\n        /**\r\n         * Called when the YouTube player is ready.\r\n         *\r\n         * @param {Object} e - An event object.\r\n         */\n        ;\n\n        _proto.onPlayerReady = function onPlayerReady(e) {\n          var player = e.target;\n          var options = this.Splide.options.video;\n\n          if (options.mute) {\n            player.mute();\n          }\n\n          player.setVolume(Math.max(Math.min(options.volume * 100, 100), 0));\n        }\n        /**\r\n         * Called when the YouTube player state is changed.\r\n         *\r\n         * @param {Object} e - An event object.\r\n         */\n        ;\n\n        _proto.onPlayerStateChange = function onPlayerStateChange(e) {\n          var _YT$PlayerState = YT.PlayerState,\n              PLAYING = _YT$PlayerState.PLAYING,\n              PAUSED = _YT$PlayerState.PAUSED,\n              ENDED = _YT$PlayerState.ENDED;\n\n          switch (true) {\n            case e.data === PLAYING:\n              this.onPlay();\n              break;\n\n            case e.data === PAUSED:\n              this.onPause();\n              break;\n\n            case e.data === ENDED:\n              this.onEnded();\n              break;\n          }\n        }\n        /**\r\n         * Play video.\r\n         */\n        ;\n\n        _proto.playVideo = function playVideo() {\n          this.player.playVideo();\n        }\n        /**\r\n         * Pause video.\r\n         */\n        ;\n\n        _proto.pauseVideo = function pauseVideo() {\n          this.player.pauseVideo();\n        }\n        /**\r\n         * Find the video ID from the HTML.\r\n         *\r\n         * @return {string} - Video ID.\r\n         */\n        ;\n\n        _proto.findVideoId = function findVideoId() {\n          var url = this.slide.getAttribute('data-splide-youtube');\n          var regExp = /^.*((youtu.be\\/)|(v\\/)|(\\/u\\/\\w\\/)|(embed\\/)|(watch\\?))\\??v?=?([^#\\&\\?]*).*/;\n          var match = url.match(regExp);\n          return match && match[7].length === 11 ? match[7] : '';\n        };\n\n        return Player;\n      }(base_player_BasePlayer); // CONCATENATED MODULE: ./src/js/providers/youtube/index.js\n\n\n      function youtube_createSuper(Derived) {\n        return function () {\n          var Super = youtube_getPrototypeOf(Derived),\n              result;\n\n          if (youtube_isNativeReflectConstruct()) {\n            var NewTarget = youtube_getPrototypeOf(this).constructor;\n            result = Reflect.construct(Super, arguments, NewTarget);\n          } else {\n            result = Super.apply(this, arguments);\n          }\n\n          return youtube_possibleConstructorReturn(this, result);\n        };\n      }\n\n      function youtube_possibleConstructorReturn(self, call) {\n        if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n          return call;\n        }\n\n        return youtube_assertThisInitialized(self);\n      }\n\n      function youtube_assertThisInitialized(self) {\n        if (self === void 0) {\n          throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n        }\n\n        return self;\n      }\n\n      function youtube_isNativeReflectConstruct() {\n        if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n        if (Reflect.construct.sham) return false;\n        if (typeof Proxy === \"function\") return true;\n\n        try {\n          Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));\n          return true;\n        } catch (e) {\n          return false;\n        }\n      }\n\n      function youtube_getPrototypeOf(o) {\n        youtube_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n          return o.__proto__ || Object.getPrototypeOf(o);\n        };\n        return youtube_getPrototypeOf(o);\n      }\n\n      function youtube_inheritsLoose(subClass, superClass) {\n        subClass.prototype = Object.create(superClass.prototype);\n        subClass.prototype.constructor = subClass;\n        subClass.__proto__ = superClass;\n      }\n      /**\r\n       * The sub component for embedding a YouTube video.\r\n       *\r\n       * @author    Naotoshi Fujita\r\n       * @copyright Naotoshi Fujita. All rights reserved.\r\n       */\n\n      /**\r\n       * URL to the YouTube API script.\r\n       *\r\n       * @type {string}\r\n       */\n\n\n      var YOUTUBE_API_SRC = 'https://www.youtube.com/player_api';\n      /**\r\n       * The sub component for embedding a YouTube video.\r\n       */\n\n      var youtube_YouTube = /*#__PURE__*/function (_BaseProvider) {\n        youtube_inheritsLoose(YouTube, _BaseProvider);\n\n        var _super = youtube_createSuper(YouTube);\n        /**\r\n         * YouTube constructor.\r\n         *\r\n         * @param {Splide} Splide     - A Splide instance.\r\n         * @param {Object} Components - An object containing components.\r\n         */\n\n\n        function YouTube(Splide, Components) {\n          var _this;\n\n          _this = _BaseProvider.call(this, Splide, Components) || this;\n          _this.oldCallback = undefined;\n\n          _this.bindAPICallback();\n\n          _this.loadAPI();\n\n          return _this;\n        }\n        /**\r\n         * Load the YouTube iframe API.\r\n         */\n\n\n        var _proto = YouTube.prototype;\n\n        _proto.loadAPI = function loadAPI() {\n          var _window = window,\n              YT = _window.YT;\n\n          if (this.shouldLoadAPI()) {\n            var tag = document.createElement('script');\n            var firstScriptTag = document.getElementsByTagName('script')[0];\n            tag.src = YOUTUBE_API_SRC;\n            firstScriptTag.parentNode.insertBefore(tag, firstScriptTag);\n          } else {\n            if (YT && YT.loaded) {\n              // API has been already loaded and the callback has been fired.\n              this.onReady();\n            }\n          }\n        }\n        /**\r\n         * Check whether the API should be loaded or not.\r\n         *\r\n         * @return {boolean} - True if it should be or false if not.\r\n         */\n        ;\n\n        _proto.shouldLoadAPI = function shouldLoadAPI() {\n          var scripts = document.getElementsByTagName('script');\n\n          for (var i = 0; i < scripts.length; i++) {\n            if (scripts[i].getAttribute('src') === YOUTUBE_API_SRC) {\n              return false;\n            }\n          }\n\n          return true;\n        }\n        /**\r\n         * Listen onYouTubeIframeAPIReady event.\r\n         */\n        ;\n\n        _proto.bindAPICallback = function bindAPICallback() {\n          // Avoid unexpected collision against other libraries.\n          if (typeof window.onYouTubeIframeAPIReady !== 'undefined') {\n            this.oldCallback = window.onYouTubeIframeAPIReady;\n          }\n\n          window.onYouTubeIframeAPIReady = this.onYouTubeIframeAPIReady.bind(this);\n        }\n        /**\r\n         * Called when the API is ready.\r\n         */\n        ;\n\n        _proto.onYouTubeIframeAPIReady = function onYouTubeIframeAPIReady() {\n          if (this.oldCallback) {\n            this.oldCallback();\n          }\n\n          this.onReady();\n        }\n        /**\r\n         * Called when the YouTube API is ready.\r\n         */\n        ;\n\n        _proto.onReady = function onReady() {\n          this.createPlayers(youtube_player_Player, 'data-splide-youtube');\n        };\n\n        return YouTube;\n      }(base_provider_BaseProvider); // EXTERNAL MODULE: ./node_modules/@vimeo/player/dist/player.es.js\n\n\n      var player_es = __webpack_require__(1); // CONCATENATED MODULE: ./src/js/providers/vimeo/player.js\n\n\n      function player_extends() {\n        player_extends = Object.assign || function (target) {\n          for (var i = 1; i < arguments.length; i++) {\n            var source = arguments[i];\n\n            for (var key in source) {\n              if (Object.prototype.hasOwnProperty.call(source, key)) {\n                target[key] = source[key];\n              }\n            }\n          }\n\n          return target;\n        };\n\n        return player_extends.apply(this, arguments);\n      }\n\n      function vimeo_player_createSuper(Derived) {\n        return function () {\n          var Super = vimeo_player_getPrototypeOf(Derived),\n              result;\n\n          if (vimeo_player_isNativeReflectConstruct()) {\n            var NewTarget = vimeo_player_getPrototypeOf(this).constructor;\n            result = Reflect.construct(Super, arguments, NewTarget);\n          } else {\n            result = Super.apply(this, arguments);\n          }\n\n          return vimeo_player_possibleConstructorReturn(this, result);\n        };\n      }\n\n      function vimeo_player_possibleConstructorReturn(self, call) {\n        if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n          return call;\n        }\n\n        return vimeo_player_assertThisInitialized(self);\n      }\n\n      function vimeo_player_assertThisInitialized(self) {\n        if (self === void 0) {\n          throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n        }\n\n        return self;\n      }\n\n      function vimeo_player_isNativeReflectConstruct() {\n        if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n        if (Reflect.construct.sham) return false;\n        if (typeof Proxy === \"function\") return true;\n\n        try {\n          Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));\n          return true;\n        } catch (e) {\n          return false;\n        }\n      }\n\n      function vimeo_player_getPrototypeOf(o) {\n        vimeo_player_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n          return o.__proto__ || Object.getPrototypeOf(o);\n        };\n        return vimeo_player_getPrototypeOf(o);\n      }\n\n      function vimeo_player_inheritsLoose(subClass, superClass) {\n        subClass.prototype = Object.create(superClass.prototype);\n        subClass.prototype.constructor = subClass;\n        subClass.__proto__ = superClass;\n      }\n      /**\r\n       * The class for controlling Vimeo video.\r\n       *\r\n       * @author    Naotoshi Fujita\r\n       * @copyright Naotoshi Fujita. All rights reserved.\r\n       */\n\n      /**\r\n       * The class for controlling Vimeo video.\r\n       */\n\n\n      var vimeo_player_Player = /*#__PURE__*/function (_BasePlayer) {\n        vimeo_player_inheritsLoose(Player, _BasePlayer);\n\n        var _super = vimeo_player_createSuper(Player);\n\n        function Player() {\n          return _BasePlayer.apply(this, arguments) || this;\n        }\n\n        var _proto = Player.prototype;\n        /**\r\n         * Create a player.\r\n         *\r\n         * @param {function} readyCallback - Callback function triggered when the player gets ready.\r\n         *\r\n         * @return {object|null} - A created player object.\r\n         */\n\n        _proto.createPlayer = function createPlayer(readyCallback) {\n          if (readyCallback === void 0) {\n            readyCallback = null;\n          }\n\n          var options = this.Splide.options.video;\n          var _options$playerOption = options.playerOptions.vimeo,\n              vimeo = _options$playerOption === void 0 ? {} : _options$playerOption;\n          var player = new player_es[\"a\"\n          /* default */\n          ](this.elements.iframe, player_extends({\n            id: this.videoId,\n            controls: !options.hideControls,\n            loop: options.loop\n          }, vimeo));\n          player.on('play', this.onPlay.bind(this));\n          player.on('pause', this.onPause.bind(this));\n          player.on('ended', this.onEnded.bind(this));\n          player.setVolume(Math.max(Math.min(options.volume, 1), 0));\n          player.setMuted(vimeo.muted || options.mute);\n\n          if (readyCallback) {\n            player.ready().then(readyCallback);\n          }\n\n          return player;\n        }\n        /**\r\n         * Find the video ID from the HTML.\r\n         *\r\n         * @return {string} - Video ID.\r\n         */\n        ;\n\n        _proto.findVideoId = function findVideoId() {\n          var url = this.slide.getAttribute('data-splide-vimeo');\n          var regExp = /vimeo.com\\/(\\d+)/;\n          var match = url.match(regExp);\n          return match && match[1] ? match[1] : '';\n        }\n        /**\r\n         * Called when the player is playing a video.\r\n         */\n        ;\n\n        _proto.onPlay = function onPlay() {\n          if (this.state.is(PLAY_REQUEST_ABORTED) && !this.isActive()) {\n            this.player.destroy();\n            this.elements.show();\n            this.state.set(NOT_INITIALIZED);\n          } else {\n            this.Splide.emit('video:play', this);\n            this.state.set(PLAYING);\n          }\n        };\n\n        return Player;\n      }(base_player_BasePlayer); // CONCATENATED MODULE: ./src/js/providers/vimeo/index.js\n\n\n      function vimeo_createSuper(Derived) {\n        return function () {\n          var Super = vimeo_getPrototypeOf(Derived),\n              result;\n\n          if (vimeo_isNativeReflectConstruct()) {\n            var NewTarget = vimeo_getPrototypeOf(this).constructor;\n            result = Reflect.construct(Super, arguments, NewTarget);\n          } else {\n            result = Super.apply(this, arguments);\n          }\n\n          return vimeo_possibleConstructorReturn(this, result);\n        };\n      }\n\n      function vimeo_possibleConstructorReturn(self, call) {\n        if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n          return call;\n        }\n\n        return vimeo_assertThisInitialized(self);\n      }\n\n      function vimeo_assertThisInitialized(self) {\n        if (self === void 0) {\n          throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n        }\n\n        return self;\n      }\n\n      function vimeo_isNativeReflectConstruct() {\n        if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n        if (Reflect.construct.sham) return false;\n        if (typeof Proxy === \"function\") return true;\n\n        try {\n          Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));\n          return true;\n        } catch (e) {\n          return false;\n        }\n      }\n\n      function vimeo_getPrototypeOf(o) {\n        vimeo_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n          return o.__proto__ || Object.getPrototypeOf(o);\n        };\n        return vimeo_getPrototypeOf(o);\n      }\n\n      function vimeo_inheritsLoose(subClass, superClass) {\n        subClass.prototype = Object.create(superClass.prototype);\n        subClass.prototype.constructor = subClass;\n        subClass.__proto__ = superClass;\n      }\n      /**\r\n       * The sub component for embedding a Vimeo video.\r\n       *\r\n       * @author    Naotoshi Fujita\r\n       * @copyright Naotoshi Fujita. All rights reserved.\r\n       */\n\n      /**\r\n       * The sub component for embedding a Vimeo video.\r\n       */\n\n\n      var vimeo_Vimeo = /*#__PURE__*/function (_BaseProvider) {\n        vimeo_inheritsLoose(Vimeo, _BaseProvider);\n\n        var _super = vimeo_createSuper(Vimeo);\n        /**\r\n         * Vimeo constructor.\r\n         *\r\n         * @param {Splide} Splide     - A Splide instance.\r\n         * @param {Object} Components - An object containing components.\r\n         */\n\n\n        function Vimeo(Splide, Components) {\n          var _this;\n\n          _this = _BaseProvider.call(this, Splide, Components) || this;\n\n          _this.createPlayers(vimeo_player_Player, 'data-splide-vimeo');\n\n          return _this;\n        }\n\n        return Vimeo;\n      }(base_provider_BaseProvider); // CONCATENATED MODULE: ./src/js/providers/index.js\n\n      /**\r\n       * Export provider classes.\r\n       *\r\n       * @author    Naotoshi Fujita\r\n       * @copyright Naotoshi Fujita. All rights reserved.\r\n       */\n\n\n      var PROVIDERS = {\n        HtmlVideo: html_video_HTMLVideo,\n        YouTube: youtube_YouTube,\n        Vimeo: vimeo_Vimeo\n      }; // CONCATENATED MODULE: ./src/js/constants/defaults.js\n\n      /**\r\n       * Export default options.\r\n       *\r\n       * @author    Naotoshi Fujita\r\n       * @copyright Naotoshi Fujita. All rights reserved.\r\n       */\n\n      var DEFAULTS = {\n        /**\r\n         * Whether to play the video automatically.\r\n         *\r\n         * @type {boolean}\r\n         */\n        autoplay: false,\n\n        /**\r\n         * Disable the overlay UI.\r\n         *\r\n         * @type {boolean}\r\n         */\n        disableOverlayUI: false,\n\n        /**\r\n         * Hide the video control UI.\r\n         *\r\n         * @type {boolean}\r\n         */\n        hideControls: false,\n\n        /**\r\n         * Loop the video.\r\n         *\r\n         * @type {boolean}\r\n         */\n        loop: false,\n\n        /**\r\n         * Mute the video.\r\n         *\r\n         * @type {boolean}\r\n         */\n        mute: false,\n\n        /**\r\n         * Default volume(0.0-1.0).\r\n         *\r\n         * @type {number}\r\n         */\n        volume: 0.2,\n\n        /**\r\n         * Additional options for each player.\r\n         * - playerOptions.youtube\r\n         * - playerOptions.vimeo\r\n         * - playerOptions.htmlVideo\r\n         *\r\n         * @type {Object}\r\n         */\n        playerOptions: {}\n      }; // CONCATENATED MODULE: ./src/js/splide-extension-video.js\n\n      function splide_extension_video_extends() {\n        splide_extension_video_extends = Object.assign || function (target) {\n          for (var i = 1; i < arguments.length; i++) {\n            var source = arguments[i];\n\n            for (var key in source) {\n              if (Object.prototype.hasOwnProperty.call(source, key)) {\n                target[key] = source[key];\n              }\n            }\n          }\n\n          return target;\n        };\n\n        return splide_extension_video_extends.apply(this, arguments);\n      }\n      /**\n       * The extension component for embedding videos to slides.\n       *\n       * @author    Naotoshi Fujita\n       * @copyright Naotoshi Fujita. All rights reserved.\n       */\n\n      /**\n       * The status class name added to the root element while the video is playing.\n       *\n       * @type {string}\n       */\n\n\n      var PLAYING_STATUS_CLASS_NAME = 'is-playing';\n      /**\n       * The extension component for embedding videos to slides.\n       *\n       * @param {Splide} Splide     - A Splide instance.\n       * @param {Object} Components - An object containing components.\n       *\n       * @return {Object} - Extension object.\n       */\n\n      /* harmony default export */\n\n      var splide_extension_video = __webpack_exports__[\"default\"] = function (Splide, Components) {\n        /**\n         * A slide element whose video is playing.\n         *\n         * @type {Element}\n         */\n        var activeSlide;\n        /**\n         * Store provider components.\n         * \n         * @type {Object[]}\n         */\n\n        var Providers = [];\n        var Video = {\n          /**\n           * Called when this extension is mounted.\n           * Initialize all sub components.\n           */\n          mount: function mount() {\n            if (_typeof(Splide.options.video) !== 'object') {\n              Splide.options.video = {};\n            }\n\n            Splide.options.video = splide_extension_video_extends({}, DEFAULTS, {}, Splide.options.video);\n            each(PROVIDERS, function (Provider) {\n              Providers.push(new Provider(Splide, Components));\n            });\n            bind();\n          },\n\n          /**\n           * Destroy.\n           */\n          destroy: function destroy() {\n            Providers.forEach(function (Provider) {\n              Provider.destroy();\n            });\n          }\n        };\n        /**\n         * Listen to some events.\n         */\n\n        function bind() {\n          var classList = Splide.root.classList;\n          Splide.on('video:play', function (Player) {\n            activeSlide = Player.slide;\n            classList.add(PLAYING_STATUS_CLASS_NAME);\n          }).on('video:pause video:ended', function (Player) {\n            if (Player.slide === activeSlide) {\n              activeSlide = null;\n              classList.remove(PLAYING_STATUS_CLASS_NAME);\n            }\n          }).on('destroy', function () {\n            classList.remove(PLAYING_STATUS_CLASS_NAME);\n          });\n        }\n\n        return Video;\n      };\n      /***/\n\n    }])\n  );\n});","module.exports = function (module) {\n  if (!module.webpackPolyfill) {\n    module.deprecate = function () {};\n\n    module.paths = []; // module.parent = undefined by default\n\n    if (!module.children) module.children = [];\n    Object.defineProperty(module, \"loaded\", {\n      enumerable: true,\n      get: function get() {\n        return module.l;\n      }\n    });\n    Object.defineProperty(module, \"id\", {\n      enumerable: true,\n      get: function get() {\n        return module.i;\n      }\n    });\n    module.webpackPolyfill = 1;\n  }\n\n  return module;\n};","import Splide from \"@splidejs/splide\";\nimport SplideVideo from \"@splidejs/splide-extension-video\";\n\nconst slideShow = (slide) => {\n// Create and mount the thumbnails slider.\n    const thumbnailSlider = new Splide( '#js-thumbnail-slider', {\n        rewind      : true,\n        fixedWidth  : 100,\n        fixedHeight : 64,\n        isNavigation: true,\n        gap         : 10,\n        focus       : 'left',\n        arrows     : false,\n        pagination  : false,\n        cover       : true,\n        breakpoints : {\n            '600': {\n                fixedWidth  : 66,\n                fixedHeight : 40,\n            }\n        }\n    } ).mount();\n\n// Create the main slider.\n    const primarySlider = new Splide( '#js-primary-slider', {\n        type: 'fade',\n        pagination: false,\n        arrows: false,\n        heightRatio: 0.5625,\n        // cover      : true,\n        video: {\n            autoplay: false,\n            hideControls: false,\n            disableOverlayUI: false,\n            playerOptions: {\n                htmlVideo: {\n                    playsinline: true,\n                },\n            }\n        },\n    } );\n\n// Set the thumbnails slider as a sync target and then call mount.\n    primarySlider.sync( thumbnailSlider ).mount({SplideVideo});\n\n}\n\nexport default slideShow\n","// Splide\nimport slideShow from '../../slideShow'\n\ndocument.addEventListener('DOMContentLoaded', () => {\n    document.querySelectorAll('.js-slideshow').forEach(slide => {\n        slideShow(slide)\n    })\n})\n","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n/*!\n * Splide.js\n * Version  : 2.4.20\n * License  : MIT\n * Copyright: 2020 Naotoshi Fujita\n */\n(function webpackUniversalModuleDefinition(root, factory) {\n  if ((typeof exports === \"undefined\" ? \"undefined\" : _typeof(exports)) === 'object' && (typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) === 'object') module.exports = factory();else if (typeof define === 'function' && define.amd) define([], factory);else if ((typeof exports === \"undefined\" ? \"undefined\" : _typeof(exports)) === 'object') exports[\"Splide\"] = factory();else root[\"Splide\"] = factory();\n})(self, function () {\n  return (\n    /******/\n    function () {\n      // webpackBootstrap\n\n      /******/\n      \"use strict\";\n      /******/\n\n      var __webpack_modules__ = {\n        /***/\n        311: function _(__unused_webpack_module, __webpack_exports__, __webpack_require__) {\n          // ESM COMPAT FLAG\n          __webpack_require__.r(__webpack_exports__); // EXPORTS\n\n\n          __webpack_require__.d(__webpack_exports__, {\n            \"default\": function _default() {\n              return (\n                /* binding */\n                module_Splide\n              );\n            }\n          }); // NAMESPACE OBJECT: ./src/js/constants/states.js\n\n\n          var states_namespaceObject = {};\n\n          __webpack_require__.r(states_namespaceObject);\n\n          __webpack_require__.d(states_namespaceObject, {\n            \"CREATED\": function CREATED() {\n              return _CREATED;\n            },\n            \"DESTROYED\": function DESTROYED() {\n              return _DESTROYED;\n            },\n            \"IDLE\": function IDLE() {\n              return _IDLE;\n            },\n            \"MOUNTED\": function MOUNTED() {\n              return _MOUNTED;\n            },\n            \"MOVING\": function MOVING() {\n              return _MOVING;\n            }\n          });\n\n          ; // CONCATENATED MODULE: ./src/js/core/event.js\n\n          /**\r\n           * The function for providing an Event object simply managing events.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The function for providing an Event object simply managing events.\r\n           */\n\n          /* harmony default export */\n\n          var core_event = function core_event() {\n            /**\r\n             * Store all event data.\r\n             *\r\n             * @type {Array}\r\n             */\n            var data = [];\n            var Event = {\n              /**\r\n               * Subscribe the given event(s).\r\n               *\r\n               * @param {string}   events  - An event name. Use space to separate multiple events.\r\n               *                             Also, namespace is accepted by dot, such as 'resize.{namespace}'.\r\n               * @param {function} handler - A callback function.\r\n               * @param {Element}  elm     - Optional. Native event will be listened to when this arg is provided.\r\n               * @param {Object}   options - Optional. Options for addEventListener.\r\n               */\n              on: function on(events, handler, elm, options) {\n                if (elm === void 0) {\n                  elm = null;\n                }\n\n                if (options === void 0) {\n                  options = {};\n                }\n\n                events.split(' ').forEach(function (event) {\n                  if (elm) {\n                    elm.addEventListener(event, handler, options);\n                  }\n\n                  data.push({\n                    event: event,\n                    handler: handler,\n                    elm: elm,\n                    options: options\n                  });\n                });\n              },\n\n              /**\r\n               * Unsubscribe the given event(s).\r\n               *\r\n               * @param {string}  events - A event name or names split by space.\r\n               * @param {Element} elm    - Optional. removeEventListener() will be called when this arg is provided.\r\n               */\n              off: function off(events, elm) {\n                if (elm === void 0) {\n                  elm = null;\n                }\n\n                events.split(' ').forEach(function (event) {\n                  data = data.filter(function (item) {\n                    if (item && item.event === event && item.elm === elm) {\n                      unsubscribe(item);\n                      return false;\n                    }\n\n                    return true;\n                  });\n                });\n              },\n\n              /**\r\n               * Emit an event.\r\n               * This method is only for custom events.\r\n               *\r\n               * @param {string}  event - An event name.\r\n               * @param {*}       args  - Any number of arguments passed to handlers.\r\n               */\n              emit: function emit(event) {\n                for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n                  args[_key - 1] = arguments[_key];\n                }\n\n                data.forEach(function (item) {\n                  if (!item.elm && item.event.split('.')[0] === event) {\n                    item.handler.apply(item, args);\n                  }\n                });\n              },\n\n              /**\r\n               * Clear event data.\r\n               */\n              destroy: function destroy() {\n                data.forEach(unsubscribe);\n                data = [];\n              }\n            };\n            /**\r\n             * Remove the registered event listener.\r\n             *\r\n             * @param {Object} item - An object containing event data.\r\n             */\n\n            function unsubscribe(item) {\n              if (item.elm) {\n                item.elm.removeEventListener(item.event, item.handler, item.options);\n              }\n            }\n\n            return Event;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/core/state.js\n\n          /**\r\n           * The function providing a super simple state system.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The function providing a super simple state system.\r\n           *\r\n           * @param {string|number} initialState - Provide the initial state value.\r\n           */\n\n          /* harmony default export */\n\n          var state = function state(initialState) {\n            /**\r\n             * Store the current state.\r\n             *\r\n             * @type {string|number}\r\n             */\n            var curr = initialState;\n            return {\n              /**\r\n               * Change state.\r\n               *\r\n               * @param {string|number} state - A new state.\r\n               */\n              set: function set(state) {\n                curr = state;\n              },\n\n              /**\r\n               * Verify if the current state is given one or not.\r\n               *\r\n               * @param {string|number} state - A state name to be verified.\r\n               *\r\n               * @return {boolean} - True if the current state is the given one.\r\n               */\n              is: function is(state) {\n                return state === curr;\n              }\n            };\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/utils/object.js\n\n          function _extends() {\n            _extends = Object.assign || function (target) {\n              for (var i = 1; i < arguments.length; i++) {\n                var source = arguments[i];\n\n                for (var key in source) {\n                  if (Object.prototype.hasOwnProperty.call(source, key)) {\n                    target[key] = source[key];\n                  }\n                }\n              }\n\n              return target;\n            };\n\n            return _extends.apply(this, arguments);\n          }\n          /**\r\n           * Some utility functions related with Object, supporting IE.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n\n          var keys = Object.keys;\n          /**\r\n           * Iterate an object like Array.forEach.\r\n           * IE doesn't support forEach of HTMLCollection.\r\n           *\r\n           * @param {Object}    obj       - An object.\r\n           * @param {function}  callback  - A function handling each value. Arguments are value, property and index.\r\n           */\n\n          function each(obj, callback) {\n            keys(obj).some(function (key, index) {\n              return callback(obj[key], key, index);\n            });\n          }\n          /**\r\n           * Return values of the given object as an array.\r\n           * IE doesn't support Object.values.\r\n           *\r\n           * @param {Object} obj - An object.\r\n           *\r\n           * @return {Array} - An array containing all values of the given object.\r\n           */\n\n\n          function values(obj) {\n            return keys(obj).map(function (key) {\n              return obj[key];\n            });\n          }\n          /**\r\n           * Check if the given subject is object or not.\r\n           *\r\n           * @param {*} subject - A subject to be verified.\r\n           *\r\n           * @return {boolean} - True if object, false otherwise.\r\n           */\n\n\n          function isObject(subject) {\n            return _typeof(subject) === 'object';\n          }\n          /**\r\n           * Merge two objects deeply.\r\n           *\r\n           * @param {Object} to   - An object where \"from\" is merged.\r\n           * @param {Object} from - An object merged to \"to\".\r\n           *\r\n           * @return {Object} - A merged object.\r\n           */\n\n\n          function merge(_ref, from) {\n            var to = _extends({}, _ref);\n\n            each(from, function (value, key) {\n              if (isObject(value)) {\n                if (!isObject(to[key])) {\n                  to[key] = {};\n                }\n\n                to[key] = merge(to[key], value);\n              } else {\n                to[key] = value;\n              }\n            });\n            return to;\n          }\n          /**\r\n           * Assign all properties \"from\" to \"to\" object.\r\n           *\r\n           * @param {Object} to   - An object where properties are assigned.\r\n           * @param {Object} from - An object whose properties are assigned to \"to\".\r\n           *\r\n           * @return {Object} - An assigned object.\r\n           */\n\n\n          function object_assign(to, from) {\n            keys(from).forEach(function (key) {\n              if (!to[key]) {\n                Object.defineProperty(to, key, Object.getOwnPropertyDescriptor(from, key));\n              }\n            });\n            return to;\n          }\n\n          ; // CONCATENATED MODULE: ./src/js/utils/utils.js\n\n          /**\r\n           * A package of some miscellaneous utility functions.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * Convert the given value to array.\r\n           *\r\n           * @param {*} value - Any value.\r\n           *\r\n           * @return {*[]} - Array containing the given value.\r\n           */\n\n          function toArray(value) {\n            return Array.isArray(value) ? value : [value];\n          }\n          /**\r\n           * Check if the given value is between min and max.\r\n           * Min will be returned when the value is less than min or max will do when greater than max.\r\n           *\r\n           * @param {number} value - A number to be checked.\r\n           * @param {number} m1    - Minimum or maximum number.\r\n           * @param {number} m2    - Maximum or minimum number.\r\n           *\r\n           * @return {number} - A value itself, min or max.\r\n           */\n\n\n          function between(value, m1, m2) {\n            return Math.min(Math.max(value, m1 > m2 ? m2 : m1), m1 > m2 ? m1 : m2);\n          }\n          /**\r\n           * The sprintf method with minimum functionality.\r\n           *\r\n           * @param {string}       format       - The string format.\r\n           * @param {string|Array} replacements - Replacements accepting multiple arguments.\r\n           *\r\n           * @returns {string} - Converted string.\r\n           */\n\n\n          function sprintf(format, replacements) {\n            var i = 0;\n            return format.replace(/%s/g, function () {\n              return toArray(replacements)[i++];\n            });\n          }\n          /**\r\n           * Append px unit to the given subject if necessary.\r\n           *\r\n           * @param {number|string} value - A value that may not include an unit.\r\n           *\r\n           * @return {string} - If the value is string, return itself.\r\n           *                    If number, do value + \"px\". An empty string, otherwise.\r\n           */\n\n\n          function unit(value) {\n            var type = _typeof(value);\n\n            if (type === 'number' && value > 0) {\n              return parseFloat(value) + 'px';\n            }\n\n            return type === 'string' ? value : '';\n          }\n          /**\r\n           * Pad start with 0.\r\n           *\r\n           * @param {number} number - A number to be filled with 0.\r\n           *\r\n           * @return {string|number} - Padded number.\r\n           */\n\n\n          function pad(number) {\n            return number < 10 ? '0' + number : number;\n          }\n          /**\r\n           * Convert the given value to pixel.\r\n           *\r\n           * @param {Element}       root  - Root element where a dummy div is appended.\r\n           * @param {string|number} value - CSS value to be converted, such as 10rem.\r\n           *\r\n           * @return {number} - Pixel.\r\n           */\n\n\n          function toPixel(root, value) {\n            if (typeof value === 'string') {\n              var div = create('div', {});\n              applyStyle(div, {\n                position: 'absolute',\n                width: value\n              });\n              append(root, div);\n              value = div.clientWidth;\n              dom_remove(div);\n            }\n\n            return +value || 0;\n          }\n\n          ; // CONCATENATED MODULE: ./src/js/utils/dom.js\n\n          /**\r\n           * Some utility functions related with DOM.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * Find the first element matching the given selector.\r\n           * Be aware that all selectors after a space are ignored.\r\n           *\r\n           * @param {Element|Node}  elm       - An ancestor element.\r\n           * @param {string}        selector  - DOMString.\r\n           *\r\n           * @return {Element|null} - A found element or null.\r\n           */\n\n          function find(elm, selector) {\n            return elm ? elm.querySelector(selector.split(' ')[0]) : null;\n          }\n          /**\r\n           * Find a first child having the given tag or class name.\r\n           *\r\n           * @param {Element} parent         - A parent element.\r\n           * @param {string}  tagOrClassName - A tag or class name.\r\n           *\r\n           * @return {Element|undefined} - A found element on success or undefined on failure.\r\n           */\n\n\n          function child(parent, tagOrClassName) {\n            return children(parent, tagOrClassName)[0];\n          }\n          /**\r\n           * Return chile elements that matches the provided tag or class name.\r\n           *\r\n           * @param {Element} parent         - A parent element.\r\n           * @param {string}  tagOrClassName - A tag or class name.\r\n           *\r\n           * @return {Element[]} - Found elements.\r\n           */\n\n\n          function children(parent, tagOrClassName) {\n            if (parent) {\n              return values(parent.children).filter(function (child) {\n                return hasClass(child, tagOrClassName.split(' ')[0]) || child.tagName === tagOrClassName;\n              });\n            }\n\n            return [];\n          }\n          /**\r\n           * Create an element with some optional attributes.\r\n           *\r\n           * @param {string} tag   - A tag name.\r\n           * @param {Object} attrs - An object any attribute pairs of name and value.\r\n           *\r\n           * @return {Element} - A created element.\r\n           */\n\n\n          function create(tag, attrs) {\n            var elm = document.createElement(tag);\n            each(attrs, function (value, key) {\n              return setAttribute(elm, key, value);\n            });\n            return elm;\n          }\n          /**\r\n           * Convert HTML string to DOM node.\r\n           *\r\n           * @param {string} html - HTML string.\r\n           *\r\n           * @return {Node} - A created node.\r\n           */\n\n\n          function domify(html) {\n            var div = create('div', {});\n            div.innerHTML = html;\n            return div.firstChild;\n          }\n          /**\r\n           * Remove a given element from a DOM tree.\r\n           *\r\n           * @param {Element|Element[]} elms - Element(s) to be removed.\r\n           */\n\n\n          function dom_remove(elms) {\n            toArray(elms).forEach(function (elm) {\n              if (elm) {\n                var parent = elm.parentElement;\n                parent && parent.removeChild(elm);\n              }\n            });\n          }\n          /**\r\n           * Append a child to a given element.\r\n           *\r\n           * @param {Element} parent - A parent element.\r\n           * @param {Element} child  - An element to be appended.\r\n           */\n\n\n          function append(parent, child) {\n            if (parent) {\n              parent.appendChild(child);\n            }\n          }\n          /**\r\n           * Insert an element before the reference element.\r\n           *\r\n           * @param {Element|Node} ref - A reference element.\r\n           * @param {Element}      elm - An element to be inserted.\r\n           */\n\n\n          function before(elm, ref) {\n            if (elm && ref) {\n              var parent = ref.parentElement;\n              parent && parent.insertBefore(elm, ref);\n            }\n          }\n          /**\r\n           * Apply styles to the given element.\r\n           *\r\n           * @param {Element} elm     - An element where styles are applied.\r\n           * @param {Object}  styles  - Object containing styles.\r\n           */\n\n\n          function applyStyle(elm, styles) {\n            if (elm) {\n              each(styles, function (value, prop) {\n                if (value !== null) {\n                  elm.style[prop] = value;\n                }\n              });\n            }\n          }\n          /**\r\n           * Add or remove classes to/from the element.\r\n           * This function is for internal usage.\r\n           *\r\n           * @param {Element}         elm     - An element where classes are added.\r\n           * @param {string|string[]} classes - Class names being added.\r\n           * @param {boolean}         remove  - Whether to remove or add classes.\r\n           */\n\n\n          function addOrRemoveClasses(elm, classes, remove) {\n            if (elm) {\n              toArray(classes).forEach(function (name) {\n                if (name) {\n                  elm.classList[remove ? 'remove' : 'add'](name);\n                }\n              });\n            }\n          }\n          /**\r\n           * Add classes to the element.\r\n           *\r\n           * @param {Element}          elm     - An element where classes are added.\r\n           * @param {string|string[]}  classes - Class names being added.\r\n           */\n\n\n          function addClass(elm, classes) {\n            addOrRemoveClasses(elm, classes, false);\n          }\n          /**\r\n           * Remove a class from the element.\r\n           *\r\n           * @param {Element}         elm     - An element where classes are removed.\r\n           * @param {string|string[]} classes - A class name being removed.\r\n           */\n\n\n          function removeClass(elm, classes) {\n            addOrRemoveClasses(elm, classes, true);\n          }\n          /**\r\n           * Verify if the provided element has the class or not.\r\n           *\r\n           * @param {Element} elm       - An element.\r\n           * @param {string}  className - A class name.\r\n           *\r\n           * @return {boolean} - True if the element has the class or false if not.\r\n           */\n\n\n          function hasClass(elm, className) {\n            return !!elm && elm.classList.contains(className);\n          }\n          /**\r\n           * Set attribute to the given element.\r\n           *\r\n           * @param {Element}                 elm   - An element where an attribute is assigned.\r\n           * @param {string}                  name  - Attribute name.\r\n           * @param {string|number|boolean}   value - Attribute value.\r\n           */\n\n\n          function setAttribute(elm, name, value) {\n            if (elm) {\n              elm.setAttribute(name, value);\n            }\n          }\n          /**\r\n           * Get attribute from the given element.\r\n           *\r\n           * @param {Element} elm  - An element where an attribute is assigned.\r\n           * @param {string}  name - Attribute name.\r\n           *\r\n           * @return {string} - The value of the given attribute if available. An empty string if not.\r\n           */\n\n\n          function getAttribute(elm, name) {\n            return elm ? elm.getAttribute(name) : '';\n          }\n          /**\r\n           * Remove attribute from the given element.\r\n           *\r\n           * @param {Element|Element[]} elms  - An element where an attribute is removed.\r\n           * @param {string|string[]}      names - Attribute name.\r\n           */\n\n\n          function removeAttribute(elms, names) {\n            toArray(names).forEach(function (name) {\n              toArray(elms).forEach(function (elm) {\n                return elm && elm.removeAttribute(name);\n              });\n            });\n          }\n          /**\r\n           * Return the Rect object of the provided object.\r\n           *\r\n           * @param {Element} elm - An element.\r\n           *\r\n           * @return {ClientRect|DOMRect} - A rect object.\r\n           */\n\n\n          function getRect(elm) {\n            return elm.getBoundingClientRect();\n          }\n          /**\r\n           * Trigger the given callback after all images contained by the element are loaded.\r\n           *\r\n           * @param {Element}  elm      - Element that may contain images.\r\n           * @param {Function} callback - Callback function fired right after all images are loaded.\r\n           */\n\n\n          function loaded(elm, callback) {\n            var images = elm.querySelectorAll('img');\n            var length = images.length;\n\n            if (length) {\n              var count = 0;\n              each(images, function (img) {\n                img.onload = img.onerror = function () {\n                  if (++count === length) {\n                    callback();\n                  }\n                };\n              });\n            } else {\n              // Trigger the callback immediately if there is no image.\n              callback();\n            }\n          }\n\n          ; // CONCATENATED MODULE: ./src/js/constants/types.js\n\n          /**\r\n           * Export slider types.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * Normal slider.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var SLIDE = 'slide';\n          /**\r\n           * Loop after the last slide and before the first one.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var LOOP = 'loop';\n          /**\r\n           * The track doesn't move.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var FADE = 'fade';\n          ; // CONCATENATED MODULE: ./src/js/transitions/slide/index.js\n\n          /**\r\n           * The component for general slide effect transition.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The component for general slide effect transition.\r\n           *\r\n           * @param {Splide} Splide     - A Splide instance.\r\n           * @param {Object} Components - An object containing components.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var slide = function slide(Splide, Components) {\n            /**\r\n             * Hold the list element.\r\n             *\r\n             * @type {Element}\r\n             */\n            var list;\n            /**\r\n             * Hold the onEnd callback function.\r\n             *\r\n             * @type {function}\r\n             */\n\n            var endCallback;\n            return {\n              /**\r\n               * Called when the component is mounted.\r\n               */\n              mount: function mount() {\n                list = Components.Elements.list;\n                Splide.on('transitionend', function (e) {\n                  if (e.target === list && endCallback) {\n                    endCallback();\n                  }\n                }, list);\n              },\n\n              /**\r\n               * Start transition.\r\n               *\r\n               * @param {number}   destIndex - Destination slide index that might be clone's.\r\n               * @param {number}   newIndex  - New index.\r\n               * @param {number}   prevIndex - Previous index.\r\n               * @param {Object}   coord     - Destination coordinates.\r\n               * @param {function} done      - Callback function must be invoked when transition is completed.\r\n               */\n              start: function start(destIndex, newIndex, prevIndex, coord, done) {\n                var options = Splide.options;\n                var edgeIndex = Components.Controller.edgeIndex;\n                var speed = options.speed;\n                endCallback = done;\n\n                if (Splide.is(SLIDE)) {\n                  if (prevIndex === 0 && newIndex >= edgeIndex || prevIndex >= edgeIndex && newIndex === 0) {\n                    speed = options.rewindSpeed || speed;\n                  }\n                }\n\n                applyStyle(list, {\n                  transition: \"transform \" + speed + \"ms \" + options.easing,\n                  transform: \"translate(\" + coord.x + \"px,\" + coord.y + \"px)\"\n                });\n              }\n            };\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/transitions/fade/index.js\n\n          /**\r\n           * The component for fade transition.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The component for fade transition.\r\n           *\r\n           * @param {Splide} Splide     - A Splide instance.\r\n           * @param {Object} Components - An object containing components.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var fade = function fade(Splide, Components) {\n            var Fade = {\n              /**\r\n               * Called when the component is mounted.\r\n               * Apply transition style to the first slide.\r\n               */\n              mount: function mount() {\n                apply(Splide.index);\n              },\n\n              /**\r\n               * Start transition.\r\n               *\r\n               * @param {number}    destIndex - Destination slide index that might be clone's.\r\n               * @param {number}    newIndex  - New index.\r\n               * @param {number}    prevIndex - Previous index.\r\n               * @param {Object}    coord     - Destination coordinates.\r\n               * @param {function}  done      - Callback function must be invoked when transition is completed.\r\n               */\n              start: function start(destIndex, newIndex, prevIndex, coord, done) {\n                var track = Components.Elements.track;\n                applyStyle(track, {\n                  height: unit(track.clientHeight)\n                });\n                apply(newIndex);\n                setTimeout(function () {\n                  done();\n                  applyStyle(track, {\n                    height: ''\n                  });\n                });\n              }\n            };\n            /**\r\n             * Apply transition style to the slide specified by the given index.\r\n             *\r\n             * @param {number} index - A slide index.\r\n             */\n\n            function apply(index) {\n              var options = Splide.options;\n              applyStyle(Components.Elements.slides[index], {\n                transition: \"opacity \" + options.speed + \"ms \" + options.easing\n              });\n            }\n\n            return Fade;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/transitions/index.js\n\n          /**\r\n           * Export transition components.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          ; // CONCATENATED MODULE: ./src/js/core/composer.js\n\n          /**\r\n           * Provide a function for composing components.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * Compose components.\r\n           *\r\n           * @param {Splide}   Splide     - Splide instance.\r\n           * @param {Object}   Components - Additional components.\r\n           * @param {function} Transition - Change component for transition.\r\n           *\r\n           * @return {Object} - An object containing all components.\r\n           */\n\n          function compose(Splide, Components, Transition) {\n            var components = {};\n            each(Components, function (Component, name) {\n              components[name] = Component(Splide, components, name.toLowerCase());\n            });\n\n            if (!Transition) {\n              Transition = Splide.is(FADE) ? fade : slide;\n            }\n\n            components.Transition = Transition(Splide, components);\n            return components;\n          }\n\n          ; // CONCATENATED MODULE: ./src/js/utils/error.js\n\n          /**\r\n           * Utility functions for outputting logs.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * Prefix of an error massage.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var MESSAGE_PREFIX = '[SPLIDE]';\n          /**\r\n           * Display an error message on the browser console.\r\n           *\r\n           * @param {string} message - An error message.\r\n           */\n\n          function error(message) {\n            console.error(MESSAGE_PREFIX + \" \" + message);\n          }\n          /**\r\n           * Check existence of the given object and throw an error if it doesn't.\r\n           *\r\n           * @throws {Error}\r\n           *\r\n           * @param {*}      subject - A subject to be confirmed.\r\n           * @param {string} message - An error message.\r\n           */\n\n\n          function exist(subject, message) {\n            if (!subject) {\n              throw new Error(message);\n            }\n          }\n\n          ; // CONCATENATED MODULE: ./src/js/constants/classes.js\n\n          /**\r\n           * Export class names.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * A root class name.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var ROOT = 'splide';\n          /**\r\n           * The definition table of all classes for elements.\r\n           * They might be modified by options.\r\n           *\r\n           * @type {Object}\r\n           */\n\n          var ELEMENT_CLASSES = {\n            root: ROOT,\n            slider: ROOT + \"__slider\",\n            track: ROOT + \"__track\",\n            list: ROOT + \"__list\",\n            slide: ROOT + \"__slide\",\n            container: ROOT + \"__slide__container\",\n            arrows: ROOT + \"__arrows\",\n            arrow: ROOT + \"__arrow\",\n            prev: ROOT + \"__arrow--prev\",\n            next: ROOT + \"__arrow--next\",\n            pagination: ROOT + \"__pagination\",\n            page: ROOT + \"__pagination__page\",\n            clone: ROOT + \"__slide--clone\",\n            progress: ROOT + \"__progress\",\n            bar: ROOT + \"__progress__bar\",\n            autoplay: ROOT + \"__autoplay\",\n            play: ROOT + \"__play\",\n            pause: ROOT + \"__pause\",\n            spinner: ROOT + \"__spinner\",\n            sr: ROOT + \"__sr\"\n          };\n          /**\r\n           * Definitions of status classes.\r\n           *\r\n           * @type {Object}\r\n           */\n\n          var STATUS_CLASSES = {\n            active: 'is-active',\n            visible: 'is-visible',\n            loading: 'is-loading'\n          };\n          ; // CONCATENATED MODULE: ./src/js/constants/i18n.js\n\n          /**\r\n           * Export i18n texts as object.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * Texts for i18n.\r\n           *\r\n           * @type {Object}\r\n           */\n\n          var I18N = {\n            prev: 'Previous slide',\n            next: 'Next slide',\n            first: 'Go to first slide',\n            last: 'Go to last slide',\n            slideX: 'Go to slide %s',\n            pageX: 'Go to page %s',\n            play: 'Start autoplay',\n            pause: 'Pause autoplay'\n          };\n          ; // CONCATENATED MODULE: ./src/js/constants/defaults.js\n\n          /**\r\n           * Export default options.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          var DEFAULTS = {\n            /**\r\n             * Determine a slider type.\r\n             * - 'slide': Regular slider.\r\n             * - 'loop' : Carousel slider.\r\n             * - 'fade' : Change slides with fade transition. perPage, drag options are ignored.\r\n             *\r\n             * @type {string}\r\n             */\n            type: 'slide',\n\n            /**\r\n             * Whether to rewind a slider before the first slide or after the last one.\r\n             * In \"loop\" mode, this option is ignored.\r\n             *\r\n             * @type {boolean}\r\n             */\n            rewind: false,\n\n            /**\r\n             * Transition speed in milliseconds.\r\n             *\r\n             * @type {number}\r\n             */\n            speed: 400,\n\n            /**\r\n             * Transition speed on rewind in milliseconds.\r\n             *\r\n             * @type {number}\r\n             */\n            rewindSpeed: 0,\n\n            /**\r\n             * Whether to prevent any actions while a slider is transitioning.\r\n             * If false, navigation, drag and swipe work while the slider is running.\r\n             * Even so, it will be forced to wait for transition in some cases in the loop mode to shift a slider.\r\n             *\r\n             * @type {boolean}\r\n             */\n            waitForTransition: true,\n\n            /**\r\n             * Define slider max width.\r\n             *\r\n             * @type {number}\r\n             */\n            width: 0,\n\n            /**\r\n             * Define slider height.\r\n             *\r\n             * @type {number}\r\n             */\n            height: 0,\n\n            /**\r\n             * Fix width of slides. CSS format is allowed such as 10em, 80% or 80vw.\r\n             * perPage number will be ignored when this option is falsy.\r\n             *\r\n             * @type {number|string}\r\n             */\n            fixedWidth: 0,\n\n            /**\r\n             * Fix height of slides. CSS format is allowed such as 10em, 80vh but % unit is not accepted.\r\n             * heightRatio option will be ignored when this option is falsy.\r\n             *\r\n             * @type {number|string}\r\n             */\n            fixedHeight: 0,\n\n            /**\r\n             * Determine height of slides by ratio to a slider width.\r\n             * This will be ignored when the fixedHeight is provided.\r\n             *\r\n             * @type {number}\r\n             */\n            heightRatio: 0,\n\n            /**\r\n             * If true, slide width will be determined by the element width itself.\r\n             * - perPage/perMove should be 1.\r\n             *\r\n             * @type {boolean}\r\n             */\n            autoWidth: false,\n\n            /**\r\n             * If true, slide height will be determined by the element width itself.\r\n             * - perPage/perMove should be 1.\r\n             *\r\n             * @type {boolean}\r\n             */\n            autoHeight: false,\n\n            /**\r\n             * Determine how many slides should be displayed per page.\r\n             *\r\n             * @type {number}\r\n             */\n            perPage: 1,\n\n            /**\r\n             * Determine how many slides should be moved when a slider goes to next or perv.\r\n             *\r\n             * @type {number}\r\n             */\n            perMove: 0,\n\n            /**\r\n             * Determine manually how many clones should be generated on the left and right side.\r\n             * The total number of clones will be twice of this number.\r\n             *\r\n             * @type {number}\r\n             */\n            clones: 0,\n\n            /**\r\n             * Start index.\r\n             *\r\n             * @type {number}\r\n             */\n            start: 0,\n\n            /**\r\n             * Determine which slide should be focused if there are multiple slides in a page.\r\n             * A string \"center\" is acceptable for centering slides.\r\n             *\r\n             * @type {boolean|number|string}\r\n             */\n            focus: false,\n\n            /**\r\n             * Gap between slides. CSS format is allowed such as 1em.\r\n             *\r\n             * @type {number|string}\r\n             */\n            gap: 0,\n\n            /**\r\n             * Set padding-left/right in horizontal mode or padding-top/bottom in vertical one.\r\n             * Give a single value to set a same size for both sides or\r\n             * do an object for different sizes.\r\n             * Also, CSS format is allowed such as 1em.\r\n             *\r\n             * @example\r\n             * - 10: Number\r\n             * - '1em': CSS format.\r\n             * - { left: 0, right: 20 }: Object for different sizes in horizontal mode.\r\n             * - { top: 0, bottom: 20 }: Object for different sizes in vertical mode.\r\n             *\r\n             * @type {number|string|Object}\r\n             */\n            padding: 0,\n\n            /**\r\n             * Whether to append arrows.\r\n             *\r\n             * @type {boolean}\r\n             */\n            arrows: true,\n\n            /**\r\n             * Change the arrow SVG path like 'm7.61 0.807-2.12...'.\r\n             *\r\n             * @type {string}\r\n             */\n            arrowPath: '',\n\n            /**\r\n             * Whether to append pagination(indicator dots) or not.\r\n             *\r\n             * @type {boolean}\r\n             */\n            pagination: true,\n\n            /**\r\n             * Activate autoplay.\r\n             *\r\n             * @type {boolean}\r\n             */\n            autoplay: false,\n\n            /**\r\n             * Autoplay interval in milliseconds.\r\n             *\r\n             * @type {number}\r\n             */\n            interval: 5000,\n\n            /**\r\n             * Whether to stop autoplay when a slider is hovered.\r\n             *\r\n             * @type {boolean}\r\n             */\n            pauseOnHover: true,\n\n            /**\r\n             * Whether to stop autoplay when a slider elements are focused.\r\n             * True is recommended for accessibility.\r\n             *\r\n             * @type {boolean}\r\n             */\n            pauseOnFocus: true,\n\n            /**\r\n             * Whether to reset progress of the autoplay timer when resumed.\r\n             *\r\n             * @type {boolean}\r\n             */\n            resetProgress: true,\n\n            /**\r\n             * Loading images lazily.\r\n             * Image src must be provided by a data-splide-lazy attribute.\r\n             *\r\n             * - false: Do nothing.\r\n             * - 'nearby': Only images around an active slide will be loaded.\r\n             * - 'sequential': All images will be sequentially loaded.\r\n             *\r\n             * @type {boolean|string}\r\n             */\n            lazyLoad: false,\n\n            /**\r\n             * This option works only when a lazyLoad option is \"nearby\".\r\n             * Determine how many pages(not slides) around an active slide should be loaded beforehand.\r\n             *\r\n             * @type {number}\r\n             */\n            preloadPages: 1,\n\n            /**\r\n             * Easing for CSS transition. For example, linear, ease or cubic-bezier().\r\n             *\r\n             * @type {string}\r\n             */\n            easing: 'cubic-bezier(.42,.65,.27,.99)',\n\n            /**\r\n             * Whether to enable keyboard shortcuts\r\n             * - true or 'global': Listen to keydown event of the document.\r\n             * - 'focused': Listen to the keydown event of the slider root element. tabindex=\"0\" will be added to the element.\r\n             * - false: Disable keyboard shortcuts.\r\n             *\r\n             * @type {boolean|string}\r\n             */\n            keyboard: 'global',\n\n            /**\r\n             * Whether to allow mouse drag and touch swipe.\r\n             *\r\n             * @type {boolean}\r\n             */\n            drag: true,\n\n            /**\r\n             * The angle threshold for drag.\r\n             * The slider starts moving only when the drag angle is less than this threshold.\r\n             *\r\n             * @type {number}\r\n             */\n            dragAngleThreshold: 30,\n\n            /**\r\n             * Distance threshold for determining if the action is \"flick\" or \"swipe\".\r\n             * When a drag distance is over this value, the action will be treated as \"swipe\", not \"flick\".\r\n             *\r\n             * @type {number}\r\n             */\n            swipeDistanceThreshold: 150,\n\n            /**\r\n             * Velocity threshold for determining if the action is \"flick\" or \"swipe\".\r\n             * Around 0.5 is recommended.\r\n             *\r\n             * @type {number}\r\n             */\n            flickVelocityThreshold: .6,\n\n            /**\r\n             * Determine power of flick. The larger number this is, the farther a slider runs by flick.\r\n             * Around 500 is recommended.\r\n             *\r\n             * @type {number}\r\n             */\n            flickPower: 600,\n\n            /**\r\n             * Limit a number of pages to move by flick.\r\n             *\r\n             * @type {number}\r\n             */\n            flickMaxPages: 1,\n\n            /**\r\n             * Slider direction.\r\n             * - 'ltr': Left to right.\r\n             * - 'rtl': Right to left.\r\n             * - 'ttb': Top to bottom.\r\n             *\r\n             * @type {string}\r\n             */\n            direction: 'ltr',\n\n            /**\r\n             * Set img src to background-image of its parent element.\r\n             * Images with various sizes can be displayed as same dimension without cropping work.\r\n             * fixedHeight or heightRatio is required.\r\n             *\r\n             * @type {boolean}\r\n             */\n            cover: false,\n\n            /**\r\n             * Whether to enable accessibility(aria and screen reader texts) or not.\r\n             *\r\n             * @type {boolean}\r\n             */\n            accessibility: true,\n\n            /**\r\n             * Whether to add tabindex=\"0\" to visible slides or not.\r\n             *\r\n             * @type {boolean}\r\n             */\n            slideFocus: true,\n\n            /**\r\n             * Determine if a slider is navigation for another.\r\n             * Use \"sync\" API to synchronize two sliders.\r\n             *\r\n             * @type {boolean}\r\n             */\n            isNavigation: false,\n\n            /**\r\n             * Whether to trim spaces before the fist slide or after the last one when \"focus\" is not 0.\r\n             *\r\n             * @type {boolean}\r\n             */\n            trimSpace: true,\n\n            /**\r\n             * The \"is-active\" class is added after transition as default.\r\n             * If true, it will be added before move.\r\n             *\r\n             * @type {boolean}\r\n             */\n            updateOnMove: false,\n\n            /**\r\n             * Throttle duration in milliseconds for the resize event.\r\n             *\r\n             * @type {number}\r\n             */\n            throttle: 100,\n\n            /**\r\n             * Whether to destroy a slider or not.\r\n             *\r\n             * @type {boolean}\r\n             */\n            destroy: false,\n\n            /**\r\n             * Options for specific breakpoints.\r\n             *\r\n             * @example\r\n             * {\r\n             *   1000: {\r\n             *     perPage: 3,\r\n             *     gap: 20\r\n             *   },\r\n             *   600: {\r\n             *     perPage: 1,\r\n             *     gap: 5,\r\n             *   }\r\n             * }\r\n             *\r\n             * @type {boolean|Object}\r\n             */\n            breakpoints: false,\n\n            /**\r\n             * Collection of class names.\r\n             *\r\n             * @see ./classes.js\r\n             *\r\n             * @type {Object}\r\n             */\n            classes: ELEMENT_CLASSES,\n\n            /**\r\n             * Collection of i18n texts.\r\n             *\r\n             * @see ./i18n.js\r\n             *\r\n             * @type {Object}\r\n             */\n            i18n: I18N\n          };\n          ; // CONCATENATED MODULE: ./src/js/constants/states.js\n\n          /**\r\n           * Export state constants.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * Splide has been just created.\r\n           *\r\n           * @type {number}\r\n           */\n\n          var _CREATED = 1;\n          /**\r\n           * All components have been mounted and initialized.\r\n           *\r\n           * @type {number}\r\n           */\n\n          var _MOUNTED = 2;\n          /**\r\n           * Splide is ready for transition.\r\n           *\r\n           * @type {number}\r\n           */\n\n          var _IDLE = 3;\n          /**\r\n           * Splide is moving.\r\n           *\r\n           * @type {number}\r\n           */\n\n          var _MOVING = 4;\n          /**\r\n           * Splide is moving.\r\n           *\r\n           * @type {number}\r\n           */\n\n          var _DESTROYED = 5;\n          ; // CONCATENATED MODULE: ./src/js/splide.js\n\n          function _defineProperties(target, props) {\n            for (var i = 0; i < props.length; i++) {\n              var descriptor = props[i];\n              descriptor.enumerable = descriptor.enumerable || false;\n              descriptor.configurable = true;\n              if (\"value\" in descriptor) descriptor.writable = true;\n              Object.defineProperty(target, descriptor.key, descriptor);\n            }\n          }\n\n          function _createClass(Constructor, protoProps, staticProps) {\n            if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n            if (staticProps) _defineProperties(Constructor, staticProps);\n            return Constructor;\n          }\n          /**\r\n           * The main class for applying Splide to an element.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The main class for applying Splide to an element,\r\n           * providing some APIs to control the behavior.\r\n           */\n\n\n          var Splide = /*#__PURE__*/function () {\n            /**\r\n             * Splide constructor.\r\n             *\r\n             * @throws {Error} When the given root element or selector is invalid.\r\n             *\r\n             * @param {Element|string}  root       - A selector for a root element or an element itself.\r\n             * @param {Object}          options    - Optional. Options to change default behaviour.\r\n             * @param {Object}          Components - Optional. Components.\r\n             */\n            function Splide(root, options, Components) {\n              if (options === void 0) {\n                options = {};\n              }\n\n              if (Components === void 0) {\n                Components = {};\n              }\n\n              this.root = root instanceof Element ? root : document.querySelector(root);\n              exist(this.root, 'An invalid element/selector was given.');\n              this.Components = null;\n              this.Event = core_event();\n              this.State = state(_CREATED);\n              this.STATES = states_namespaceObject;\n              this._o = merge(DEFAULTS, options);\n              this._i = 0;\n              this._c = Components;\n              this._e = {}; // Extensions\n\n              this._t = null; // Transition\n            }\n            /**\r\n             * Compose and mount components.\r\n             *\r\n             * @param {Object}   Extensions - Optional. Additional components.\r\n             * @param {function} Transition - Optional. Set a custom transition component.\r\n             *\r\n             * @return {Splide|undefined} - This instance or undefined if an exception occurred.\r\n             */\n\n\n            var _proto = Splide.prototype;\n\n            _proto.mount = function mount(Extensions, Transition) {\n              var _this = this;\n\n              if (Extensions === void 0) {\n                Extensions = this._e;\n              }\n\n              if (Transition === void 0) {\n                Transition = this._t;\n              } // Reset the state.\n\n\n              this.State.set(_CREATED);\n              this._e = Extensions;\n              this._t = Transition;\n              this.Components = compose(this, merge(this._c, Extensions), Transition);\n\n              try {\n                each(this.Components, function (component, key) {\n                  var required = component.required;\n\n                  if (required === undefined || required) {\n                    component.mount && component.mount();\n                  } else {\n                    delete _this.Components[key];\n                  }\n                });\n              } catch (e) {\n                error(e.message);\n                return;\n              }\n\n              var State = this.State;\n              State.set(_MOUNTED);\n              each(this.Components, function (component) {\n                component.mounted && component.mounted();\n              });\n              this.emit('mounted');\n              State.set(_IDLE);\n              this.emit('ready');\n              applyStyle(this.root, {\n                visibility: 'visible'\n              });\n              this.on('move drag', function () {\n                return State.set(_MOVING);\n              }).on('moved dragged', function () {\n                return State.set(_IDLE);\n              });\n              return this;\n            }\n            /**\r\n             * Set sync target.\r\n             *\r\n             * @param {Splide} splide - A Splide instance.\r\n             *\r\n             * @return {Splide} - This instance.\r\n             */\n            ;\n\n            _proto.sync = function sync(splide) {\n              this.sibling = splide;\n              return this;\n            }\n            /**\r\n             * Register callback fired on the given event(s).\r\n             *\r\n             * @param {string}   events  - An event name. Use space to separate multiple events.\r\n             *                             Also, namespace is accepted by dot, such as 'resize.{namespace}'.\r\n             * @param {function} handler - A callback function.\r\n             * @param {Element}  elm     - Optional. Native event will be listened to when this arg is provided.\r\n             * @param {Object}   options - Optional. Options for addEventListener.\r\n             *\r\n             * @return {Splide} - This instance.\r\n             */\n            ;\n\n            _proto.on = function on(events, handler, elm, options) {\n              if (elm === void 0) {\n                elm = null;\n              }\n\n              if (options === void 0) {\n                options = {};\n              }\n\n              this.Event.on(events, handler, elm, options);\n              return this;\n            }\n            /**\r\n             * Unsubscribe the given event.\r\n             *\r\n             * @param {string}  events - A event name.\r\n             * @param {Element} elm    - Optional. removeEventListener() will be called when this arg is provided.\r\n             *\r\n             * @return {Splide} - This instance.\r\n             */\n            ;\n\n            _proto.off = function off(events, elm) {\n              if (elm === void 0) {\n                elm = null;\n              }\n\n              this.Event.off(events, elm);\n              return this;\n            }\n            /**\r\n             * Emit an event.\r\n             *\r\n             * @param {string} event - An event name.\r\n             * @param {*}      args  - Any number of arguments passed to handlers.\r\n             */\n            ;\n\n            _proto.emit = function emit(event) {\n              var _this$Event;\n\n              for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n                args[_key - 1] = arguments[_key];\n              }\n\n              (_this$Event = this.Event).emit.apply(_this$Event, [event].concat(args));\n\n              return this;\n            }\n            /**\r\n             * Go to the slide specified by the given control.\r\n             *\r\n             * @param {string|number} control - A control pattern.\r\n             * @param {boolean}       wait    - Optional. Whether to wait for transition.\r\n             */\n            ;\n\n            _proto.go = function go(control, wait) {\n              if (wait === void 0) {\n                wait = this.options.waitForTransition;\n              }\n\n              if (this.State.is(_IDLE) || this.State.is(_MOVING) && !wait) {\n                this.Components.Controller.go(control, false);\n              }\n\n              return this;\n            }\n            /**\r\n             * Verify whether the slider type is the given one or not.\r\n             *\r\n             * @param {string} type - A slider type.\r\n             *\r\n             * @return {boolean} - True if the slider type is the provided type or false if not.\r\n             */\n            ;\n\n            _proto.is = function is(type) {\n              return type === this._o.type;\n            }\n            /**\r\n             * Insert a slide.\r\n             *\r\n             * @param {Element|string} slide - A slide element to be added.\r\n             * @param {number}         index - A slide will be added at the position.\r\n             */\n            ;\n\n            _proto.add = function add(slide, index) {\n              if (index === void 0) {\n                index = -1;\n              }\n\n              this.Components.Elements.add(slide, index, this.refresh.bind(this));\n              return this;\n            }\n            /**\r\n             * Remove the slide designated by the index.\r\n             *\r\n             * @param {number} index - A slide index.\r\n             */\n            ;\n\n            _proto.remove = function remove(index) {\n              this.Components.Elements.remove(index);\n              this.refresh();\n              return this;\n            }\n            /**\r\n             * Destroy all Slide objects and clones and recreate them again.\r\n             */\n            ;\n\n            _proto.refresh = function refresh() {\n              this.emit('refresh:before').emit('refresh').emit('resize');\n              return this;\n            }\n            /**\r\n             * Destroy the Splide.\r\n             * \"Completely\" boolean is mainly for breakpoints.\r\n             *\r\n             * @param {boolean} completely - Destroy completely.\r\n             */\n            ;\n\n            _proto.destroy = function destroy(completely) {\n              var _this2 = this;\n\n              if (completely === void 0) {\n                completely = true;\n              } // Postpone destroy because it should be done after mount.\n\n\n              if (this.State.is(_CREATED)) {\n                this.on('ready', function () {\n                  return _this2.destroy(completely);\n                });\n                return;\n              }\n\n              values(this.Components).reverse().forEach(function (component) {\n                component.destroy && component.destroy(completely);\n              });\n              this.emit('destroy', completely); // Destroy all event handlers, including ones for native events.\n\n              this.Event.destroy();\n              this.State.set(_DESTROYED);\n              return this;\n            }\n            /**\r\n             * Return the current slide index.\r\n             *\r\n             * @return {number} - The current slide index.\r\n             // */\n            ;\n\n            _createClass(Splide, [{\n              key: \"index\",\n              get: function get() {\n                return this._i;\n              }\n              /**\r\n               * Set the current slide index.\r\n               *\r\n               * @param {number|string} index - A new index.\r\n               */\n              ,\n              set: function set(index) {\n                this._i = parseInt(index);\n              }\n              /**\r\n               * Return length of slides.\r\n               * This is an alias of Elements.length.\r\n               *\r\n               * @return {number} - A number of slides.\r\n               */\n\n            }, {\n              key: \"length\",\n              get: function get() {\n                return this.Components.Elements.length;\n              }\n              /**\r\n               * Return options.\r\n               *\r\n               * @return {Object} - Options object.\r\n               */\n\n            }, {\n              key: \"options\",\n              get: function get() {\n                return this._o;\n              }\n              /**\r\n               * Set options with merging the given object to the current one.\r\n               *\r\n               * @param {Object} options - New options.\r\n               */\n              ,\n              set: function set(options) {\n                var created = this.State.is(_CREATED);\n\n                if (!created) {\n                  this.emit('update');\n                }\n\n                this._o = merge(this._o, options);\n\n                if (!created) {\n                  this.emit('updated', this._o);\n                }\n              }\n              /**\r\n               * Return the class list.\r\n               * This is an alias of Splide.options.classList.\r\n               *\r\n               * @return {Object} - An object containing all class list.\r\n               */\n\n            }, {\n              key: \"classes\",\n              get: function get() {\n                return this._o.classes;\n              }\n              /**\r\n               * Return the i18n strings.\r\n               * This is an alias of Splide.options.i18n.\r\n               *\r\n               * @return {Object} - An object containing all i18n strings.\r\n               */\n\n            }, {\n              key: \"i18n\",\n              get: function get() {\n                return this._o.i18n;\n              }\n            }]);\n\n            return Splide;\n          }();\n\n          ; // CONCATENATED MODULE: ./src/js/components/options/index.js\n\n          /**\r\n           * The component for initializing options.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The component for initializing options.\r\n           *\r\n           * @param {Splide} Splide - A Splide instance.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var options = function options(Splide) {\n            /**\r\n             * Retrieve options from the data attribute.\r\n             * Note that IE10 doesn't support dataset property.\r\n             *\r\n             * @type {string}\r\n             */\n            var options = getAttribute(Splide.root, 'data-splide');\n\n            if (options) {\n              try {\n                Splide.options = JSON.parse(options);\n              } catch (e) {\n                error(e.message);\n              }\n            }\n\n            return {\n              /**\r\n               * Called when the component is mounted.\r\n               */\n              mount: function mount() {\n                if (Splide.State.is(_CREATED)) {\n                  Splide.index = Splide.options.start;\n                }\n              }\n            };\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/constants/directions.js\n\n          /**\r\n           * Export layout modes.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * Enumerate slides from left to right.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var LTR = 'ltr';\n          /**\r\n           * Enumerate slides from right to left.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var RTL = 'rtl';\n          /**\r\n           * Enumerate slides in a col.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var TTB = 'ttb';\n          ; // CONCATENATED MODULE: ./src/js/components/elements/slide.js\n\n          /**\r\n           * The sub component for handling each slide.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * Events for restoring original styles.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var STYLE_RESTORE_EVENTS = 'update.slide';\n          /**\r\n           * The sub component for handling each slide.\r\n           *\r\n           * @param {Splide}  Splide    - A Splide instance.\r\n           * @param {number}  index     - An unique slide index.\r\n           * @param {number}  realIndex - Clones should pass a real slide index.\r\n           * @param {Element} slide     - A slide element.\r\n           *\r\n           * @return {Object} - The sub component object.\r\n           */\n\n          /* harmony default export */\n\n          var elements_slide = function elements_slide(Splide, index, realIndex, slide) {\n            /**\r\n             * Whether to update \"is-active\" class before or after transition.\r\n             *\r\n             * @type {boolean}\r\n             */\n            var updateOnMove = Splide.options.updateOnMove;\n            /**\r\n             * Events when the slide status is updated.\r\n             * Append a namespace to remove listeners later.\r\n             *\r\n             * @type {string}\r\n             */\n\n            var STATUS_UPDATE_EVENTS = 'ready.slide updated.slide resized.slide moved.slide' + (updateOnMove ? ' move.slide' : '');\n            /**\r\n             * Slide sub component object.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Slide = {\n              /**\r\n               * Slide element.\r\n               *\r\n               * @type {Element}\r\n               */\n              slide: slide,\n\n              /**\r\n               * Slide index.\r\n               *\r\n               * @type {number}\r\n               */\n              index: index,\n\n              /**\r\n               * Real index for clones.\r\n               *\r\n               * @type {number}\r\n               */\n              realIndex: realIndex,\n\n              /**\r\n               * Container element if available.\r\n               *\r\n               * @type {Element|undefined}\r\n               */\n              container: child(slide, Splide.classes.container),\n\n              /**\r\n               * Whether this is a cloned slide or not.\r\n               *\r\n               * @type {boolean}\r\n               */\n              isClone: realIndex > -1,\n\n              /**\r\n               * Called when the component is mounted.\r\n               */\n              mount: function mount() {\n                var _this = this;\n\n                if (!this.isClone) {\n                  slide.id = Splide.root.id + \"-slide\" + pad(index + 1);\n                }\n\n                Splide.on(STATUS_UPDATE_EVENTS, function () {\n                  return _this.update();\n                }).on(STYLE_RESTORE_EVENTS, restoreStyles).on('click', function () {\n                  return Splide.emit('click', _this);\n                }, slide);\n                /*\r\n                 * Add \"is-active\" class to a clone element temporarily\r\n                 * and it will be removed on \"moved\" event.\r\n                 */\n\n                if (updateOnMove) {\n                  Splide.on('move.slide', function (newIndex) {\n                    if (newIndex === realIndex) {\n                      _update(true, false);\n                    }\n                  });\n                } // Make sure the slide is shown.\n\n\n                applyStyle(slide, {\n                  display: ''\n                }); // Hold the original styles.\n\n                this.styles = getAttribute(slide, 'style') || '';\n              },\n\n              /**\r\n               * Destroy.\r\n               */\n              destroy: function destroy() {\n                Splide.off(STATUS_UPDATE_EVENTS).off(STYLE_RESTORE_EVENTS).off('click', slide);\n                removeClass(slide, values(STATUS_CLASSES));\n                restoreStyles();\n                removeAttribute(this.container, 'style');\n              },\n\n              /**\r\n               * Update active and visible status.\r\n               */\n              update: function update() {\n                _update(this.isActive(), false);\n\n                _update(this.isVisible(), true);\n              },\n\n              /**\r\n               * Check whether this slide is active or not.\r\n               *\r\n               * @return {boolean} - True if the slide is active or false if not.\r\n               */\n              isActive: function isActive() {\n                return Splide.index === index;\n              },\n\n              /**\r\n               * Check whether this slide is visible in the viewport or not.\r\n               *\r\n               * @return {boolean} - True if the slide is visible or false if not.\r\n               */\n              isVisible: function isVisible() {\n                var active = this.isActive();\n\n                if (Splide.is(FADE) || active) {\n                  return active;\n                }\n\n                var ceil = Math.ceil;\n                var trackRect = getRect(Splide.Components.Elements.track);\n                var slideRect = getRect(slide);\n\n                if (Splide.options.direction === TTB) {\n                  return trackRect.top <= slideRect.top && slideRect.bottom <= ceil(trackRect.bottom);\n                }\n\n                return trackRect.left <= slideRect.left && slideRect.right <= ceil(trackRect.right);\n              },\n\n              /**\r\n               * Calculate how far this slide is from another slide and\r\n               * return true if the distance is within the given number.\r\n               *\r\n               * @param {number} from   - Index of a target slide.\r\n               * @param {number} within - True if the slide is within this number.\r\n               *\r\n               * @return {boolean} - True if the slide is within the number or false otherwise.\r\n               */\n              isWithin: function isWithin(from, within) {\n                var diff = Math.abs(from - index);\n\n                if (!Splide.is(SLIDE) && !this.isClone) {\n                  diff = Math.min(diff, Splide.length - diff);\n                }\n\n                return diff < within;\n              }\n            };\n            /**\r\n             * Update classes for activity or visibility.\r\n             *\r\n             * @param {boolean} active        - Is active/visible or not.\r\n             * @param {boolean} forVisibility - Toggle classes for activity or visibility.\r\n             */\n\n            function _update(active, forVisibility) {\n              var type = forVisibility ? 'visible' : 'active';\n              var className = STATUS_CLASSES[type];\n\n              if (active) {\n                addClass(slide, className);\n                Splide.emit(\"\" + type, Slide);\n              } else {\n                if (hasClass(slide, className)) {\n                  removeClass(slide, className);\n                  Splide.emit(\"\" + (forVisibility ? 'hidden' : 'inactive'), Slide);\n                }\n              }\n            }\n            /**\r\n             * Restore the original styles.\r\n             */\n\n\n            function restoreStyles() {\n              setAttribute(slide, 'style', Slide.styles);\n            }\n\n            return Slide;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/components/elements/index.js\n\n          /**\r\n           * The component for main elements.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The property name for UID stored in a window object.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var UID_NAME = 'uid';\n          /**\r\n           * The component for main elements.\r\n           *\r\n           * @param {Splide} Splide     - A Splide instance.\r\n           * @param {Object} Components - An object containing components.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var components_elements = function components_elements(Splide, Components) {\n            /**\r\n             * Hold the root element.\r\n             *\r\n             * @type {Element}\r\n             */\n            var root = Splide.root;\n            /**\r\n             * Hold the class list.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var classes = Splide.classes;\n            /**\r\n             * Store Slide objects.\r\n             *\r\n             * @type {Array}\r\n             */\n\n            var Slides = [];\n            /*\r\n             * Assign unique ID to the root element if it doesn't have the one.\r\n             * Note that IE doesn't support padStart() to fill the uid by 0.\r\n             */\n\n            if (!root.id) {\n              window.splide = window.splide || {};\n              var uid = window.splide[UID_NAME] || 0;\n              window.splide[UID_NAME] = ++uid;\n              root.id = \"splide\" + pad(uid);\n            }\n            /**\r\n             * Elements component object.\r\n             *\r\n             * @type {Object}\r\n             */\n\n\n            var Elements = {\n              /**\r\n               * Called when the component is mounted.\r\n               * Collect main elements and store them as member properties.\r\n               */\n              mount: function mount() {\n                var _this = this;\n\n                this.init();\n                Splide.on('refresh', function () {\n                  _this.destroy();\n\n                  _this.init();\n                }).on('updated', function () {\n                  removeClass(root, getClasses());\n                  addClass(root, getClasses());\n                });\n              },\n\n              /**\r\n               * Destroy.\r\n               */\n              destroy: function destroy() {\n                Slides.forEach(function (Slide) {\n                  Slide.destroy();\n                });\n                Slides = [];\n                removeClass(root, getClasses());\n              },\n\n              /**\r\n               * Initialization.\r\n               */\n              init: function init() {\n                var _this2 = this;\n\n                collect();\n                addClass(root, getClasses());\n                this.slides.forEach(function (slide, index) {\n                  _this2.register(slide, index, -1);\n                });\n              },\n\n              /**\r\n               * Register a slide to create a Slide object and handle its behavior.\r\n               *\r\n               * @param {Element} slide     - A slide element.\r\n               * @param {number}  index     - A unique index. This can be negative.\r\n               * @param {number}  realIndex - A real index for clones. Set -1 for real slides.\r\n               */\n              register: function register(slide, index, realIndex) {\n                var SlideObject = elements_slide(Splide, index, realIndex, slide);\n                SlideObject.mount();\n                Slides.push(SlideObject);\n              },\n\n              /**\r\n               * Return the Slide object designated by the index.\r\n               * Note that \"find\" is not supported by IE.\r\n               *\r\n               * @return {Object|undefined} - A Slide object if available. Undefined if not.\r\n               */\n              getSlide: function getSlide(index) {\n                return Slides.filter(function (Slide) {\n                  return Slide.index === index;\n                })[0];\n              },\n\n              /**\r\n               * Return all Slide objects.\r\n               *\r\n               * @param {boolean} includeClones - Whether to include cloned slides or not.\r\n               *\r\n               * @return {Object[]} - Slide objects.\r\n               */\n              getSlides: function getSlides(includeClones) {\n                return includeClones ? Slides : Slides.filter(function (Slide) {\n                  return !Slide.isClone;\n                });\n              },\n\n              /**\r\n               * Return Slide objects belonging to the given page.\r\n               *\r\n               * @param {number} page - A page number.\r\n               *\r\n               * @return {Object[]} - An array containing Slide objects.\r\n               */\n              getSlidesByPage: function getSlidesByPage(page) {\n                var idx = Components.Controller.toIndex(page);\n                var options = Splide.options;\n                var max = options.focus !== false ? 1 : options.perPage;\n                return Slides.filter(function (_ref) {\n                  var index = _ref.index;\n                  return idx <= index && index < idx + max;\n                });\n              },\n\n              /**\r\n               * Insert a slide to a slider.\r\n               * Need to refresh Splide after adding a slide.\r\n               *\r\n               * @param {Node|string} slide    - A slide element to be added.\r\n               * @param {number}      index    - A slide will be added at the position.\r\n               * @param {Function}    callback - Called right after the slide is added to the DOM tree.\r\n               */\n              add: function add(slide, index, callback) {\n                if (typeof slide === 'string') {\n                  slide = domify(slide);\n                }\n\n                if (slide instanceof Element) {\n                  var ref = this.slides[index]; // This will be removed in mount() of a Slide component.\n\n                  applyStyle(slide, {\n                    display: 'none'\n                  });\n\n                  if (ref) {\n                    before(slide, ref);\n                    this.slides.splice(index, 0, slide);\n                  } else {\n                    append(this.list, slide);\n                    this.slides.push(slide);\n                  }\n\n                  loaded(slide, function () {\n                    callback && callback(slide);\n                  });\n                }\n              },\n\n              /**\r\n               * Remove a slide from a slider.\r\n               * Need to refresh Splide after removing a slide.\r\n               *\r\n               * @param index - Slide index.\r\n               */\n              remove: function remove(index) {\n                dom_remove(this.slides.splice(index, 1)[0]);\n              },\n\n              /**\r\n               * Trigger the provided callback for each Slide object.\r\n               *\r\n               * @param {Function} callback - A callback function. The first argument will be the Slide object.\r\n               */\n              each: function each(callback) {\n                Slides.forEach(callback);\n              },\n\n              /**\r\n               * Return slides length without clones.\r\n               *\r\n               * @return {number} - Slide length.\r\n               */\n              get length() {\n                return this.slides.length;\n              },\n\n              /**\r\n               * Return \"SlideObjects\" length including clones.\r\n               *\r\n               * @return {number} - Slide length including clones.\r\n               */\n              get total() {\n                return Slides.length;\n              }\n\n            };\n            /**\r\n             * Collect elements.\r\n             */\n\n            function collect() {\n              Elements.slider = child(root, classes.slider);\n              Elements.track = find(root, \".\" + classes.track);\n              Elements.list = child(Elements.track, classes.list);\n              exist(Elements.track && Elements.list, 'Track or list was not found.');\n              Elements.slides = children(Elements.list, classes.slide);\n              var arrows = findParts(classes.arrows);\n              Elements.arrows = {\n                prev: find(arrows, \".\" + classes.prev),\n                next: find(arrows, \".\" + classes.next)\n              };\n              var autoplay = findParts(classes.autoplay);\n              Elements.bar = find(findParts(classes.progress), \".\" + classes.bar);\n              Elements.play = find(autoplay, \".\" + classes.play);\n              Elements.pause = find(autoplay, \".\" + classes.pause);\n              Elements.track.id = Elements.track.id || root.id + \"-track\";\n              Elements.list.id = Elements.list.id || root.id + \"-list\";\n            }\n            /**\r\n             * Return class names for the root element.\r\n             */\n\n\n            function getClasses() {\n              var rootClass = classes.root;\n              var options = Splide.options;\n              return [rootClass + \"--\" + options.type, rootClass + \"--\" + options.direction, options.drag ? rootClass + \"--draggable\" : '', options.isNavigation ? rootClass + \"--nav\" : '', STATUS_CLASSES.active];\n            }\n            /**\r\n             * Find parts only from children of the root or track.\r\n             *\r\n             * @return {Element} - A found element or undefined.\r\n             */\n\n\n            function findParts(className) {\n              return child(root, className) || child(Elements.slider, className);\n            }\n\n            return Elements;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/components/controller/index.js\n\n          /**\r\n           * The component for controlling the track.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          var floor = Math.floor;\n          /**\r\n           * The component for controlling the track.\r\n           *\r\n           * @param {Splide} Splide     - A Splide instance.\r\n           * @param {Object} Components - An object containing components.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var controller = function controller(Splide, Components) {\n            /**\r\n             * Store current options.\r\n             *\r\n             * @type {Object}\r\n             */\n            var options;\n            /**\r\n             * True if the slide is LOOP mode.\r\n             *\r\n             * @type {boolean}\r\n             */\n\n            var isLoop;\n            /**\r\n             * Controller component object.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Controller = {\n              /**\r\n               * Called when the component is mounted.\r\n               */\n              mount: function mount() {\n                options = Splide.options;\n                isLoop = Splide.is(LOOP);\n                bind();\n              },\n\n              /**\r\n               * Make track run by the given control.\r\n               * - \"+{i}\" : Increment the slide index by i.\r\n               * - \"-{i}\" : Decrement the slide index by i.\r\n               * - \"{i}\"  : Go to the slide whose index is i.\r\n               * - \">\"    : Go to next page.\r\n               * - \"<\"    : Go to prev page.\r\n               * - \">{i}\" : Go to page i.\r\n               *\r\n               * @param {string|number} control  - A control pattern.\r\n               * @param {boolean}       silently - Go to the destination without event emission.\r\n               */\n              go: function go(control, silently) {\n                var destIndex = this.trim(this.parse(control));\n                Components.Track.go(destIndex, this.rewind(destIndex), silently);\n              },\n\n              /**\r\n               * Parse the given control and return the destination index for the track.\r\n               *\r\n               * @param {string} control - A control target pattern.\r\n               *\r\n               * @return {number} - A parsed target.\r\n               */\n              parse: function parse(control) {\n                var index = Splide.index;\n                var matches = String(control).match(/([+\\-<>]+)(\\d+)?/);\n                var indicator = matches ? matches[1] : '';\n                var number = matches ? parseInt(matches[2]) : 0;\n\n                switch (indicator) {\n                  case '+':\n                    index += number || 1;\n                    break;\n\n                  case '-':\n                    index -= number || 1;\n                    break;\n\n                  case '>':\n                  case '<':\n                    index = parsePage(number, index, indicator === '<');\n                    break;\n\n                  default:\n                    index = parseInt(control);\n                }\n\n                return index;\n              },\n\n              /**\r\n               * Compute index from the given page number.\r\n               *\r\n               * @param {number} page - Page number.\r\n               *\r\n               * @return {number} - A computed page number.\r\n               */\n              toIndex: function toIndex(page) {\n                if (hasFocus()) {\n                  return page;\n                }\n\n                var length = Splide.length;\n                var perPage = options.perPage;\n                var index = page * perPage;\n                index = index - (this.pageLength * perPage - length) * floor(index / length); // Adjustment for the last page.\n\n                if (length - perPage <= index && index < length) {\n                  index = length - perPage;\n                }\n\n                return index;\n              },\n\n              /**\r\n               * Compute page number from the given slide index.\r\n               *\r\n               * @param {number} index - Slide index.\r\n               *\r\n               * @return {number} - A computed page number.\r\n               */\n              toPage: function toPage(index) {\n                if (hasFocus()) {\n                  return index;\n                }\n\n                var length = Splide.length;\n                var perPage = options.perPage; // Make the last \"perPage\" number of slides belong to the last page.\n\n                if (length - perPage <= index && index < length) {\n                  return floor((length - 1) / perPage);\n                }\n\n                return floor(index / perPage);\n              },\n\n              /**\r\n               * Trim the given index according to the current mode.\r\n               * Index being returned could be less than 0 or greater than the length in Loop mode.\r\n               *\r\n               * @param {number} index - An index being trimmed.\r\n               *\r\n               * @return {number} - A trimmed index.\r\n               */\n              trim: function trim(index) {\n                if (!isLoop) {\n                  index = options.rewind ? this.rewind(index) : between(index, 0, this.edgeIndex);\n                }\n\n                return index;\n              },\n\n              /**\r\n               * Rewind the given index if it's out of range.\r\n               *\r\n               * @param {number} index - An index.\r\n               *\r\n               * @return {number} - A rewound index.\r\n               */\n              rewind: function rewind(index) {\n                var edge = this.edgeIndex;\n\n                if (isLoop) {\n                  while (index > edge) {\n                    index -= edge + 1;\n                  }\n\n                  while (index < 0) {\n                    index += edge + 1;\n                  }\n                } else {\n                  if (index > edge) {\n                    index = 0;\n                  } else if (index < 0) {\n                    index = edge;\n                  }\n                }\n\n                return index;\n              },\n\n              /**\r\n               * Check if the direction is \"rtl\" or not.\r\n               *\r\n               * @return {boolean} - True if \"rtl\" or false if not.\r\n               */\n              isRtl: function isRtl() {\n                return options.direction === RTL;\n              },\n\n              /**\r\n               * Return the page length.\r\n               *\r\n               * @return {number} - Max page number.\r\n               */\n              get pageLength() {\n                var length = Splide.length;\n                return hasFocus() ? length : Math.ceil(length / options.perPage);\n              },\n\n              /**\r\n               * Return the edge index.\r\n               *\r\n               * @return {number} - Edge index.\r\n               */\n              get edgeIndex() {\n                var length = Splide.length;\n\n                if (!length) {\n                  return 0;\n                }\n\n                if (hasFocus() || options.isNavigation || isLoop) {\n                  return length - 1;\n                }\n\n                return length - options.perPage;\n              },\n\n              /**\r\n               * Return the index of the previous slide.\r\n               *\r\n               * @return {number} - The index of the previous slide if available. -1 otherwise.\r\n               */\n              get prevIndex() {\n                var prev = Splide.index - 1;\n\n                if (isLoop || options.rewind) {\n                  prev = this.rewind(prev);\n                }\n\n                return prev > -1 ? prev : -1;\n              },\n\n              /**\r\n               * Return the index of the next slide.\r\n               *\r\n               * @return {number} - The index of the next slide if available. -1 otherwise.\r\n               */\n              get nextIndex() {\n                var next = Splide.index + 1;\n\n                if (isLoop || options.rewind) {\n                  next = this.rewind(next);\n                }\n\n                return Splide.index < next && next <= this.edgeIndex || next === 0 ? next : -1;\n              }\n\n            };\n            /**\r\n             * Listen to some events.\r\n             */\n\n            function bind() {\n              Splide.on('move', function (newIndex) {\n                Splide.index = newIndex;\n              }).on('updated refresh', function (newOptions) {\n                options = newOptions || options;\n                Splide.index = between(Splide.index, 0, Controller.edgeIndex);\n              });\n            }\n            /**\r\n             * Verify if the focus option is available or not.\r\n             *\r\n             * @return {boolean} - True if a slider has the focus option.\r\n             */\n\n\n            function hasFocus() {\n              return options.focus !== false;\n            }\n            /**\r\n             * Return the next or previous page index computed by the page number and current index.\r\n             *\r\n             * @param {number}  number - Specify the page number.\r\n             * @param {number}  index  - Current index.\r\n             * @param {boolean} prev   - Prev or next.\r\n             *\r\n             * @return {number} - Slide index.\r\n             */\n\n\n            function parsePage(number, index, prev) {\n              if (number > -1) {\n                return Controller.toIndex(number);\n              }\n\n              var perMove = options.perMove;\n              var sign = prev ? -1 : 1;\n\n              if (perMove) {\n                return index + perMove * sign;\n              }\n\n              return Controller.toIndex(Controller.toPage(index) + sign);\n            }\n\n            return Controller;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/components/track/index.js\n\n          /**\r\n           * The component for moving list in the track.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          var abs = Math.abs;\n          /**\r\n           * The component for moving list in the track.\r\n           *\r\n           * @param {Splide} Splide     - A Splide instance.\r\n           * @param {Object} Components - An object containing components.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var track = function track(Splide, Components) {\n            /**\r\n             * Hold the Layout component.\r\n             *\r\n             * @type {Object}\r\n             */\n            var Layout;\n            /**\r\n             * Hold the Layout component.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Elements;\n            /**\r\n             * Store the list element.\r\n             *\r\n             * @type {Element}\r\n             */\n\n            var list;\n            /**\r\n             * Whether the current direction is vertical or not.\r\n             *\r\n             * @type {boolean}\r\n             */\n\n            var isVertical = Splide.options.direction === TTB;\n            /**\r\n             * Whether the slider type is FADE or not.\r\n             *\r\n             * @type {boolean}\r\n             */\n\n            var isFade = Splide.is(FADE);\n            /**\r\n             * Whether the slider direction is RTL or not.\r\n             *\r\n             * @type {boolean}\r\n             */\n\n            var isRTL = Splide.options.direction === RTL;\n            /**\r\n             * This will be true while transitioning from the last index to the first one.\r\n             *\r\n             * @type {boolean}\r\n             */\n\n            var isLoopPending = false;\n            /**\r\n             * Sign for the direction. Only RTL mode uses the positive sign.\r\n             *\r\n             * @type {number}\r\n             */\n\n            var sign = isRTL ? 1 : -1;\n            /**\r\n             * Track component object.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Track = {\n              /**\r\n               * Make public the sign defined locally.\r\n               *\r\n               * @type {number}\r\n               */\n              sign: sign,\n\n              /**\r\n               * Called when the component is mounted.\r\n               */\n              mount: function mount() {\n                Elements = Components.Elements;\n                Layout = Components.Layout;\n                list = Elements.list;\n              },\n\n              /**\r\n               * Called after the component is mounted.\r\n               * The resize event must be registered after the Layout's one is done.\r\n               */\n              mounted: function mounted() {\n                var _this = this;\n\n                if (!isFade) {\n                  this.jump(0);\n                  Splide.on('mounted resize updated', function () {\n                    _this.jump(Splide.index);\n                  });\n                }\n              },\n\n              /**\r\n               * Go to the given destination index.\r\n               * After arriving there, the track is jump to the new index without animation, mainly for loop mode.\r\n               *\r\n               * @param {number}  destIndex - A destination index.\r\n               *                              This can be negative or greater than slides length for reaching clones.\r\n               * @param {number}  newIndex  - An actual new index. They are always same in Slide and Rewind mode.\r\n               * @param {boolean} silently  - If true, suppress emitting events.\r\n               */\n              go: function go(destIndex, newIndex, silently) {\n                var newPosition = getTrimmedPosition(destIndex);\n                var prevIndex = Splide.index; // Prevent any actions while transitioning from the last index to the first one for jump.\n\n                if (Splide.State.is(_MOVING) && isLoopPending) {\n                  return;\n                }\n\n                isLoopPending = destIndex !== newIndex;\n\n                if (!silently) {\n                  Splide.emit('move', newIndex, prevIndex, destIndex);\n                }\n\n                if (Math.abs(newPosition - this.position) >= 1 || isFade) {\n                  Components.Transition.start(destIndex, newIndex, prevIndex, this.toCoord(newPosition), function () {\n                    onTransitionEnd(destIndex, newIndex, prevIndex, silently);\n                  });\n                } else {\n                  if (destIndex !== prevIndex && Splide.options.trimSpace === 'move') {\n                    Components.Controller.go(destIndex + destIndex - prevIndex, silently);\n                  } else {\n                    onTransitionEnd(destIndex, newIndex, prevIndex, silently);\n                  }\n                }\n              },\n\n              /**\r\n               * Move the track to the specified index.\r\n               *\r\n               * @param {number} index - A destination index where the track jumps.\r\n               */\n              jump: function jump(index) {\n                this.translate(getTrimmedPosition(index));\n              },\n\n              /**\r\n               * Set the list position by CSS translate property.\r\n               *\r\n               * @param {number} position - A new position value.\r\n               */\n              translate: function translate(position) {\n                applyStyle(list, {\n                  transform: \"translate\" + (isVertical ? 'Y' : 'X') + \"(\" + position + \"px)\"\n                });\n              },\n\n              /**\r\n               * Cancel the transition and set the list position.\r\n               * Also, loop the slider if necessary.\r\n               */\n              cancel: function cancel() {\n                if (Splide.is(LOOP)) {\n                  this.shift();\n                } else {\n                  // Ensure the current position.\n                  this.translate(this.position);\n                }\n\n                applyStyle(list, {\n                  transition: ''\n                });\n              },\n\n              /**\r\n               * Shift the slider if it exceeds borders on the edge.\r\n               */\n              shift: function shift() {\n                var position = abs(this.position);\n                var left = abs(this.toPosition(0));\n                var right = abs(this.toPosition(Splide.length));\n                var innerSize = right - left;\n\n                if (position < left) {\n                  position += innerSize;\n                } else if (position > right) {\n                  position -= innerSize;\n                }\n\n                this.translate(sign * position);\n              },\n\n              /**\r\n               * Trim redundant spaces on the left or right edge if necessary.\r\n               *\r\n               * @param {number} position - Position value to be trimmed.\r\n               *\r\n               * @return {number} - Trimmed position.\r\n               */\n              trim: function trim(position) {\n                if (!Splide.options.trimSpace || Splide.is(LOOP)) {\n                  return position;\n                }\n\n                var edge = sign * (Layout.totalSize() - Layout.size - Layout.gap);\n                return between(position, edge, 0);\n              },\n\n              /**\r\n               * Calculate the closest slide index from the given position.\r\n               *\r\n               * @param {number} position - A position converted to an slide index.\r\n               *\r\n               * @return {number} - The closest slide index.\r\n               */\n              toIndex: function toIndex(position) {\n                var _this2 = this;\n\n                var index = 0;\n                var minDistance = Infinity;\n                Elements.getSlides(true).forEach(function (Slide) {\n                  var slideIndex = Slide.index;\n                  var distance = abs(_this2.toPosition(slideIndex) - position);\n\n                  if (distance < minDistance) {\n                    minDistance = distance;\n                    index = slideIndex;\n                  }\n                });\n                return index;\n              },\n\n              /**\r\n               * Return coordinates object by the given position.\r\n               *\r\n               * @param {number} position - A position value.\r\n               *\r\n               * @return {Object} - A coordinates object.\r\n               */\n              toCoord: function toCoord(position) {\n                return {\n                  x: isVertical ? 0 : position,\n                  y: isVertical ? position : 0\n                };\n              },\n\n              /**\r\n               * Calculate the track position by a slide index.\r\n               *\r\n               * @param {number} index - Slide index.\r\n               *\r\n               * @return {Object} - Calculated position.\r\n               */\n              toPosition: function toPosition(index) {\n                var position = Layout.totalSize(index) - Layout.slideSize(index) - Layout.gap;\n                return sign * (position + this.offset(index));\n              },\n\n              /**\r\n               * Return the current offset value, considering direction.\r\n               *\r\n               * @return {number} - Offset amount.\r\n               */\n              offset: function offset(index) {\n                var focus = Splide.options.focus;\n                var slideSize = Layout.slideSize(index);\n\n                if (focus === 'center') {\n                  return -(Layout.size - slideSize) / 2;\n                }\n\n                return -(parseInt(focus) || 0) * (slideSize + Layout.gap);\n              },\n\n              /**\r\n               * Return the current position.\r\n               * This returns the correct position even while transitioning by CSS.\r\n               *\r\n               * @return {number} - Current position.\r\n               */\n              get position() {\n                var prop = isVertical ? 'top' : isRTL ? 'right' : 'left';\n                return getRect(list)[prop] - (getRect(Elements.track)[prop] - Layout.padding[prop] * sign);\n              }\n\n            };\n            /**\r\n             * Called whenever slides arrive at a destination.\r\n             *\r\n             * @param {number}  destIndex - A destination index.\r\n             * @param {number}  newIndex  - A new index.\r\n             * @param {number}  prevIndex - A previous index.\r\n             * @param {boolean} silently  - If true, suppress emitting events.\r\n             */\n\n            function onTransitionEnd(destIndex, newIndex, prevIndex, silently) {\n              applyStyle(list, {\n                transition: ''\n              });\n              isLoopPending = false;\n\n              if (!isFade) {\n                Track.jump(newIndex);\n              }\n\n              if (!silently) {\n                Splide.emit('moved', newIndex, prevIndex, destIndex);\n              }\n            }\n            /**\r\n             * Convert index to the trimmed position.\r\n             *\r\n             * @return {number} - Trimmed position.\r\n             */\n\n\n            function getTrimmedPosition(index) {\n              return Track.trim(Track.toPosition(index));\n            }\n\n            return Track;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/components/clones/index.js\n\n          /**\r\n           * The component for cloning some slides for \"loop\" mode of the track.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The component for cloning some slides for \"loop\" mode of the track.\r\n           *\r\n           * @param {Splide} Splide     - A Splide instance.\r\n           * @param {Object} Components - An object containing components.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var clones = function clones(Splide, Components) {\n            /**\r\n             * Store information of all clones.\r\n             *\r\n             * @type {Array}\r\n             */\n            var clones = [];\n            /**\r\n             * Store the current clone count on one side.\r\n             *\r\n             * @type {number}\r\n             */\n\n            var cloneCount = 0;\n            /**\r\n             * Keep Elements component.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Elements = Components.Elements;\n            /**\r\n             * Clones component object.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Clones = {\n              /**\r\n               * Called when the component is mounted.\r\n               */\n              mount: function mount() {\n                var _this = this;\n\n                if (Splide.is(LOOP)) {\n                  init();\n                  Splide.on('refresh:before', function () {\n                    _this.destroy();\n                  }).on('refresh', init).on('resize', function () {\n                    if (cloneCount !== getCloneCount()) {\n                      // Destroy before refresh not to collect clones by the Elements component.\n                      _this.destroy();\n\n                      Splide.refresh();\n                    }\n                  });\n                }\n              },\n\n              /**\r\n               * Destroy.\r\n               */\n              destroy: function destroy() {\n                dom_remove(clones);\n                clones = [];\n              },\n\n              /**\r\n               * Return all clones.\r\n               *\r\n               * @return {Element[]} - Cloned elements.\r\n               */\n              get clones() {\n                return clones;\n              },\n\n              /**\r\n               * Return clone length.\r\n               *\r\n               * @return {number} - A length of clones.\r\n               */\n              get length() {\n                return clones.length;\n              }\n\n            };\n            /**\r\n             * Initialization.\r\n             */\n\n            function init() {\n              Clones.destroy();\n              cloneCount = getCloneCount();\n              generateClones(cloneCount);\n            }\n            /**\r\n             * Generate and append/prepend clones.\r\n             *\r\n             * @param {number} count - The half number of clones.\r\n             */\n\n\n            function generateClones(count) {\n              var length = Elements.length,\n                  register = Elements.register;\n\n              if (length) {\n                var slides = Elements.slides;\n\n                while (slides.length < count) {\n                  slides = slides.concat(slides);\n                } // Clones after the last element.\n\n\n                slides.slice(0, count).forEach(function (elm, index) {\n                  var clone = cloneDeeply(elm);\n                  append(Elements.list, clone);\n                  clones.push(clone);\n                  register(clone, index + length, index % length);\n                }); // Clones before the first element.\n\n                slides.slice(-count).forEach(function (elm, index) {\n                  var clone = cloneDeeply(elm);\n                  before(clone, slides[0]);\n                  clones.push(clone);\n                  register(clone, index - count, (length + index - count % length) % length);\n                });\n              }\n            }\n            /**\r\n             * Return half count of clones to be generated.\r\n             * Clone count is determined by:\r\n             * - \"clones\" value in the options.\r\n             * - Number of slides that can be placed in a view in \"fixed\" mode.\r\n             * - Max pages a flick action can move.\r\n             * - Whether the slide length is enough for perPage.\r\n             *\r\n             * @return {number} - Count for clones.\r\n             */\n\n\n            function getCloneCount() {\n              var options = Splide.options;\n\n              if (options.clones) {\n                return options.clones;\n              } // Use the slide length in autoWidth mode because the number cannot be calculated.\n\n\n              var baseCount = options.autoWidth || options.autoHeight ? Elements.length : options.perPage;\n              var dimension = options.direction === TTB ? 'Height' : 'Width';\n              var fixedSize = toPixel(Splide.root, options[\"fixed\" + dimension]);\n\n              if (fixedSize) {\n                // Roughly calculate the count. This needs not to be strict.\n                baseCount = Math.ceil(Elements.track[\"client\" + dimension] / fixedSize);\n              }\n\n              return baseCount * (options.drag ? options.flickMaxPages + 1 : 1);\n            }\n            /**\r\n             * Clone deeply the given element.\r\n             *\r\n             * @param {Element} elm - An element being duplicated.\r\n             *\r\n             * @return {Node} - A cloned node(element).\r\n             */\n\n\n            function cloneDeeply(elm) {\n              var clone = elm.cloneNode(true);\n              addClass(clone, Splide.classes.clone); // ID should not be duplicated.\n\n              removeAttribute(clone, 'id');\n              return clone;\n            }\n\n            return Clones;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/components/layout/directions/horizontal.js\n\n          /**\r\n           * The resolver component for horizontal layout.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The resolver component for horizontal layout.\r\n           *\r\n           * @param {Splide} Splide     - A Splide instance.\r\n           * @param {Object} Components - An object containing components.\r\n           *\r\n           * @return {Object} - The resolver object.\r\n           */\n\n          /* harmony default export */\n\n          var horizontal = function horizontal(Splide, Components) {\n            /**\r\n             * Keep the Elements component.\r\n             *\r\n             * @type {string}\r\n             */\n            var Elements = Components.Elements;\n            /**\r\n             * Keep the root element.\r\n             *\r\n             * @type {Element}\r\n             */\n\n            var root = Splide.root;\n            /**\r\n             * Keep the track element.\r\n             *\r\n             * @type {Element}\r\n             */\n\n            var track;\n            /**\r\n             * Keep the latest options.\r\n             *\r\n             * @type {Element}\r\n             */\n\n            var options = Splide.options;\n            return {\n              /**\r\n               * Margin property name.\r\n               *\r\n               * @type {string}\r\n               */\n              margin: 'margin' + (options.direction === RTL ? 'Left' : 'Right'),\n\n              /**\r\n               * Always 0 because the height will be determined by inner contents.\r\n               *\r\n               * @type {number}\r\n               */\n              height: 0,\n\n              /**\r\n               * Initialization.\r\n               */\n              init: function init() {\n                this.resize();\n              },\n\n              /**\r\n               * Resize gap and padding.\r\n               * This must be called on init.\r\n               */\n              resize: function resize() {\n                options = Splide.options;\n                track = Elements.track;\n                this.gap = toPixel(root, options.gap);\n                var padding = options.padding;\n                var left = toPixel(root, padding.left || padding);\n                var right = toPixel(root, padding.right || padding);\n                this.padding = {\n                  left: left,\n                  right: right\n                };\n                applyStyle(track, {\n                  paddingLeft: unit(left),\n                  paddingRight: unit(right)\n                });\n              },\n\n              /**\r\n               * Return total width from the left of the list to the right of the slide specified by the provided index.\r\n               *\r\n               * @param {number} index - Optional. A slide index. If undefined, total width of the slider will be returned.\r\n               *\r\n               * @return {number} - Total width to the right side of the specified slide, or 0 for an invalid index.\r\n               */\n              totalWidth: function totalWidth(index) {\n                if (index === void 0) {\n                  index = Splide.length - 1;\n                }\n\n                var Slide = Elements.getSlide(index);\n                var width = 0;\n\n                if (Slide) {\n                  var slideRect = getRect(Slide.slide);\n                  var listRect = getRect(Elements.list);\n\n                  if (options.direction === RTL) {\n                    width = listRect.right - slideRect.left;\n                  } else {\n                    width = slideRect.right - listRect.left;\n                  }\n\n                  width += this.gap;\n                }\n\n                return width;\n              },\n\n              /**\r\n               * Return the slide width in px.\r\n               *\r\n               * @param {number} index - Slide index.\r\n               *\r\n               * @return {number} - The slide width.\r\n               */\n              slideWidth: function slideWidth(index) {\n                if (options.autoWidth) {\n                  var Slide = Elements.getSlide(index);\n                  return Slide ? Slide.slide.offsetWidth : 0;\n                }\n\n                var width = options.fixedWidth || (this.width + this.gap) / options.perPage - this.gap;\n                return toPixel(root, width);\n              },\n\n              /**\r\n               * Return the slide height in px.\r\n               *\r\n               * @return {number} - The slide height.\r\n               */\n              slideHeight: function slideHeight() {\n                var height = options.height || options.fixedHeight || this.width * options.heightRatio;\n                return toPixel(root, height);\n              },\n\n              /**\r\n               * Return slider width without padding.\r\n               *\r\n               * @return {number} - Current slider width.\r\n               */\n              get width() {\n                return track.clientWidth - this.padding.left - this.padding.right;\n              }\n\n            };\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/components/layout/directions/vertical.js\n\n          /**\r\n           * The resolver component for vertical layout.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The resolver component for vertical layout.\r\n           *\r\n           * @param {Splide} Splide     - A Splide instance.\r\n           * @param {Object} Components - An object containing components.\r\n           *\r\n           * @return {Object} - The resolver object.\r\n           */\n\n          /* harmony default export */\n\n          var vertical = function vertical(Splide, Components) {\n            /**\r\n             * Keep the Elements component.\r\n             *\r\n             * @type {string}\r\n             */\n            var Elements = Components.Elements;\n            /**\r\n             * Keep the root element.\r\n             *\r\n             * @type {Element}\r\n             */\n\n            var root = Splide.root;\n            /**\r\n             * Keep the track element.\r\n             *\r\n             * @type {Element}\r\n             */\n\n            var track;\n            /**\r\n             * Keep the latest options.\r\n             *\r\n             * @type {Element}\r\n             */\n\n            var options;\n            return {\n              /**\r\n               * Margin property name.\r\n               *\r\n               * @type {string}\r\n               */\n              margin: 'marginBottom',\n\n              /**\r\n               * Initialization.\r\n               */\n              init: function init() {\n                this.resize();\n              },\n\n              /**\r\n               * Resize gap and padding.\r\n               * This must be called on init.\r\n               */\n              resize: function resize() {\n                options = Splide.options;\n                track = Elements.track;\n                this.gap = toPixel(root, options.gap);\n                var padding = options.padding;\n                var top = toPixel(root, padding.top || padding);\n                var bottom = toPixel(root, padding.bottom || padding);\n                this.padding = {\n                  top: top,\n                  bottom: bottom\n                };\n                applyStyle(track, {\n                  paddingTop: unit(top),\n                  paddingBottom: unit(bottom)\n                });\n              },\n\n              /**\r\n               * Return total height from the top of the list to the bottom of the slide specified by the provided index.\r\n               *\r\n               * @param {number} index - Optional. A slide index. If undefined, total height of the slider will be returned.\r\n               *\r\n               * @return {number} - Total height to the bottom of the specified slide, or 0 for an invalid index.\r\n               */\n              totalHeight: function totalHeight(index) {\n                if (index === void 0) {\n                  index = Splide.length - 1;\n                }\n\n                var Slide = Elements.getSlide(index);\n\n                if (Slide) {\n                  return getRect(Slide.slide).bottom - getRect(Elements.list).top + this.gap;\n                }\n\n                return 0;\n              },\n\n              /**\r\n               * Return the slide width in px.\r\n               *\r\n               * @return {number} - The slide width.\r\n               */\n              slideWidth: function slideWidth() {\n                return toPixel(root, options.fixedWidth || this.width);\n              },\n\n              /**\r\n               * Return the slide height in px.\r\n               *\r\n               * @param {number} index - Slide index.\r\n               *\r\n               * @return {number} - The slide height.\r\n               */\n              slideHeight: function slideHeight(index) {\n                if (options.autoHeight) {\n                  var Slide = Elements.getSlide(index);\n                  return Slide ? Slide.slide.offsetHeight : 0;\n                }\n\n                var height = options.fixedHeight || (this.height + this.gap) / options.perPage - this.gap;\n                return toPixel(root, height);\n              },\n\n              /**\r\n               * Return slider width without padding.\r\n               *\r\n               * @return {number} - Current slider width.\r\n               */\n              get width() {\n                return track.clientWidth;\n              },\n\n              /**\r\n               * Return slide height without padding.\r\n               *\r\n               * @return {number} - Slider height.\r\n               */\n              get height() {\n                var height = options.height || this.width * options.heightRatio;\n                exist(height, '\"height\" or \"heightRatio\" is missing.');\n                return toPixel(root, height) - this.padding.top - this.padding.bottom;\n              }\n\n            };\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/utils/time.js\n\n          /**\r\n           * A package of utility functions related with time.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * Simple throttle function that controls how often the given function is executed.\r\n           *\r\n           * @param {function} func - A function to be throttled.\r\n           * @param {number}   wait - Time in millisecond for interval of execution.\r\n           *\r\n           * @return {Function} - A debounced function.\r\n           */\n\n          function throttle(func, wait) {\n            var timeout; // Declare function by the \"function\" keyword to prevent \"this\" from being inherited.\n\n            return function () {\n              if (!timeout) {\n                timeout = setTimeout(function () {\n                  func();\n                  timeout = null;\n                }, wait);\n              }\n            };\n          }\n          /**\r\n           * Custom setInterval function that provides progress rate as callback.\r\n           *\r\n           * @param {function} callback - A callback function fired every time the interval time passes.\r\n           * @param {number}   interval - Interval duration in milliseconds.\r\n           * @param {function} progress - A callback function fired whenever the progress goes.\r\n           *\r\n           * @return {Object} - An object containing play() and pause() functions.\r\n           */\n\n\n          function createInterval(callback, interval, progress) {\n            var _window = window,\n                requestAnimationFrame = _window.requestAnimationFrame;\n            var start,\n                elapse,\n                rate,\n                _pause = true;\n\n            var step = function step(timestamp) {\n              if (!_pause) {\n                if (!start) {\n                  start = timestamp;\n\n                  if (rate && rate < 1) {\n                    start -= rate * interval;\n                  }\n                }\n\n                elapse = timestamp - start;\n                rate = elapse / interval;\n\n                if (elapse >= interval) {\n                  start = 0;\n                  rate = 1;\n                  callback();\n                }\n\n                if (progress) {\n                  progress(rate);\n                }\n\n                requestAnimationFrame(step);\n              }\n            };\n\n            return {\n              pause: function pause() {\n                _pause = true;\n                start = 0;\n              },\n              play: function play(reset) {\n                start = 0;\n\n                if (reset) {\n                  rate = 0;\n                }\n\n                if (_pause) {\n                  _pause = false;\n                  requestAnimationFrame(step);\n                }\n              }\n            };\n          }\n\n          ; // CONCATENATED MODULE: ./src/js/components/layout/index.js\n\n          /**\r\n           * The component for handing slide layouts and their sizes.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The component for handing slide layouts and their sizes.\r\n           *\r\n           * @param {Splide} Splide     - A Splide instance.\r\n           * @param {Object} Components - An object containing components.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var layout = function layout(Splide, Components) {\n            /**\r\n             * Keep the Elements component.\r\n             *\r\n             * @type {string}\r\n             */\n            var Elements = Components.Elements;\n            /**\r\n             * Whether the slider is vertical or not.\r\n             *\r\n             * @type {boolean}\r\n             */\n\n            var isVertical = Splide.options.direction === TTB;\n            /**\r\n             * Layout component object.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Layout = object_assign({\n              /**\r\n               * Called when the component is mounted.\r\n               */\n              mount: function mount() {\n                bind();\n                init(); // The word \"size\" means width for a horizontal slider and height for a vertical slider.\n\n                this.totalSize = isVertical ? this.totalHeight : this.totalWidth;\n                this.slideSize = isVertical ? this.slideHeight : this.slideWidth;\n              },\n\n              /**\r\n               * Destroy the component.\r\n               */\n              destroy: function destroy() {\n                removeAttribute([Elements.list, Elements.track], 'style');\n              },\n\n              /**\r\n               * Return the slider height on the vertical mode or width on the horizontal mode.\r\n               *\r\n               * @return {number}\r\n               */\n              get size() {\n                return isVertical ? this.height : this.width;\n              }\n\n            }, isVertical ? vertical(Splide, Components) : horizontal(Splide, Components));\n            /**\r\n             * Init slider styles according to options.\r\n             */\n\n            function init() {\n              Layout.init();\n              applyStyle(Splide.root, {\n                maxWidth: unit(Splide.options.width)\n              });\n              Elements.each(function (Slide) {\n                Slide.slide.style[Layout.margin] = unit(Layout.gap);\n              });\n              resize();\n            }\n            /**\r\n             * Listen the resize native event with throttle.\r\n             * Initialize when the component is mounted or options are updated.\r\n             */\n\n\n            function bind() {\n              Splide.on('resize load', throttle(function () {\n                Splide.emit('resize');\n              }, Splide.options.throttle), window).on('resize', resize).on('updated refresh', init);\n            }\n            /**\r\n             * Resize the track and slide elements.\r\n             */\n\n\n            function resize() {\n              var options = Splide.options;\n              Layout.resize();\n              applyStyle(Elements.track, {\n                height: unit(Layout.height)\n              });\n              var slideHeight = options.autoHeight ? null : unit(Layout.slideHeight());\n              Elements.each(function (Slide) {\n                applyStyle(Slide.container, {\n                  height: slideHeight\n                });\n                applyStyle(Slide.slide, {\n                  width: options.autoWidth ? null : unit(Layout.slideWidth(Slide.index)),\n                  height: Slide.container ? null : slideHeight\n                });\n              });\n              Splide.emit('resized');\n            }\n\n            return Layout;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/components/drag/index.js\n\n          /**\r\n           * The component for supporting mouse drag and swipe.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          var drag_abs = Math.abs;\n          /**\r\n           * If the absolute velocity is greater thant this value,\r\n           * a slider always goes to a different slide after drag, not allowed to stay on a current slide.\r\n           */\n\n          var MIN_VELOCITY = 0.1;\n          /**\r\n           * Adjust how much the track can be pulled on the first or last page.\r\n           * The larger number this is, the farther the track moves.\r\n           * This should be around 5 - 9.\r\n           *\r\n           * @type {number}\r\n           */\n\n          var FRICTION_REDUCER = 7;\n          /**\r\n           * The component supporting mouse drag and swipe.\r\n           *\r\n           * @param {Splide} Splide     - A Splide instance.\r\n           * @param {Object} Components - An object containing components.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var drag = function drag(Splide, Components) {\n            /**\r\n             * Store the Move component.\r\n             *\r\n             * @type {Object}\r\n             */\n            var Track = Components.Track;\n            /**\r\n             * Store the Controller component.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Controller = Components.Controller;\n            /**\r\n             * Coordinate of the track on starting drag.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var startCoord;\n            /**\r\n             * Analyzed info on starting drag.\r\n             *\r\n             * @type {Object|null}\r\n             */\n\n            var startInfo;\n            /**\r\n             * Analyzed info being updated while dragging/swiping.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var currentInfo;\n            /**\r\n             * Determine whether slides are being dragged or not.\r\n             *\r\n             * @type {boolean}\r\n             */\n\n            var isDragging;\n            /**\r\n             * Whether the slider direction is vertical or not.\r\n             *\r\n             * @type {boolean}\r\n             */\n\n            var isVertical = Splide.options.direction === TTB;\n            /**\r\n             * Axis for the direction.\r\n             *\r\n             * @type {string}\r\n             */\n\n            var axis = isVertical ? 'y' : 'x';\n            /**\r\n             * Drag component object.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Drag = {\n              /**\r\n               * Whether dragging is disabled or not.\r\n               *\r\n               * @type {boolean}\r\n               */\n              disabled: false,\n\n              /**\r\n               * Called when the component is mounted.\r\n               */\n              mount: function mount() {\n                var _this = this;\n\n                var Elements = Components.Elements;\n                var track = Elements.track;\n                Splide.on('touchstart mousedown', start, track).on('touchmove mousemove', move, track, {\n                  passive: false\n                }).on('touchend touchcancel mouseleave mouseup dragend', end, track).on('mounted refresh', function () {\n                  // Prevent dragging an image or anchor itself.\n                  each(Elements.list.querySelectorAll('img, a'), function (elm) {\n                    Splide.off('dragstart', elm).on('dragstart', function (e) {\n                      e.preventDefault();\n                    }, elm, {\n                      passive: false\n                    });\n                  });\n                }).on('mounted updated', function () {\n                  _this.disabled = !Splide.options.drag;\n                });\n              }\n            };\n            /**\r\n             * Called when the track starts to be dragged.\r\n             *\r\n             * @param {TouchEvent|MouseEvent} e - TouchEvent or MouseEvent object.\r\n             */\n\n            function start(e) {\n              if (!Drag.disabled && !isDragging) {\n                // These prams are used to evaluate whether the slider should start moving.\n                init(e);\n              }\n            }\n            /**\r\n             * Initialize parameters.\r\n             *\r\n             * @param {TouchEvent|MouseEvent} e - TouchEvent or MouseEvent object.\r\n             */\n\n\n            function init(e) {\n              startCoord = Track.toCoord(Track.position);\n              startInfo = analyze(e, {});\n              currentInfo = startInfo;\n            }\n            /**\r\n             * Called while the track being dragged.\r\n             *\r\n             * @param {TouchEvent|MouseEvent} e - TouchEvent or MouseEvent object.\r\n             */\n\n\n            function move(e) {\n              if (startInfo) {\n                currentInfo = analyze(e, startInfo);\n\n                if (isDragging) {\n                  if (e.cancelable) {\n                    e.preventDefault();\n                  }\n\n                  if (!Splide.is(FADE)) {\n                    var position = startCoord[axis] + currentInfo.offset[axis];\n                    Track.translate(resist(position));\n                  }\n                } else {\n                  if (shouldMove(currentInfo)) {\n                    Splide.emit('drag', startInfo);\n                    isDragging = true;\n                    Track.cancel(); // These params are actual drag data.\n\n                    init(e);\n                  }\n                }\n              }\n            }\n            /**\r\n             * Determine whether to start moving the track or not by drag angle.\r\n             *\r\n             * @param {Object} info - An information object.\r\n             *\r\n             * @return {boolean} - True if the track should be moved or false if not.\r\n             */\n\n\n            function shouldMove(_ref) {\n              var offset = _ref.offset;\n\n              if (Splide.State.is(_MOVING) && Splide.options.waitForTransition) {\n                return false;\n              }\n\n              var angle = Math.atan(drag_abs(offset.y) / drag_abs(offset.x)) * 180 / Math.PI;\n\n              if (isVertical) {\n                angle = 90 - angle;\n              }\n\n              return angle < Splide.options.dragAngleThreshold;\n            }\n            /**\r\n             * Resist dragging the track on the first/last page because there is no more.\r\n             *\r\n             * @param {number} position - A position being applied to the track.\r\n             *\r\n             * @return {Object} - Adjusted position.\r\n             */\n\n\n            function resist(position) {\n              if (Splide.is(SLIDE)) {\n                var sign = Track.sign;\n\n                var _start = sign * Track.trim(Track.toPosition(0));\n\n                var _end = sign * Track.trim(Track.toPosition(Controller.edgeIndex));\n\n                position *= sign;\n\n                if (position < _start) {\n                  position = _start - FRICTION_REDUCER * Math.log(_start - position);\n                } else if (position > _end) {\n                  position = _end + FRICTION_REDUCER * Math.log(position - _end);\n                }\n\n                position *= sign;\n              }\n\n              return position;\n            }\n            /**\r\n             * Called when dragging ends.\r\n             */\n\n\n            function end() {\n              startInfo = null;\n\n              if (isDragging) {\n                Splide.emit('dragged', currentInfo);\n                go(currentInfo);\n                isDragging = false;\n              }\n            }\n            /**\r\n             * Go to the slide determined by the analyzed data.\r\n             *\r\n             * @param {Object} info - An info object.\r\n             */\n\n\n            function go(info) {\n              var velocity = info.velocity[axis];\n              var absV = drag_abs(velocity);\n\n              if (absV > 0) {\n                var options = Splide.options;\n                var index = Splide.index;\n                var sign = velocity < 0 ? -1 : 1;\n                var destIndex = index;\n\n                if (!Splide.is(FADE)) {\n                  var destination = Track.position;\n\n                  if (absV > options.flickVelocityThreshold && drag_abs(info.offset[axis]) < options.swipeDistanceThreshold) {\n                    destination += sign * Math.min(absV * options.flickPower, Components.Layout.size * (options.flickMaxPages || 1));\n                  }\n\n                  destIndex = Track.toIndex(destination);\n                }\n                /*\r\n                 * Do not allow the track to go to a previous position if there is enough velocity.\r\n                 * Always use the adjacent index for the fade mode.\r\n                 */\n\n\n                if (destIndex === index && absV > MIN_VELOCITY) {\n                  destIndex = index + sign * Track.sign;\n                }\n\n                if (Splide.is(SLIDE)) {\n                  destIndex = between(destIndex, 0, Controller.edgeIndex);\n                }\n\n                Controller.go(destIndex, options.isNavigation);\n              }\n            }\n            /**\r\n             * Analyze the given event object and return important information for handling swipe behavior.\r\n             *\r\n             * @param {Event}   e          - Touch or Mouse event object.\r\n             * @param {Object}  startInfo  - Information analyzed on start for calculating difference from the current one.\r\n             *\r\n             * @return {Object} - An object containing analyzed information, such as offset, velocity, etc.\r\n             */\n\n\n            function analyze(e, startInfo) {\n              var timeStamp = e.timeStamp,\n                  touches = e.touches;\n\n              var _ref2 = touches ? touches[0] : e,\n                  clientX = _ref2.clientX,\n                  clientY = _ref2.clientY;\n\n              var _ref3 = startInfo.to || {},\n                  _ref3$x = _ref3.x,\n                  fromX = _ref3$x === void 0 ? clientX : _ref3$x,\n                  _ref3$y = _ref3.y,\n                  fromY = _ref3$y === void 0 ? clientY : _ref3$y;\n\n              var startTime = startInfo.time || 0;\n              var offset = {\n                x: clientX - fromX,\n                y: clientY - fromY\n              };\n              var duration = timeStamp - startTime;\n              var velocity = {\n                x: offset.x / duration,\n                y: offset.y / duration\n              };\n              return {\n                to: {\n                  x: clientX,\n                  y: clientY\n                },\n                offset: offset,\n                time: timeStamp,\n                velocity: velocity\n              };\n            }\n\n            return Drag;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/components/click/index.js\n\n          /**\r\n           * The component for handling a click event.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The component for handling a click event.\r\n           * Click should be disabled during drag/swipe.\r\n           *\r\n           * @param {Splide} Splide     - A Splide instance.\r\n           * @param {Object} Components - An object containing components.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var click = function click(Splide, Components) {\n            /**\r\n             * Whether click is disabled or not.\r\n             *\r\n             * @type {boolean}\r\n             */\n            var disabled = false;\n            /**\r\n             * Click component object.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Click = {\n              /**\r\n               * Mount only when the drag is activated and the slide type is not \"fade\".\r\n               *\r\n               * @type {boolean}\r\n               */\n              required: Splide.options.drag,\n\n              /**\r\n               * Called when the component is mounted.\r\n               */\n              mount: function mount() {\n                Splide.on('click', onClick, Components.Elements.track, {\n                  capture: true\n                }).on('drag', function () {\n                  disabled = true;\n                }).on('dragged', function () {\n                  // Make sure the flag is released after the click event is fired.\n                  setTimeout(function () {\n                    disabled = false;\n                  });\n                });\n              }\n            };\n            /**\r\n             * Called when a track element is clicked.\r\n             *\r\n             * @param {Event} e - A click event.\r\n             */\n\n            function onClick(e) {\n              if (disabled) {\n                e.preventDefault();\n                e.stopPropagation();\n                e.stopImmediatePropagation();\n              }\n            }\n\n            return Click;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/components/autoplay/index.js\n\n          /**\r\n           * The component for playing slides automatically.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * Set of pause flags.\r\n           */\n\n          var PAUSE_FLAGS = {\n            HOVER: 1,\n            FOCUS: 2,\n            MANUAL: 3\n          };\n          /**\r\n           * The component for playing slides automatically.\r\n           *\r\n           * @param {Splide} Splide     - A Splide instance.\r\n           * @param {Object} Components - An object containing components.\r\n           * @param {string} name       - A component name as a lowercase string.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var autoplay = function autoplay(Splide, Components, name) {\n            /**\r\n             * Store pause flags.\r\n             *\r\n             * @type {Array}\r\n             */\n            var flags = [];\n            /**\r\n             * Store an interval object.\r\n             *\r\n             * @type {Object};\r\n             */\n\n            var interval;\n            /**\r\n             * Keep the Elements component.\r\n             *\r\n             * @type {string}\r\n             */\n\n            var Elements = Components.Elements;\n            /**\r\n             * Autoplay component object.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Autoplay = {\n              /**\r\n               * Required only when the autoplay option is true.\r\n               *\r\n               * @type {boolean}\r\n               */\n              required: Splide.options.autoplay,\n\n              /**\r\n               * Called when the component is mounted.\r\n               * Note that autoplay starts only if there are slides over perPage number.\r\n               */\n              mount: function mount() {\n                var options = Splide.options;\n\n                if (Elements.slides.length > options.perPage) {\n                  interval = createInterval(function () {\n                    Splide.go('>');\n                  }, options.interval, function (rate) {\n                    Splide.emit(name + \":playing\", rate);\n\n                    if (Elements.bar) {\n                      applyStyle(Elements.bar, {\n                        width: rate * 100 + \"%\"\n                      });\n                    }\n                  });\n                  bind();\n                  this.play();\n                }\n              },\n\n              /**\r\n               * Start autoplay.\r\n               *\r\n               * @param {number} flag - A pause flag to be removed.\r\n               */\n              play: function play(flag) {\n                if (flag === void 0) {\n                  flag = 0;\n                }\n\n                flags = flags.filter(function (f) {\n                  return f !== flag;\n                });\n\n                if (!flags.length) {\n                  Splide.emit(name + \":play\");\n                  interval.play(Splide.options.resetProgress);\n                }\n              },\n\n              /**\r\n               * Pause autoplay.\r\n               * Note that Array.includes is not supported by IE.\r\n               *\r\n               * @param {number} flag - A pause flag to be added.\r\n               */\n              pause: function pause(flag) {\n                if (flag === void 0) {\n                  flag = 0;\n                }\n\n                interval.pause();\n\n                if (flags.indexOf(flag) === -1) {\n                  flags.push(flag);\n                }\n\n                if (flags.length === 1) {\n                  Splide.emit(name + \":pause\");\n                }\n              }\n            };\n            /**\r\n             * Listen some events.\r\n             */\n\n            function bind() {\n              var options = Splide.options;\n              var sibling = Splide.sibling;\n              var elms = [Splide.root, sibling ? sibling.root : null];\n\n              if (options.pauseOnHover) {\n                switchOn(elms, 'mouseleave', PAUSE_FLAGS.HOVER, true);\n                switchOn(elms, 'mouseenter', PAUSE_FLAGS.HOVER, false);\n              }\n\n              if (options.pauseOnFocus) {\n                switchOn(elms, 'focusout', PAUSE_FLAGS.FOCUS, true);\n                switchOn(elms, 'focusin', PAUSE_FLAGS.FOCUS, false);\n              }\n\n              if (Elements.play) {\n                Splide.on('click', function () {\n                  // Need to be removed a focus flag at first.\n                  Autoplay.play(PAUSE_FLAGS.FOCUS);\n                  Autoplay.play(PAUSE_FLAGS.MANUAL);\n                }, Elements.play);\n              }\n\n              if (Elements.pause) {\n                switchOn([Elements.pause], 'click', PAUSE_FLAGS.MANUAL, false);\n              }\n\n              Splide.on('move refresh', function () {\n                Autoplay.play();\n              }) // Rewind the timer.\n              .on('destroy', function () {\n                Autoplay.pause();\n              });\n            }\n            /**\r\n             * Play or pause on the given event.\r\n             *\r\n             * @param {Element[]} elms  - Elements.\r\n             * @param {string}    event - An event name or names.\r\n             * @param {number}    flag  - A pause flag defined on the top.\r\n             * @param {boolean}   play  - Determine whether to play or pause.\r\n             */\n\n\n            function switchOn(elms, event, flag, play) {\n              elms.forEach(function (elm) {\n                Splide.on(event, function () {\n                  Autoplay[play ? 'play' : 'pause'](flag);\n                }, elm);\n              });\n            }\n\n            return Autoplay;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/components/cover/index.js\n\n          /**\r\n           * The component for change an img element to background image of its wrapper.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The component for change an img element to background image of its wrapper.\r\n           *\r\n           * @param {Splide} Splide     - A Splide instance.\r\n           * @param {Object} Components - An object containing components.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var cover = function cover(Splide, Components) {\n            /**\r\n             * Hold options.\r\n             *\r\n             * @type {Object}\r\n             */\n            var options = Splide.options;\n            /**\r\n             * Cover component object.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Cover = {\n              /**\r\n               * Required only when \"cover\" option is true.\r\n               *\r\n               * @type {boolean}\r\n               */\n              required: options.cover,\n\n              /**\r\n               * Called when the component is mounted.\r\n               */\n              mount: function mount() {\n                Splide.on('lazyload:loaded', function (img) {\n                  cover(img, false);\n                });\n                Splide.on('mounted updated refresh', function () {\n                  return apply(false);\n                });\n              },\n\n              /**\r\n               * Destroy.\r\n               */\n              destroy: function destroy() {\n                apply(true);\n              }\n            };\n            /**\r\n             * Apply \"cover\" to all slides.\r\n             *\r\n             * @param {boolean} uncover - If true, \"cover\" will be clear.\r\n             */\n\n            function apply(uncover) {\n              Components.Elements.each(function (Slide) {\n                var img = child(Slide.slide, 'IMG') || child(Slide.container, 'IMG');\n\n                if (img && img.src) {\n                  cover(img, uncover);\n                }\n              });\n            }\n            /**\r\n             * Set background image of the parent element, using source of the given image element.\r\n             *\r\n             * @param {Element} img     - An image element.\r\n             * @param {boolean} uncover - Reset \"cover\".\r\n             */\n\n\n            function cover(img, uncover) {\n              applyStyle(img.parentElement, {\n                background: uncover ? '' : \"center/cover no-repeat url(\\\"\" + img.src + \"\\\")\"\n              });\n              applyStyle(img, {\n                display: uncover ? '' : 'none'\n              });\n            }\n\n            return Cover;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/components/arrows/path.js\n\n          /**\r\n           * Export vector path for an arrow.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * Namespace definition for SVG element.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var XML_NAME_SPACE = 'http://www.w3.org/2000/svg';\n          /**\r\n           * The arrow vector path.\r\n           *\r\n           * @type {number}\r\n           */\n\n          var PATH = 'm15.5 0.932-4.3 4.38 14.5 14.6-14.5 14.5 4.3 4.4 14.6-14.6 4.4-4.3-4.4-4.4-14.6-14.6z';\n          /**\r\n           * SVG width and height.\r\n           *\r\n           * @type {number}\r\n           */\n\n          var SIZE = 40;\n          ; // CONCATENATED MODULE: ./src/js/components/arrows/index.js\n\n          /**\r\n           * The component for appending prev/next arrows.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The component for appending prev/next arrows.\r\n           *\r\n           * @param {Splide} Splide     - A Splide instance.\r\n           * @param {Object} Components - An object containing components.\r\n           * @param {string} name       - A component name as a lowercase string.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var arrows = function arrows(Splide, Components, name) {\n            /**\r\n             * Previous arrow element.\r\n             *\r\n             * @type {Element|undefined}\r\n             */\n            var prev;\n            /**\r\n             * Next arrow element.\r\n             *\r\n             * @type {Element|undefined}\r\n             */\n\n            var next;\n            /**\r\n             * Store the class list.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var classes = Splide.classes;\n            /**\r\n             * Hold the root element.\r\n             *\r\n             * @type {Element}\r\n             */\n\n            var root = Splide.root;\n            /**\r\n             * Whether arrows are created programmatically or not.\r\n             *\r\n             * @type {boolean}\r\n             */\n\n            var created;\n            /**\r\n             * Hold the Elements component.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Elements = Components.Elements;\n            /**\r\n             * Arrows component object.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Arrows = {\n              /**\r\n               * Required when the arrows option is true.\r\n               *\r\n               * @type {boolean}\r\n               */\n              required: Splide.options.arrows,\n\n              /**\r\n               * Called when the component is mounted.\r\n               */\n              mount: function mount() {\n                // Attempt to get arrows from HTML source.\n                prev = Elements.arrows.prev;\n                next = Elements.arrows.next; // If arrows were not found in HTML, let's generate them.\n\n                if ((!prev || !next) && Splide.options.arrows) {\n                  prev = createArrow(true);\n                  next = createArrow(false);\n                  created = true;\n                  appendArrows();\n                }\n\n                if (prev && next) {\n                  bind();\n                }\n\n                this.arrows = {\n                  prev: prev,\n                  next: next\n                };\n              },\n\n              /**\r\n               * Called after all components are mounted.\r\n               */\n              mounted: function mounted() {\n                Splide.emit(name + \":mounted\", prev, next);\n              },\n\n              /**\r\n               * Destroy.\r\n               */\n              destroy: function destroy() {\n                removeAttribute([prev, next], 'disabled');\n\n                if (created) {\n                  dom_remove(prev.parentElement);\n                }\n              }\n            };\n            /**\r\n             * Listen to native and custom events.\r\n             */\n\n            function bind() {\n              Splide.on('click', function () {\n                Splide.go('<');\n              }, prev).on('click', function () {\n                Splide.go('>');\n              }, next).on('mounted move updated refresh', updateDisabled);\n            }\n            /**\r\n             * Update a disabled attribute.\r\n             */\n\n\n            function updateDisabled() {\n              var _Components$Controlle = Components.Controller,\n                  prevIndex = _Components$Controlle.prevIndex,\n                  nextIndex = _Components$Controlle.nextIndex;\n              var isEnough = Splide.length > Splide.options.perPage || Splide.is(LOOP);\n              prev.disabled = prevIndex < 0 || !isEnough;\n              next.disabled = nextIndex < 0 || !isEnough;\n              Splide.emit(name + \":updated\", prev, next, prevIndex, nextIndex);\n            }\n            /**\r\n             * Create a wrapper element and append arrows.\r\n             */\n\n\n            function appendArrows() {\n              var wrapper = create('div', {\n                \"class\": classes.arrows\n              });\n              append(wrapper, prev);\n              append(wrapper, next);\n              var slider = Elements.slider;\n              var parent = Splide.options.arrows === 'slider' && slider ? slider : root;\n              before(wrapper, parent.firstElementChild);\n            }\n            /**\r\n             * Create an arrow element.\r\n             *\r\n             * @param {boolean} prev - Determine to create a prev arrow or next arrow.\r\n             *\r\n             * @return {Element} - A created arrow element.\r\n             */\n\n\n            function createArrow(prev) {\n              var arrow = \"<button class=\\\"\" + classes.arrow + \" \" + (prev ? classes.prev : classes.next) + \"\\\" type=\\\"button\\\">\" + (\"<svg xmlns=\\\"\" + XML_NAME_SPACE + \"\\\"\\tviewBox=\\\"0 0 \" + SIZE + \" \" + SIZE + \"\\\"\\twidth=\\\"\" + SIZE + \"\\\"\\theight=\\\"\" + SIZE + \"\\\">\") + (\"<path d=\\\"\" + (Splide.options.arrowPath || PATH) + \"\\\" />\");\n              return domify(arrow);\n            }\n\n            return Arrows;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/components/pagination/index.js\n\n          /**\r\n           * The component for handling pagination\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The event name for updating some attributes of pagination nodes.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var ATTRIBUTES_UPDATE_EVENT = 'move.page';\n          /**\r\n           * The event name for recreating pagination.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var UPDATE_EVENT = 'updated.page refresh.page';\n          /**\r\n           * The component for handling pagination\r\n           *\r\n           * @param {Splide} Splide     - A Splide instance.\r\n           * @param {Object} Components - An object containing components.\r\n           * @param {string} name       - A component name as a lowercase string.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var pagination = function pagination(Splide, Components, name) {\n            /**\r\n             * Store all data for pagination.\r\n             * - list: A list element.\r\n             * - items: An array that contains objects(li, button, index, page).\r\n             *\r\n             * @type {Object}\r\n             */\n            var data = {};\n            /**\r\n             * Hold the Elements component.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Elements = Components.Elements;\n            /**\r\n             * Pagination component object.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Pagination = {\n              /**\r\n               * Called when the component is mounted.\r\n               */\n              mount: function mount() {\n                var pagination = Splide.options.pagination;\n\n                if (pagination) {\n                  data = createPagination();\n                  var slider = Elements.slider;\n                  var parent = pagination === 'slider' && slider ? slider : Splide.root;\n                  append(parent, data.list);\n                  Splide.on(ATTRIBUTES_UPDATE_EVENT, updateAttributes);\n                }\n\n                Splide.off(UPDATE_EVENT).on(UPDATE_EVENT, function () {\n                  Pagination.destroy();\n\n                  if (Splide.options.pagination) {\n                    Pagination.mount();\n                    Pagination.mounted();\n                  }\n                });\n              },\n\n              /**\r\n               * Called after all components are mounted.\r\n               */\n              mounted: function mounted() {\n                if (Splide.options.pagination) {\n                  var index = Splide.index;\n                  Splide.emit(name + \":mounted\", data, this.getItem(index));\n                  updateAttributes(index, -1);\n                }\n              },\n\n              /**\r\n               * Destroy the pagination.\r\n               * Be aware that node.remove() is not supported by IE.\r\n               */\n              destroy: function destroy() {\n                dom_remove(data.list);\n\n                if (data.items) {\n                  data.items.forEach(function (item) {\n                    Splide.off('click', item.button);\n                  });\n                } // Do not remove UPDATE_EVENT to recreate pagination if needed.\n\n\n                Splide.off(ATTRIBUTES_UPDATE_EVENT);\n                data = {};\n              },\n\n              /**\r\n               * Return an item by index.\r\n               *\r\n               * @param {number} index - A slide index.\r\n               *\r\n               * @return {Object|undefined} - An item object on success or undefined on failure.\r\n               */\n              getItem: function getItem(index) {\n                return data.items[Components.Controller.toPage(index)];\n              },\n\n              /**\r\n               * Return object containing pagination data.\r\n               *\r\n               * @return {Object} - Pagination data including list and items.\r\n               */\n              get data() {\n                return data;\n              }\n\n            };\n            /**\r\n             * Update attributes.\r\n             *\r\n             * @param {number} index     - Active index.\r\n             * @param {number} prevIndex - Prev index.\r\n             */\n\n            function updateAttributes(index, prevIndex) {\n              var prev = Pagination.getItem(prevIndex);\n              var curr = Pagination.getItem(index);\n              var active = STATUS_CLASSES.active;\n\n              if (prev) {\n                removeClass(prev.button, active);\n              }\n\n              if (curr) {\n                addClass(curr.button, active);\n              }\n\n              Splide.emit(name + \":updated\", data, prev, curr);\n            }\n            /**\r\n             * Create a wrapper and button elements.\r\n             *\r\n             * @return {Object} - An object contains all data.\r\n             */\n\n\n            function createPagination() {\n              var options = Splide.options;\n              var classes = Splide.classes;\n              var list = create('ul', {\n                \"class\": classes.pagination\n              });\n              var items = Elements.getSlides(false).filter(function (Slide) {\n                return options.focus !== false || Slide.index % options.perPage === 0;\n              }).map(function (Slide, page) {\n                var li = create('li', {});\n                var button = create('button', {\n                  \"class\": classes.page,\n                  type: 'button'\n                });\n                append(li, button);\n                append(list, li);\n                Splide.on('click', function () {\n                  Splide.go(\">\" + page);\n                }, button);\n                return {\n                  li: li,\n                  button: button,\n                  page: page,\n                  Slides: Elements.getSlidesByPage(page)\n                };\n              });\n              return {\n                list: list,\n                items: items\n              };\n            }\n\n            return Pagination;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/components/lazyload/index.js\n\n          /**\r\n           * The component for loading slider images lazily.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The name for a data attribute of src.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var SRC_DATA_NAME = 'data-splide-lazy';\n          /**\r\n           * The name for a data attribute of srcset.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var SRCSET_DATA_NAME = 'data-splide-lazy-srcset';\n          /**\r\n           * The component for loading slider images lazily.\r\n           *\r\n           * @param {Splide} Splide     - A Splide instance.\r\n           * @param {Object} Components - An object containing components.\r\n           * @param {string} name       - A component name as a lowercase string.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var lazyload = function lazyload(Splide, Components, name) {\n            /**\r\n             * Next index for sequential loading.\r\n             *\r\n             * @type {number}\r\n             */\n            var nextIndex;\n            /**\r\n             * Store objects containing an img element and a Slide object.\r\n             *\r\n             * @type {Object[]}\r\n             */\n\n            var images;\n            /**\r\n             * Store the options.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var options = Splide.options;\n            /**\r\n             * Whether to load images sequentially or not.\r\n             *\r\n             * @type {boolean}\r\n             */\n\n            var isSequential = options.lazyLoad === 'sequential';\n            /**\r\n             * Lazyload component object.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Lazyload = {\n              /**\r\n               * Mount only when the lazyload option is provided.\r\n               *\r\n               * @type {boolean}\r\n               */\n              required: options.lazyLoad,\n\n              /**\r\n               * Called when the component is mounted.\r\n               */\n              mount: function mount() {\n                Splide.on('mounted refresh', function () {\n                  init();\n                  Components.Elements.each(function (Slide) {\n                    each(Slide.slide.querySelectorAll(\"[\" + SRC_DATA_NAME + \"], [\" + SRCSET_DATA_NAME + \"]\"), function (img) {\n                      if (!img.src && !img.srcset) {\n                        images.push({\n                          img: img,\n                          Slide: Slide\n                        });\n                        applyStyle(img, {\n                          display: 'none'\n                        });\n                      }\n                    });\n                  });\n\n                  if (isSequential) {\n                    loadNext();\n                  }\n                });\n\n                if (!isSequential) {\n                  Splide.on(\"mounted refresh moved.\" + name, check);\n                }\n              },\n\n              /**\r\n               * Destroy.\r\n               */\n              destroy: init\n            };\n            /**\r\n             * Initialize parameters.\r\n             */\n\n            function init() {\n              images = [];\n              nextIndex = 0;\n            }\n            /**\r\n             * Check how close each image is from the active slide and\r\n             * determine whether to start loading or not, according to the distance.\r\n             *\r\n             * @param {number} index - Current index.\r\n             */\n\n\n            function check(index) {\n              index = isNaN(index) ? Splide.index : index;\n              images = images.filter(function (image) {\n                if (image.Slide.isWithin(index, options.perPage * (options.preloadPages + 1))) {\n                  load(image.img, image.Slide);\n                  return false;\n                }\n\n                return true;\n              }); // Unbind if all images are loaded.\n\n              if (!images[0]) {\n                Splide.off(\"moved.\" + name);\n              }\n            }\n            /**\r\n             * Start loading an image.\r\n             * Creating a clone of the image element since setting src attribute directly to it\r\n             * often occurs 'hitch', blocking some other processes of a browser.\r\n             *\r\n             * @param {Element} img   - An image element.\r\n             * @param {Object}  Slide - A Slide object.\r\n             */\n\n\n            function load(img, Slide) {\n              addClass(Slide.slide, STATUS_CLASSES.loading);\n              var spinner = create('span', {\n                \"class\": Splide.classes.spinner\n              });\n              append(img.parentElement, spinner);\n\n              img.onload = function () {\n                loaded(img, spinner, Slide, false);\n              };\n\n              img.onerror = function () {\n                loaded(img, spinner, Slide, true);\n              };\n\n              setAttribute(img, 'srcset', getAttribute(img, SRCSET_DATA_NAME) || '');\n              setAttribute(img, 'src', getAttribute(img, SRC_DATA_NAME) || '');\n            }\n            /**\r\n             * Start loading a next image in images array.\r\n             */\n\n\n            function loadNext() {\n              if (nextIndex < images.length) {\n                var image = images[nextIndex];\n                load(image.img, image.Slide);\n              }\n\n              nextIndex++;\n            }\n            /**\r\n             * Called just after the image was loaded or loading was aborted by some error.\r\n             *\r\n             * @param {Element} img     - An image element.\r\n             * @param {Element} spinner - A spinner element.\r\n             * @param {Object}  Slide   - A Slide object.\r\n             * @param {boolean} error   - True if the image was loaded successfully or false on error.\r\n             */\n\n\n            function loaded(img, spinner, Slide, error) {\n              removeClass(Slide.slide, STATUS_CLASSES.loading);\n\n              if (!error) {\n                dom_remove(spinner);\n                applyStyle(img, {\n                  display: ''\n                });\n                Splide.emit(name + \":loaded\", img).emit('resize');\n              }\n\n              if (isSequential) {\n                loadNext();\n              }\n            }\n\n            return Lazyload;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/constants/a11y.js\n\n          /**\r\n           * Export aria attribute names.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * Attribute name for aria-current.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var ARIA_CURRENRT = 'aria-current';\n          /**\r\n           * Attribute name for aria-control.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var ARIA_CONTROLS = 'aria-controls';\n          /**\r\n           * Attribute name for aria-control.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var ARIA_LABEL = 'aria-label';\n          /**\r\n           * Attribute name for aria-labelledby.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var ARIA_LABELLEDBY = 'aria-labelledby';\n          /**\r\n           * Attribute name for aria-hidden.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var ARIA_HIDDEN = 'aria-hidden';\n          /**\r\n           * Attribute name for tab-index.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var TAB_INDEX = 'tabindex';\n          ; // CONCATENATED MODULE: ./src/js/components/keyboard/index.js\n\n          /**\r\n           * The component for controlling slides via keyboard.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * Map a key to a slide control.\r\n           *\r\n           * @type {Object}\r\n           */\n\n          var KEY_MAP = {\n            ltr: {\n              ArrowLeft: '<',\n              ArrowRight: '>',\n              // For IE.\n              Left: '<',\n              Right: '>'\n            },\n            rtl: {\n              ArrowLeft: '>',\n              ArrowRight: '<',\n              // For IE.\n              Left: '>',\n              Right: '<'\n            },\n            ttb: {\n              ArrowUp: '<',\n              ArrowDown: '>',\n              // For IE.\n              Up: '<',\n              Down: '>'\n            }\n          };\n          /**\r\n           * The component for controlling slides via keyboard.\r\n           *\r\n           * @param {Splide} Splide - A Splide instance.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var keyboard = function keyboard(Splide) {\n            /**\r\n             * Hold the target element.\r\n             *\r\n             * @type {Element|Document|undefined}\r\n             */\n            var target;\n            return {\n              /**\r\n               * Called when the component is mounted.\r\n               */\n              mount: function mount() {\n                Splide.on('mounted updated', function () {\n                  var options = Splide.options;\n                  var root = Splide.root;\n                  var map = KEY_MAP[options.direction];\n                  var keyboard = options.keyboard;\n\n                  if (target) {\n                    Splide.off('keydown', target);\n                    removeAttribute(root, TAB_INDEX);\n                  }\n\n                  if (keyboard) {\n                    if (keyboard === 'focused') {\n                      target = root;\n                      setAttribute(root, TAB_INDEX, 0);\n                    } else {\n                      target = document;\n                    }\n\n                    Splide.on('keydown', function (e) {\n                      if (map[e.key]) {\n                        Splide.go(map[e.key]);\n                      }\n                    }, target);\n                  }\n                });\n              }\n            };\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/components/a11y/index.js\n\n          /**\r\n           * The component for enhancing accessibility.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The component for enhancing accessibility.\r\n           *\r\n           * @param {Splide} Splide     - A Splide instance.\r\n           * @param {Object} Components - An object containing components.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var a11y = function a11y(Splide, Components) {\n            /**\r\n             * Hold a i18n object.\r\n             *\r\n             * @type {Object}\r\n             */\n            var i18n = Splide.i18n;\n            /**\r\n             * Hold the Elements component.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Elements = Components.Elements;\n            /**\r\n             * All attributes related with A11y.\r\n             *\r\n             * @type {string[]}\r\n             */\n\n            var allAttributes = [ARIA_HIDDEN, TAB_INDEX, ARIA_CONTROLS, ARIA_LABEL, ARIA_CURRENRT, 'role'];\n            /**\r\n             * A11y component object.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var A11y = {\n              /**\r\n               * Required only when the accessibility option is true.\r\n               *\r\n               * @type {boolean}\r\n               */\n              required: Splide.options.accessibility,\n\n              /**\r\n               * Called when the component is mounted.\r\n               */\n              mount: function mount() {\n                Splide.on('visible', function (Slide) {\n                  updateSlide(Slide.slide, true);\n                }).on('hidden', function (Slide) {\n                  updateSlide(Slide.slide, false);\n                }).on('arrows:mounted', initArrows).on('arrows:updated', updateArrows).on('pagination:mounted', initPagination).on('pagination:updated', updatePagination).on('refresh', function () {\n                  removeAttribute(Components.Clones.clones, allAttributes);\n                });\n\n                if (Splide.options.isNavigation) {\n                  Splide.on('navigation:mounted navigation:updated', initNavigation).on('active', function (Slide) {\n                    updateNavigation(Slide, true);\n                  }).on('inactive', function (Slide) {\n                    updateNavigation(Slide, false);\n                  });\n                }\n\n                initAutoplay();\n              },\n\n              /**\r\n               * Destroy.\r\n               */\n              destroy: function destroy() {\n                var Arrows = Components.Arrows;\n                var arrows = Arrows ? Arrows.arrows : {};\n                removeAttribute(Elements.slides.concat([arrows.prev, arrows.next, Elements.play, Elements.pause]), allAttributes);\n              }\n            };\n            /**\r\n             * Update slide attributes when it gets visible or hidden.\r\n             *\r\n             * @param {Element} slide   - A slide element.\r\n             * @param {Boolean} visible - True when the slide gets visible, or false when hidden.\r\n             */\n\n            function updateSlide(slide, visible) {\n              setAttribute(slide, ARIA_HIDDEN, !visible);\n\n              if (Splide.options.slideFocus) {\n                setAttribute(slide, TAB_INDEX, visible ? 0 : -1);\n              }\n            }\n            /**\r\n             * Initialize arrows if they are available.\r\n             * Append screen reader elements and add aria-controls attribute.\r\n             *\r\n             * @param {Element} prev - Previous arrow element.\r\n             * @param {Element} next - Next arrow element.\r\n             */\n\n\n            function initArrows(prev, next) {\n              var controls = Elements.track.id;\n              setAttribute(prev, ARIA_CONTROLS, controls);\n              setAttribute(next, ARIA_CONTROLS, controls);\n            }\n            /**\r\n             * Update arrow attributes.\r\n             *\r\n             * @param {Element} prev      - Previous arrow element.\r\n             * @param {Element} next      - Next arrow element.\r\n             * @param {number}  prevIndex - Previous slide index or -1 when there is no precede slide.\r\n             * @param {number}  nextIndex - Next slide index or -1 when there is no next slide.\r\n             */\n\n\n            function updateArrows(prev, next, prevIndex, nextIndex) {\n              var index = Splide.index;\n              var prevLabel = prevIndex > -1 && index < prevIndex ? i18n.last : i18n.prev;\n              var nextLabel = nextIndex > -1 && index > nextIndex ? i18n.first : i18n.next;\n              setAttribute(prev, ARIA_LABEL, prevLabel);\n              setAttribute(next, ARIA_LABEL, nextLabel);\n            }\n            /**\r\n             * Initialize pagination if it's available.\r\n             * Append a screen reader element and add aria-controls/label attribute to each item.\r\n             *\r\n             * @param {Object} data       - Data object containing all items.\r\n             * @param {Object} activeItem - An initial active item.\r\n             */\n\n\n            function initPagination(data, activeItem) {\n              if (activeItem) {\n                setAttribute(activeItem.button, ARIA_CURRENRT, true);\n              }\n\n              data.items.forEach(function (item) {\n                var options = Splide.options;\n                var text = options.focus === false && options.perPage > 1 ? i18n.pageX : i18n.slideX;\n                var label = sprintf(text, item.page + 1);\n                var button = item.button;\n                var controls = item.Slides.map(function (Slide) {\n                  return Slide.slide.id;\n                });\n                setAttribute(button, ARIA_CONTROLS, controls.join(' '));\n                setAttribute(button, ARIA_LABEL, label);\n              });\n            }\n            /**\r\n             * Update pagination attributes.\r\n             *\r\n             * @param {Object}  data - Data object containing all items.\r\n             * @param {Element} prev - A previous active element.\r\n             * @param {Element} curr - A current active element.\r\n             */\n\n\n            function updatePagination(data, prev, curr) {\n              if (prev) {\n                removeAttribute(prev.button, ARIA_CURRENRT);\n              }\n\n              if (curr) {\n                setAttribute(curr.button, ARIA_CURRENRT, true);\n              }\n            }\n            /**\r\n             * Initialize autoplay buttons.\r\n             */\n\n\n            function initAutoplay() {\n              ['play', 'pause'].forEach(function (name) {\n                var elm = Elements[name];\n\n                if (elm) {\n                  if (!isButton(elm)) {\n                    setAttribute(elm, 'role', 'button');\n                  }\n\n                  setAttribute(elm, ARIA_CONTROLS, Elements.track.id);\n                  setAttribute(elm, ARIA_LABEL, i18n[name]);\n                }\n              });\n            }\n            /**\r\n             * Initialize navigation slider.\r\n             * Add button role, aria-label, aria-controls to slide elements and append screen reader text to them.\r\n             *\r\n             * @param {Splide} main - A main Splide instance.\r\n             */\n\n\n            function initNavigation(main) {\n              Elements.each(function (Slide) {\n                var slide = Slide.slide;\n                var realIndex = Slide.realIndex;\n\n                if (!isButton(slide)) {\n                  setAttribute(slide, 'role', 'button');\n                }\n\n                var slideIndex = realIndex > -1 ? realIndex : Slide.index;\n                var label = sprintf(i18n.slideX, slideIndex + 1);\n                var mainSlide = main.Components.Elements.getSlide(slideIndex);\n                setAttribute(slide, ARIA_LABEL, label);\n\n                if (mainSlide) {\n                  setAttribute(slide, ARIA_CONTROLS, mainSlide.slide.id);\n                }\n              });\n            }\n            /**\r\n             * Update navigation attributes.\r\n             *\r\n             * @param {Object}  Slide  - A target Slide object.\r\n             * @param {boolean} active - True if the slide is active or false if inactive.\r\n             */\n\n\n            function updateNavigation(_ref, active) {\n              var slide = _ref.slide;\n\n              if (active) {\n                setAttribute(slide, ARIA_CURRENRT, true);\n              } else {\n                removeAttribute(slide, ARIA_CURRENRT);\n              }\n            }\n            /**\r\n             * Check if the given element is button or not.\r\n             *\r\n             * @param {Element} elm - An element to be checked.\r\n             *\r\n             * @return {boolean} - True if the given element is button.\r\n             */\n\n\n            function isButton(elm) {\n              return elm.tagName === 'BUTTON';\n            }\n\n            return A11y;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/components/sync/index.js\n\n          /**\r\n           * The component for synchronizing a slider with another.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * The event name for sync.\r\n           *\r\n           * @type {string}\r\n           */\n\n          var SYNC_EVENT = 'move.sync';\n          /**\r\n           * The event names for click navigation.\r\n           * @type {string}\r\n           */\n\n          var CLICK_EVENTS = 'mouseup touchend';\n          /**\r\n           * The keys for triggering the navigation button.\r\n           *\r\n           * @type {String[]}\r\n           */\n\n          var TRIGGER_KEYS = [' ', 'Enter', 'Spacebar'];\n          /**\r\n           * The component for synchronizing a slider with another.\r\n           *\r\n           * @param {Splide} Splide - A Splide instance.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var sync = function sync(Splide) {\n            /**\r\n             * Keep the sibling Splide instance.\r\n             *\r\n             * @type {Splide}\r\n             */\n            var sibling = Splide.sibling;\n            /**\r\n             * Whether the sibling slider is navigation or not.\r\n             *\r\n             * @type {Splide|boolean}\r\n             */\n\n            var isNavigation = sibling && sibling.options.isNavigation;\n            /**\r\n             * Layout component object.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Sync = {\n              /**\r\n               * Required only when the sub slider is available.\r\n               *\r\n               * @type {boolean}\r\n               */\n              required: !!sibling,\n\n              /**\r\n               * Called when the component is mounted.\r\n               */\n              mount: function mount() {\n                syncMain();\n                syncSibling();\n\n                if (isNavigation) {\n                  bind();\n                  Splide.on('refresh', function () {\n                    setTimeout(function () {\n                      bind();\n                      sibling.emit('navigation:updated', Splide);\n                    });\n                  });\n                }\n              },\n\n              /**\r\n               * Called after all components are mounted.\r\n               */\n              mounted: function mounted() {\n                if (isNavigation) {\n                  sibling.emit('navigation:mounted', Splide);\n                }\n              }\n            };\n            /**\r\n             * Listen the primary slider event to move secondary one.\r\n             * Must unbind a handler at first to avoid infinite loop.\r\n             */\n\n            function syncMain() {\n              Splide.on(SYNC_EVENT, function (newIndex, prevIndex, destIndex) {\n                sibling.off(SYNC_EVENT).go(sibling.is(LOOP) ? destIndex : newIndex, false);\n                syncSibling();\n              });\n            }\n            /**\r\n             * Listen the secondary slider event to move primary one.\r\n             * Must unbind a handler at first to avoid infinite loop.\r\n             */\n\n\n            function syncSibling() {\n              sibling.on(SYNC_EVENT, function (newIndex, prevIndex, destIndex) {\n                Splide.off(SYNC_EVENT).go(Splide.is(LOOP) ? destIndex : newIndex, false);\n                syncMain();\n              });\n            }\n            /**\r\n             * Listen some events on each slide.\r\n             */\n\n\n            function bind() {\n              sibling.Components.Elements.each(function (_ref) {\n                var slide = _ref.slide,\n                    index = _ref.index;\n                /*\r\n                 * Listen mouseup and touchend events to handle click.\r\n                 */\n\n                Splide.off(CLICK_EVENTS, slide).on(CLICK_EVENTS, function (e) {\n                  // Ignore a middle or right click.\n                  if (!e.button || e.button === 0) {\n                    moveSibling(index);\n                  }\n                }, slide);\n                /*\r\n                 * Subscribe keyup to handle Enter and Space key.\r\n                 * Note that Array.includes is not supported by IE.\r\n                 */\n\n                Splide.off('keyup', slide).on('keyup', function (e) {\n                  if (TRIGGER_KEYS.indexOf(e.key) > -1) {\n                    e.preventDefault();\n                    moveSibling(index);\n                  }\n                }, slide, {\n                  passive: false\n                });\n              });\n            }\n            /**\r\n             * Move the sibling to the given index.\r\n             * Need to check \"IDLE\" status because slides can be moving by Drag component.\r\n             *\r\n             * @param {number} index - Target index.\r\n             */\n\n\n            function moveSibling(index) {\n              if (Splide.State.is(_IDLE)) {\n                sibling.go(index);\n              }\n            }\n\n            return Sync;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/components/breakpoints/index.js\n\n          /**\r\n           * The component for updating options according to a current window width.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * Interval time for throttle.\r\n           *\r\n           * @type {number}\r\n           */\n\n          var THROTTLE = 50;\n          /**\r\n           * The component for updating options according to a current window width.\r\n           *\r\n           * @param {Splide} Splide - A Splide instance.\r\n           *\r\n           * @return {Object} - The component object.\r\n           */\n\n          /* harmony default export */\n\n          var breakpoints = function breakpoints(Splide) {\n            /**\r\n             * Store breakpoints.\r\n             *\r\n             * @type {Object|boolean}\r\n             */\n            var breakpoints = Splide.options.breakpoints;\n            /**\r\n             * The check function whose frequency of call is reduced.\r\n             *\r\n             * @type {Function}\r\n             */\n\n            var throttledCheck = throttle(check, THROTTLE);\n            /**\r\n             * Keep initial options.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var initialOptions;\n            /**\r\n             * An array containing objects of point and MediaQueryList.\r\n             *\r\n             * @type {Object[]}\r\n             */\n\n            var map = [];\n            /**\r\n             * Hold the previous breakpoint.\r\n             *\r\n             * @type {number|undefined}\r\n             */\n\n            var prevPoint;\n            /**\r\n             * Breakpoints component object.\r\n             *\r\n             * @type {Object}\r\n             */\n\n            var Breakpoints = {\n              /**\r\n               * Required only when the breakpoints definition is provided and browser supports matchMedia.\r\n               *\r\n               * @type {boolean}\r\n               */\n              required: breakpoints && matchMedia,\n\n              /**\r\n               * Called when the component is mounted.\r\n               */\n              mount: function mount() {\n                map = Object.keys(breakpoints).sort(function (n, m) {\n                  return +n - +m;\n                }).map(function (point) {\n                  return {\n                    point: point,\n                    mql: matchMedia(\"(max-width:\" + point + \"px)\")\n                  };\n                });\n                /*\r\n                 * To keep monitoring resize event after destruction without \"completely\",\r\n                 * use native addEventListener instead of Splide.on.\r\n                 */\n\n                this.destroy(true);\n                addEventListener('resize', throttledCheck); // Keep initial options to apply them when no breakpoint matches.\n\n                initialOptions = Splide.options;\n                check();\n              },\n\n              /**\r\n               * Destroy.\r\n               *\r\n               * @param {boolean} completely - Whether to destroy Splide completely.\r\n               */\n              destroy: function destroy(completely) {\n                if (completely) {\n                  removeEventListener('resize', throttledCheck);\n                }\n              }\n            };\n            /**\r\n             * Check the breakpoint.\r\n             */\n\n            function check() {\n              var point = getPoint();\n\n              if (point !== prevPoint) {\n                prevPoint = point;\n                var State = Splide.State;\n                var options = breakpoints[point] || initialOptions;\n                var destroy = options.destroy;\n\n                if (destroy) {\n                  Splide.options = initialOptions;\n                  Splide.destroy(destroy === 'completely');\n                } else {\n                  if (State.is(_DESTROYED)) {\n                    Splide.mount();\n                  }\n\n                  Splide.options = options;\n                }\n              }\n            }\n            /**\r\n             * Return the breakpoint matching current window width.\r\n             * Note that Array.prototype.find is not supported by IE.\r\n             *\r\n             * @return {number|string} - A breakpoint as number or string. -1 if no point matches.\r\n             */\n\n\n            function getPoint() {\n              var item = map.filter(function (item) {\n                return item.mql.matches;\n              })[0];\n              return item ? item.point : -1;\n            }\n\n            return Breakpoints;\n          };\n\n          ; // CONCATENATED MODULE: ./src/js/components/index.js\n\n          /**\r\n           * Export components.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          var COMPLETE = {\n            Options: options,\n            Breakpoints: breakpoints,\n            Controller: controller,\n            Elements: components_elements,\n            Track: track,\n            Clones: clones,\n            Layout: layout,\n            Drag: drag,\n            Click: click,\n            Autoplay: autoplay,\n            Cover: cover,\n            Arrows: arrows,\n            Pagination: pagination,\n            LazyLoad: lazyload,\n            Keyboard: keyboard,\n            Sync: sync,\n            A11y: a11y\n          };\n          var LIGHT = {\n            Options: options,\n            Controller: controller,\n            Elements: components_elements,\n            Track: track,\n            Clones: clones,\n            Layout: layout,\n            Drag: drag,\n            Click: click,\n            Arrows: arrows,\n            Pagination: pagination,\n            A11y: a11y\n          };\n          ; // CONCATENATED MODULE: ./build/module/module.js\n\n          function _inheritsLoose(subClass, superClass) {\n            subClass.prototype = Object.create(superClass.prototype);\n            subClass.prototype.constructor = subClass;\n            subClass.__proto__ = superClass;\n          }\n          /**\r\n           * Export Splide class for import.\r\n           *\r\n           * @author    Naotoshi Fujita\r\n           * @copyright Naotoshi Fujita. All rights reserved.\r\n           */\n\n          /**\r\n           * Export Splide class for import from other projects.\r\n           */\n\n\n          var module_Splide = /*#__PURE__*/function (_Core) {\n            _inheritsLoose(Splide, _Core);\n\n            function Splide(root, options) {\n              return _Core.call(this, root, options, COMPLETE) || this;\n            }\n\n            return Splide;\n          }(Splide);\n          /***/\n\n        }\n        /******/\n\n      };\n      /************************************************************************/\n\n      /******/\n      // The module cache\n\n      /******/\n\n      var __webpack_module_cache__ = {};\n      /******/\n\n      /******/\n      // The require function\n\n      /******/\n\n      function __webpack_require__(moduleId) {\n        /******/\n        // Check if module is in cache\n\n        /******/\n        if (__webpack_module_cache__[moduleId]) {\n          /******/\n          return __webpack_module_cache__[moduleId].exports;\n          /******/\n        }\n        /******/\n        // Create a new module (and put it into the cache)\n\n        /******/\n\n\n        var module = __webpack_module_cache__[moduleId] = {\n          /******/\n          // no module.id needed\n\n          /******/\n          // no module.loaded needed\n\n          /******/\n          exports: {}\n          /******/\n\n        };\n        /******/\n\n        /******/\n        // Execute the module function\n\n        /******/\n\n        __webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n        /******/\n\n        /******/\n        // Return the exports of the module\n\n        /******/\n\n\n        return module.exports;\n        /******/\n      }\n      /******/\n\n      /************************************************************************/\n\n      /******/\n\n      /* webpack/runtime/define property getters */\n\n      /******/\n\n\n      (function () {\n        /******/\n        // define getter functions for harmony exports\n\n        /******/\n        __webpack_require__.d = function (exports, definition) {\n          /******/\n          for (var key in definition) {\n            /******/\n            if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n              /******/\n              Object.defineProperty(exports, key, {\n                enumerable: true,\n                get: definition[key]\n              });\n              /******/\n            }\n            /******/\n\n          }\n          /******/\n\n        };\n        /******/\n\n      })();\n      /******/\n\n      /******/\n\n      /* webpack/runtime/hasOwnProperty shorthand */\n\n      /******/\n\n\n      (function () {\n        /******/\n        __webpack_require__.o = function (obj, prop) {\n          return Object.prototype.hasOwnProperty.call(obj, prop);\n        };\n        /******/\n\n      })();\n      /******/\n\n      /******/\n\n      /* webpack/runtime/make namespace object */\n\n      /******/\n\n\n      (function () {\n        /******/\n        // define __esModule on exports\n\n        /******/\n        __webpack_require__.r = function (exports) {\n          /******/\n          if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n            /******/\n            Object.defineProperty(exports, Symbol.toStringTag, {\n              value: 'Module'\n            });\n            /******/\n          }\n          /******/\n\n\n          Object.defineProperty(exports, '__esModule', {\n            value: true\n          });\n          /******/\n        };\n        /******/\n\n      })();\n      /******/\n\n      /************************************************************************/\n\n      /******/\n      // module exports must be returned from runtime so entry inlining is disabled\n\n      /******/\n      // startup\n\n      /******/\n      // Load entry module and return exports\n\n      /******/\n\n\n      return __webpack_require__(311);\n      /******/\n    }()\n  );\n});"],"sourceRoot":""}