{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///(webpack)/buildin/module.js","webpack:///./node_modules/@splidejs/splide/dist/js/splide.esm.js","webpack:///./frontend/packs/javascripts/shared/welcome/heroSlider.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","webpackPolyfill","deprecate","paths","children","factory","_typeof","iterator","obj","constructor","self","__webpack_modules__","__unused_webpack_module","__webpack_exports__","states_namespaceObject","_extends","assign","target","arguments","length","source","apply","this","_CREATED","_DESTROYED","_IDLE","_MOUNTED","_MOVING","keys","each","callback","some","index","values","map","isObject","subject","merge","_ref","from","to","toArray","Array","isArray","between","m1","m2","Math","min","max","sprintf","format","replacements","replace","unit","type","parseFloat","pad","number","toPixel","root","div","applyStyle","position","width","append","clientWidth","dom_remove","find","elm","selector","querySelector","split","child","parent","tagOrClassName","filter","hasClass","tagName","tag","attrs","document","createElement","setAttribute","domify","html","innerHTML","firstChild","elms","forEach","parentElement","removeChild","appendChild","before","ref","insertBefore","styles","prop","style","addOrRemoveClasses","classes","remove","classList","addClass","removeClass","className","contains","getAttribute","removeAttribute","names","getRect","getBoundingClientRect","SLIDE","LOOP","FADE","slide","Splide","Components","list","endCallback","mount","Elements","on","e","start","destIndex","newIndex","prevIndex","coord","done","options","edgeIndex","Controller","speed","is","rewindSpeed","transition","easing","transform","x","y","fade","slides","track","height","clientHeight","setTimeout","error","message","console","MESSAGE_PREFIX","exist","Error","ROOT","STATUS_CLASSES","active","visible","loading","DEFAULTS","rewind","waitForTransition","fixedWidth","fixedHeight","heightRatio","autoWidth","autoHeight","perPage","perMove","clones","focus","gap","padding","arrows","arrowPath","pagination","autoplay","interval","pauseOnHover","pauseOnFocus","resetProgress","lazyLoad","preloadPages","keyboard","drag","dragAngleThreshold","swipeDistanceThreshold","flickVelocityThreshold","flickPower","flickMaxPages","direction","cover","accessibility","slideFocus","isNavigation","trimSpace","updateOnMove","throttle","destroy","breakpoints","slider","container","arrow","prev","next","page","clone","progress","bar","play","pause","spinner","sr","i18n","first","last","slideX","pageX","_defineProperties","props","descriptor","configurable","writable","curr","Element","Event","data","unsubscribe","item","removeEventListener","event","handler","events","addEventListener","push","off","emit","_len","args","_key","core_event","State","set","state","STATES","_o","_i","_c","_e","_t","Constructor","protoProps","staticProps","_proto","Extensions","Transition","_this","components","Component","toLowerCase","compose","component","required","undefined","mounted","visibility","sync","splide","sibling","_this$Event","concat","go","control","wait","add","refresh","completely","_this2","reverse","parseInt","created","JSON","parse","RTL","TTB","STYLE_RESTORE_EVENTS","components_elements","Slides","id","window","uid","init","getClasses","Slide","findParts","collect","register","realIndex","SlideObject","STATUS_UPDATE_EVENTS","isClone","update","restoreStyles","_update","display","isActive","isVisible","ceil","trackRect","slideRect","top","bottom","left","right","isWithin","within","diff","abs","forVisibility","elements_slide","getSlide","getSlides","includeClones","getSlidesByPage","idx","toIndex","splice","images","querySelectorAll","count","img","onload","onerror","loaded","rootClass","floor","controller","isLoop","newOptions","silently","trim","Track","matches","String","match","indicator","sign","toPage","parsePage","hasFocus","pageLength","edge","isRtl","Layout","isVertical","isFade","isRTL","isLoopPending","jump","newPosition","getTrimmedPosition","toCoord","onTransitionEnd","translate","cancel","shift","toPosition","innerSize","totalSize","size","minDistance","Infinity","slideIndex","distance","slideSize","offset","cloneCount","Clones","getCloneCount","slice","cloneDeeply","generateClones","baseCount","dimension","fixedSize","cloneNode","func","timeout","layout","resize","totalHeight","totalWidth","slideHeight","slideWidth","margin","paddingTop","paddingBottom","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","time","click","onClick","stopPropagation","stopImmediatePropagation","capture","PAUSE_FLAGS","updateDisabled","_Components$Controlle","nextIndex","isEnough","createArrow","wrapper","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","controls","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","f","indexOf","Cover","uncover","src","background","LazyLoad","isSequential","isNaN","image","load","loadNext","srcset","Keyboard","Sync","syncMain","syncSibling","moveSibling","A11y","module_Splide","_Core","subClass","superClass","__proto__","__webpack_module_cache__","definition"],"mappings":";aACE,IAAIA,EAAmB,GAGvB,SAASC,EAAoBC,GAG5B,GAAGF,EAAiBE,GACnB,OAAOF,EAAiBE,GAAUC,QAGnC,IAAIC,EAASJ,EAAiBE,GAAY,CACzCG,EAAGH,EACHI,GAAG,EACHH,QAAS,IAUV,OANAI,EAAQL,GAAUM,KAAKJ,EAAOD,QAASC,EAAQA,EAAOD,QAASF,GAG/DG,EAAOE,GAAI,EAGJF,EAAOD,QAKfF,EAAoBQ,EAAIF,EAGxBN,EAAoBS,EAAIV,EAGxBC,EAAoBU,EAAI,SAASR,EAASS,EAAMC,GAC3CZ,EAAoBa,EAAEX,EAASS,IAClCG,OAAOC,eAAeb,EAASS,EAAM,CAAEK,YAAY,EAAMC,IAAKL,KAKhEZ,EAAoBkB,EAAI,SAAShB,GACX,qBAAXiB,QAA0BA,OAAOC,aAC1CN,OAAOC,eAAeb,EAASiB,OAAOC,YAAa,CAAEC,MAAO,WAE7DP,OAAOC,eAAeb,EAAS,aAAc,CAAEmB,OAAO,KAQvDrB,EAAoBsB,EAAI,SAASD,EAAOE,GAEvC,GADU,EAAPA,IAAUF,EAAQrB,EAAoBqB,IAC/B,EAAPE,EAAU,OAAOF,EACpB,GAAW,EAAPE,GAA8B,kBAAVF,GAAsBA,GAASA,EAAMG,WAAY,OAAOH,EAChF,IAAII,EAAKX,OAAOY,OAAO,MAGvB,GAFA1B,EAAoBkB,EAAEO,GACtBX,OAAOC,eAAeU,EAAI,UAAW,CAAET,YAAY,EAAMK,MAAOA,IACtD,EAAPE,GAA4B,iBAATF,EAAmB,IAAI,IAAIM,KAAON,EAAOrB,EAAoBU,EAAEe,EAAIE,EAAK,SAASA,GAAO,OAAON,EAAMM,IAAQC,KAAK,KAAMD,IAC9I,OAAOF,GAIRzB,EAAoB6B,EAAI,SAAS1B,GAChC,IAAIS,EAAST,GAAUA,EAAOqB,WAC7B,WAAwB,OAAOrB,EAAgB,SAC/C,WAA8B,OAAOA,GAEtC,OADAH,EAAoBU,EAAEE,EAAQ,IAAKA,GAC5BA,GAIRZ,EAAoBa,EAAI,SAASiB,EAAQC,GAAY,OAAOjB,OAAOkB,UAAUC,eAAe1B,KAAKuB,EAAQC,IAGzG/B,EAAoBkC,EAAI,yCAIjBlC,EAAoBA,EAAoBmC,EAAI,K,mBClFrDhC,EAAOD,QAAU,SAAUC,GAsBzB,OArBKA,EAAOiC,kBACVjC,EAAOkC,UAAY,aAEnBlC,EAAOmC,MAAQ,GAEVnC,EAAOoC,WAAUpC,EAAOoC,SAAW,IACxCzB,OAAOC,eAAeZ,EAAQ,SAAU,CACtCa,YAAY,EACZC,IAAK,WACH,OAAOd,EAAOE,KAGlBS,OAAOC,eAAeZ,EAAQ,KAAM,CAClCa,YAAY,EACZC,IAAK,WACH,OAAOd,EAAOC,KAGlBD,EAAOiC,gBAAkB,GAGpBjC,I,oBCtBT,sBAQiDqC,EARjD,cAAmD,OAAOC,EAAU,mBAAqBtB,QAAU,iBAAmBA,OAAOuB,SAAW,SAAUC,GAAO,cAAcA,GAAS,SAAUA,GAAO,OAAOA,GAAO,mBAAqBxB,QAAUwB,EAAIC,cAAgBzB,QAAUwB,IAAQxB,OAAOa,UAAY,gBAAkBW,IAAgBA,GAUtUE,KAF8CL,EAExC,WACP,OAEE,WAIE,aAGA,IAAIM,EAAsB,CAExB,IAEA,SAAWC,EAAyBC,EAAqBhD,GAEvDA,EAAoBkB,EAAE8B,GAGtBhD,EAAoBU,EAAEsC,EAAqB,CACzC,QAAW,WACT,OAAO,MAQX,IAAIC,EAAyB,GA+L7B,SAASC,IAeP,OAdAA,EAAWpC,OAAOqC,QAAU,SAAUC,GACpC,IAAK,IAAIhD,EAAI,EAAGA,EAAIiD,UAAUC,OAAQlD,IAAK,CACzC,IAAImD,EAASF,UAAUjD,GAEvB,IAAK,IAAIuB,KAAO4B,EACVzC,OAAOkB,UAAUC,eAAe1B,KAAKgD,EAAQ5B,KAC/CyB,EAAOzB,GAAO4B,EAAO5B,IAK3B,OAAOyB,IAGOI,MAAMC,KAAMJ,WA5M9BrD,EAAoBkB,EAAE+B,GAEtBjD,EAAoBU,EAAEuC,EAAwB,CAC5C,QAAW,WACT,OAAOS,GAET,UAAa,WACX,OAAOC,GAET,KAAQ,WACN,OAAOC,GAET,QAAW,WACT,OAAOC,GAET,OAAU,WACR,OAAOC,KAsMX,IAAIC,EAAOjD,OAAOiD,KASlB,SAASC,EAAKrB,EAAKsB,GACjBF,EAAKpB,GAAKuB,MAAK,SAAUvC,EAAKwC,GAC5B,OAAOF,EAAStB,EAAIhB,GAAMA,EAAKwC,MAanC,SAASC,EAAOzB,GACd,OAAOoB,EAAKpB,GAAK0B,KAAI,SAAU1C,GAC7B,OAAOgB,EAAIhB,MAYf,SAAS2C,EAASC,GAChB,MAA4B,WAArB9B,EAAQ8B,GAYjB,SAASC,EAAMC,EAAMC,GACnB,IAAIC,EAAKzB,EAAS,GAAIuB,GAatB,OAXAT,EAAKU,GAAM,SAAUrD,EAAOM,GACtB2C,EAASjD,IACNiD,EAASK,EAAGhD,MACfgD,EAAGhD,GAAO,IAGZgD,EAAGhD,GAAO6C,EAAMG,EAAGhD,GAAMN,IAEzBsD,EAAGhD,GAAON,KAGPsD,EAsCT,SAASC,EAAQvD,GACf,OAAOwD,MAAMC,QAAQzD,GAASA,EAAQ,CAACA,GAczC,SAAS0D,EAAQ1D,EAAO2D,EAAIC,GAC1B,OAAOC,KAAKC,IAAID,KAAKE,IAAI/D,EAAO2D,EAAKC,EAAKA,EAAKD,GAAKA,EAAKC,EAAKD,EAAKC,GAYrE,SAASI,EAAQC,EAAQC,GACvB,IAAInF,EAAI,EACR,OAAOkF,EAAOE,QAAQ,OAAO,WAC3B,OAAOZ,EAAQW,GAAcnF,QAajC,SAASqF,EAAKpE,GACZ,IAAIqE,EAAOjD,EAAQpB,GAEnB,MAAa,WAATqE,GAAqBrE,EAAQ,EACxBsE,WAAWtE,GAAS,KAGb,WAATqE,EAAoBrE,EAAQ,GAWrC,SAASuE,EAAIC,GACX,OAAOA,EAAS,GAAK,IAAMA,EAASA,EAYtC,SAASC,EAAQC,EAAM1E,GACrB,GAAqB,kBAAVA,EAAoB,CAC7B,IAAI2E,EAAMtE,EAAO,MAAO,IACxBuE,EAAWD,EAAK,CACdE,SAAU,WACVC,MAAO9E,IAET+E,EAAOL,EAAMC,GACb3E,EAAQ2E,EAAIK,YACZC,EAAWN,GAGb,OAAQ3E,GAAS,EAsBnB,SAASkF,EAAKC,EAAKC,GACjB,OAAOD,EAAMA,EAAIE,cAAcD,EAASE,MAAM,KAAK,IAAM,KAY3D,SAASC,EAAMC,EAAQC,GACrB,OAAOvE,EAASsE,EAAQC,GAAgB,GAY1C,SAASvE,EAASsE,EAAQC,GACxB,OAAID,EACKzC,EAAOyC,EAAOtE,UAAUwE,QAAO,SAAUH,GAC9C,OAAOI,EAASJ,EAAOE,EAAeH,MAAM,KAAK,KAAOC,EAAMK,UAAYH,KAIvE,GAYT,SAASpF,EAAOwF,EAAKC,GACnB,IAAIX,EAAMY,SAASC,cAAcH,GAIjC,OAHAlD,EAAKmD,GAAO,SAAU9F,EAAOM,GAC3B,OAAO2F,EAAad,EAAK7E,EAAKN,MAEzBmF,EAWT,SAASe,EAAOC,GACd,IAAIxB,EAAMtE,EAAO,MAAO,IAExB,OADAsE,EAAIyB,UAAYD,EACTxB,EAAI0B,WASb,SAASpB,EAAWqB,GAClB/C,EAAQ+C,GAAMC,SAAQ,SAAUpB,GAC9B,GAAIA,EAAK,CACP,IAAIK,EAASL,EAAIqB,cACjBhB,GAAUA,EAAOiB,YAAYtB,OAYnC,SAASJ,EAAOS,EAAQD,GAClBC,GACFA,EAAOkB,YAAYnB,GAWvB,SAASoB,EAAOxB,EAAKyB,GACnB,GAAIzB,GAAOyB,EAAK,CACd,IAAIpB,EAASoB,EAAIJ,cACjBhB,GAAUA,EAAOqB,aAAa1B,EAAKyB,IAWvC,SAAShC,EAAWO,EAAK2B,GACnB3B,GACFxC,EAAKmE,GAAQ,SAAU9G,EAAO+G,GACd,OAAV/G,IACFmF,EAAI6B,MAAMD,GAAQ/G,MAe1B,SAASiH,EAAmB9B,EAAK+B,EAASC,GACpChC,GACF5B,EAAQ2D,GAASX,SAAQ,SAAUjH,GAC7BA,GACF6F,EAAIiC,UAAUD,EAAS,SAAW,OAAO7H,MAajD,SAAS+H,EAASlC,EAAK+B,GACrBD,EAAmB9B,EAAK+B,GAAS,GAUnC,SAASI,EAAYnC,EAAK+B,GACxBD,EAAmB9B,EAAK+B,GAAS,GAYnC,SAASvB,EAASR,EAAKoC,GACrB,QAASpC,GAAOA,EAAIiC,UAAUI,SAASD,GAWzC,SAAStB,EAAad,EAAK7F,EAAMU,GAC3BmF,GACFA,EAAIc,aAAa3G,EAAMU,GAa3B,SAASyH,EAAatC,EAAK7F,GACzB,OAAO6F,EAAMA,EAAIsC,aAAanI,GAAQ,GAUxC,SAASoI,EAAgBpB,EAAMqB,GAC7BpE,EAAQoE,GAAOpB,SAAQ,SAAUjH,GAC/BiE,EAAQ+C,GAAMC,SAAQ,SAAUpB,GAC9B,OAAOA,GAAOA,EAAIuC,gBAAgBpI,SAaxC,SAASsI,EAAQzC,GACf,OAAOA,EAAI0C,wBA4Cb,IAAIC,EAAQ,QAORC,EAAO,OAOPC,EAAO,OAqBPC,EAAQ,SAAeC,EAAQC,GAMjC,IAAIC,EAOAC,EACJ,MAAO,CAILC,MAAO,WACLF,EAAOD,EAAWI,SAASH,KAC3BF,EAAOM,GAAG,iBAAiB,SAAUC,GAC/BA,EAAE1G,SAAWqG,GAAQC,GACvBA,MAEDD,IAYLM,MAAO,SAAeC,EAAWC,EAAUC,EAAWC,EAAOC,GAC3D,IAAIC,EAAUd,EAAOc,QACjBC,EAAYd,EAAWe,WAAWD,UAClCE,EAAQH,EAAQG,MACpBd,EAAcU,EAEVb,EAAOkB,GAAGtB,KACM,IAAde,GAAmBD,GAAYK,GAAaJ,GAAaI,GAA0B,IAAbL,KACxEO,EAAQH,EAAQK,aAAeF,GAInCvE,EAAWwD,EAAM,CACfkB,WAAY,aAAeH,EAAQ,MAAQH,EAAQO,OACnDC,UAAW,aAAeV,EAAMW,EAAI,MAAQX,EAAMY,EAAI,WA0B1DC,EAAO,SAAczB,EAAQC,GAuC/B,SAAShG,EAAMW,GACb,IAAIkG,EAAUd,EAAOc,QACrBpE,EAAWuD,EAAWI,SAASqB,OAAO9G,GAAQ,CAC5CwG,WAAY,WAAaN,EAAQG,MAAQ,MAAQH,EAAQO,SAI7D,MA7CW,CAKTjB,MAAO,WACLnG,EAAM+F,EAAOpF,QAYf4F,MAAO,SAAeC,EAAWC,EAAUC,EAAWC,EAAOC,GAC3D,IAAIc,EAAQ1B,EAAWI,SAASsB,MAChCjF,EAAWiF,EAAO,CAChBC,OAAQ1F,EAAKyF,EAAME,gBAErB5H,EAAMyG,GACNoB,YAAW,WACTjB,IACAnE,EAAWiF,EAAO,CAChBC,OAAQ,WAqFlB,SAASG,EAAMC,GACbC,QAAQF,MAAMG,YAAuBF,GAYvC,SAASG,EAAMnH,EAASgH,GACtB,IAAKhH,EACH,MAAM,IAAIoH,MAAMJ,GAmBpB,IAAIK,EAAO,SAoCPC,EAAiB,CACnBC,OAAQ,YACRC,QAAS,aACTC,QAAS,cAoCPC,EAAW,CASbvG,KAAM,QAQNwG,QAAQ,EAOR1B,MAAO,IAOPE,YAAa,EASbyB,mBAAmB,EAOnBhG,MAAO,EAOPgF,OAAQ,EAQRiB,WAAY,EAQZC,YAAa,EAQbC,YAAa,EAQbC,WAAW,EAQXC,YAAY,EAOZC,QAAS,EAOTC,QAAS,EAQTC,OAAQ,EAOR5C,MAAO,EAQP6C,OAAO,EAOPC,IAAK,EAgBLC,QAAS,EAOTC,QAAQ,EAORC,UAAW,GAOXC,YAAY,EAOZC,UAAU,EAOVC,SAAU,IAOVC,cAAc,EAQdC,cAAc,EAOdC,eAAe,EAYfC,UAAU,EAQVC,aAAc,EAOd5C,OAAQ,gCAUR6C,SAAU,SAOVC,MAAM,EAQNC,mBAAoB,GAQpBC,uBAAwB,IAQxBC,uBAAwB,GAQxBC,WAAY,IAOZC,cAAe,EAUfC,UAAW,MASXC,OAAO,EAOPC,eAAe,EAOfC,YAAY,EAQZC,cAAc,EAOdC,WAAW,EAQXC,cAAc,EAOdC,SAAU,IAOVC,SAAS,EAmBTC,aAAa,EASblG,QA3coB,CACpBxC,KAAM6F,EACN8C,OAAQ9C,EAAO,WACfV,MAAOU,EAAO,UACdnC,KAAMmC,EAAO,SACbtC,MAAOsC,EAAO,UACd+C,UAAW/C,EAAO,qBAClBmB,OAAQnB,EAAO,WACfgD,MAAOhD,EAAO,UACdiD,KAAMjD,EAAO,gBACbkD,KAAMlD,EAAO,gBACbqB,WAAYrB,EAAO,eACnBmD,KAAMnD,EAAO,qBACboD,MAAOpD,EAAO,iBACdqD,SAAUrD,EAAO,aACjBsD,IAAKtD,EAAO,kBACZsB,SAAUtB,EAAO,aACjBuD,KAAMvD,EAAO,SACbwD,MAAOxD,EAAO,UACdyD,QAASzD,EAAO,YAChB0D,GAAI1D,EAAO,QAgcX2D,KApaS,CACTV,KAAM,iBACNC,KAAM,aACNU,MAAO,oBACPC,KAAM,mBACNC,OAAQ,iBACRC,MAAO,gBACPR,KAAM,iBACNC,MAAO,mBA6aL1L,EAAW,EAOXG,EAAW,EAOXD,EAAQ,EAORE,EAAU,EAOVH,EAAa,EAGjB,SAASiM,EAAkBxM,EAAQyM,GACjC,IAAK,IAAIzP,EAAI,EAAGA,EAAIyP,EAAMvM,OAAQlD,IAAK,CACrC,IAAI0P,EAAaD,EAAMzP,GACvB0P,EAAW9O,WAAa8O,EAAW9O,aAAc,EACjD8O,EAAWC,cAAe,EACtB,UAAWD,IAAYA,EAAWE,UAAW,GACjDlP,OAAOC,eAAeqC,EAAQ0M,EAAWnO,IAAKmO,IAsBlD,IAAIvG,EAAsB,WAUxB,SAASA,EAAOxD,EAAMsE,EAASb,GAp1CrB,IAMNyG,OA+0Cc,IAAZ5F,IACFA,EAAU,SAGO,IAAfb,IACFA,EAAa,IAGf/F,KAAKsC,KAAOA,aAAgBmK,QAAUnK,EAAOqB,SAASV,cAAcX,GACpE2F,EAAMjI,KAAKsC,KAAM,0CACjBtC,KAAK+F,WAAa,KAClB/F,KAAK0M,MA19CQ,WAMf,IAAIC,EAAO,GA0FX,SAASC,EAAYC,GACfA,EAAK9J,KACP8J,EAAK9J,IAAI+J,oBAAoBD,EAAKE,MAAOF,EAAKG,QAASH,EAAKjG,SAIhE,MA/FY,CAUVR,GAAI,SAAY6G,EAAQD,EAASjK,EAAK6D,QACxB,IAAR7D,IACFA,EAAM,WAGQ,IAAZ6D,IACFA,EAAU,IAGZqG,EAAO/J,MAAM,KAAKiB,SAAQ,SAAU4I,GAC9BhK,GACFA,EAAImK,iBAAiBH,EAAOC,EAASpG,GAGvC+F,EAAKQ,KAAK,CACRJ,MAAOA,EACPC,QAASA,EACTjK,IAAKA,EACL6D,QAASA,QAWfwG,IAAK,SAAaH,EAAQlK,QACZ,IAARA,IACFA,EAAM,MAGRkK,EAAO/J,MAAM,KAAKiB,SAAQ,SAAU4I,GAClCJ,EAAOA,EAAKrJ,QAAO,SAAUuJ,GAC3B,OAAIA,GAAQA,EAAKE,QAAUA,GAASF,EAAK9J,MAAQA,IAC/C6J,EAAYC,IACL,UAefQ,KAAM,SAAcN,GAClB,IAAK,IAAIO,EAAO1N,UAAUC,OAAQ0N,EAAO,IAAInM,MAAMkM,EAAO,EAAIA,EAAO,EAAI,GAAIE,EAAO,EAAGA,EAAOF,EAAME,IAClGD,EAAKC,EAAO,GAAK5N,UAAU4N,GAG7Bb,EAAKxI,SAAQ,SAAU0I,GAChBA,EAAK9J,KAAO8J,EAAKE,MAAM7J,MAAM,KAAK,KAAO6J,GAC5CF,EAAKG,QAAQjN,MAAM8M,EAAMU,OAQ/BxC,QAAS,WACP4B,EAAKxI,QAAQyI,GACbD,EAAO,KAm4CIc,GACbzN,KAAK0N,OA31CHlB,EA21CiBvM,EA11Cd,CAML0N,IAAK,SAAaC,GAChBpB,EAAOoB,GAUT5G,GAAI,SAAY4G,GACd,OAAOA,IAAUpB,KAy0CnBxM,KAAK6N,OAASrO,EACdQ,KAAK8N,GAAK/M,EAAMyH,EAAU5B,GAC1B5G,KAAK+N,GAAK,EACV/N,KAAKgO,GAAKjI,EACV/F,KAAKiO,GAAK,GAEVjO,KAAKkO,GAAK,KAYZ,IA5DoBC,EAAaC,EAAYC,EA4DzCC,EAASxI,EAAOvH,UA4TpB,OA1TA+P,EAAOpI,MAAQ,SAAeqI,EAAYC,GACxC,IAAIC,EAAQzO,UAEO,IAAfuO,IACFA,EAAavO,KAAKiO,SAGD,IAAfO,IACFA,EAAaxO,KAAKkO,IAIpBlO,KAAK0N,MAAMC,IAAI1N,GACfD,KAAKiO,GAAKM,EACVvO,KAAKkO,GAAKM,EACVxO,KAAK+F,WAzqBT,SAAiBD,EAAQC,EAAYyI,GACnC,IAAIE,EAAa,GAUjB,OATAnO,EAAKwF,GAAY,SAAU4I,EAAWzR,GACpCwR,EAAWxR,GAAQyR,EAAU7I,EAAQ4I,EAAYxR,EAAK0R,kBAGnDJ,IACHA,EAAa1I,EAAOkB,GAAGpB,GAAQ2B,EAAO1B,GAGxC6I,EAAWF,WAAaA,EAAW1I,EAAQ4I,GACpCA,EA8pBaG,CAAQ7O,KAAMe,EAAMf,KAAKgO,GAAIO,GAAaC,GAE5D,IACEjO,EAAKP,KAAK+F,YAAY,SAAU+I,EAAW5Q,GACzC,IAAI6Q,EAAWD,EAAUC,cAERC,IAAbD,GAA0BA,EAC5BD,EAAU5I,OAAS4I,EAAU5I,eAEtBuI,EAAM1I,WAAW7H,MAG5B,MAAOmI,GAEP,YADAwB,EAAMxB,EAAEyB,SAIV,IAAI4F,EAAQ1N,KAAK0N,MAgBjB,OAfAA,EAAMC,IAAIvN,GACVG,EAAKP,KAAK+F,YAAY,SAAU+I,GAC9BA,EAAUG,SAAWH,EAAUG,aAEjCjP,KAAKqN,KAAK,WACVK,EAAMC,IAAIxN,GACVH,KAAKqN,KAAK,SACV7K,EAAWxC,KAAKsC,KAAM,CACpB4M,WAAY,YAEdlP,KAAKoG,GAAG,aAAa,WACnB,OAAOsH,EAAMC,IAAItN,MAChB+F,GAAG,iBAAiB,WACrB,OAAOsH,EAAMC,IAAIxN,MAEZH,MAWTsO,EAAOa,KAAO,SAAcC,GAE1B,OADApP,KAAKqP,QAAUD,EACRpP,MAeTsO,EAAOlI,GAAK,SAAY6G,EAAQD,EAASjK,EAAK6D,GAU5C,YATY,IAAR7D,IACFA,EAAM,WAGQ,IAAZ6D,IACFA,EAAU,IAGZ5G,KAAK0M,MAAMtG,GAAG6G,EAAQD,EAASjK,EAAK6D,GAC7B5G,MAYTsO,EAAOlB,IAAM,SAAaH,EAAQlK,GAMhC,YALY,IAARA,IACFA,EAAM,MAGR/C,KAAK0M,MAAMU,IAAIH,EAAQlK,GAChB/C,MAUTsO,EAAOjB,KAAO,SAAcN,GAG1B,IAFA,IAAIuC,EAEKhC,EAAO1N,UAAUC,OAAQ0N,EAAO,IAAInM,MAAMkM,EAAO,EAAIA,EAAO,EAAI,GAAIE,EAAO,EAAGA,EAAOF,EAAME,IAClGD,EAAKC,EAAO,GAAK5N,UAAU4N,GAK7B,OAFC8B,EAActP,KAAK0M,OAAOW,KAAKtN,MAAMuP,EAAa,CAACvC,GAAOwC,OAAOhC,IAE3DvN,MAUTsO,EAAOkB,GAAK,SAAYC,EAASC,GAS/B,YARa,IAATA,IACFA,EAAO1P,KAAK4G,QAAQ8B,oBAGlB1I,KAAK0N,MAAM1G,GAAG7G,IAAUH,KAAK0N,MAAM1G,GAAG3G,KAAaqP,IACrD1P,KAAK+F,WAAWe,WAAW0I,GAAGC,GAAS,GAGlCzP,MAWTsO,EAAOtH,GAAK,SAAY/E,GACtB,OAAOA,IAASjC,KAAK8N,GAAG7L,MAU1BqM,EAAOqB,IAAM,SAAa9J,EAAOnF,GAM/B,YALc,IAAVA,IACFA,GAAS,GAGXV,KAAK+F,WAAWI,SAASwJ,IAAI9J,EAAOnF,EAAOV,KAAK4P,QAAQzR,KAAK6B,OACtDA,MASTsO,EAAOvJ,OAAS,SAAgBrE,GAG9B,OAFAV,KAAK+F,WAAWI,SAASpB,OAAOrE,GAChCV,KAAK4P,UACE5P,MAOTsO,EAAOsB,QAAU,WAEf,OADA5P,KAAKqN,KAAK,kBAAkBA,KAAK,WAAWA,KAAK,UAC1CrN,MAUTsO,EAAOvD,QAAU,SAAiB8E,GAChC,IAAIC,EAAS9P,KAOb,QALmB,IAAf6P,IACFA,GAAa,IAIX7P,KAAK0N,MAAM1G,GAAG/G,GAclB,OAPAU,EAAOX,KAAK+F,YAAYgK,UAAU5L,SAAQ,SAAU2K,GAClDA,EAAU/D,SAAW+D,EAAU/D,QAAQ8E,MAEzC7P,KAAKqN,KAAK,UAAWwC,GAErB7P,KAAK0M,MAAM3B,UACX/K,KAAK0N,MAAMC,IAAIzN,GACRF,KAbLA,KAAKoG,GAAG,SAAS,WACf,OAAO0J,EAAO/E,QAAQ8E,OAjRR1B,EAsSPrI,GAtSoBsI,EAsSZ,CAAC,CACpBlQ,IAAK,QACLV,IAAK,WACH,OAAOwC,KAAK+N,IAQdJ,IAAK,SAAajN,GAChBV,KAAK+N,GAAKiC,SAAStP,KASpB,CACDxC,IAAK,SACLV,IAAK,WACH,OAAOwC,KAAK+F,WAAWI,SAAStG,SAQjC,CACD3B,IAAK,UACLV,IAAK,WACH,OAAOwC,KAAK8N,IAQdH,IAAK,SAAa/G,GAChB,IAAIqJ,EAAUjQ,KAAK0N,MAAM1G,GAAG/G,GAEvBgQ,GACHjQ,KAAKqN,KAAK,UAGZrN,KAAK8N,GAAK/M,EAAMf,KAAK8N,GAAIlH,GAEpBqJ,GACHjQ,KAAKqN,KAAK,UAAWrN,KAAK8N,MAU7B,CACD5P,IAAK,UACLV,IAAK,WACH,OAAOwC,KAAK8N,GAAGhJ,UAShB,CACD5G,IAAK,OACLV,IAAK,WACH,OAAOwC,KAAK8N,GAAGhC,UAnXHK,EAAkBgC,EAAY5P,UAAW6P,GACrDC,GAAalC,EAAkBgC,EAAaE,GAsXzCvI,EAtWiB,GA4XtBc,EAAU,SAAiBd,GAO7B,IAAIc,EAAUvB,EAAaS,EAAOxD,KAAM,eAExC,GAAIsE,EACF,IACEd,EAAOc,QAAUsJ,KAAKC,MAAMvJ,GAC5B,MAAOP,GACPwB,EAAMxB,EAAEyB,SAIZ,MAAO,CAIL5B,MAAO,WACDJ,EAAO4H,MAAM1G,GAAG/G,KAClB6F,EAAOpF,MAAQoF,EAAOc,QAAQN,UA4BlC8J,EAAM,MAONC,EAAM,MAgBNC,GAAuB,eA6OvBC,GAAsB,SAA6BzK,EAAQC,GAM7D,IAAIzD,EAAOwD,EAAOxD,KAOdwC,EAAUgB,EAAOhB,QAOjB0L,EAAS,GAMb,IAAKlO,EAAKmO,GAAI,CACZC,OAAOtB,OAASsB,OAAOtB,QAAU,GACjC,IAAIuB,EAAMD,OAAOtB,OAAe,KAAK,EACrCsB,OAAOtB,OAAe,MAAMuB,EAC5BrO,EAAKmO,GAAK,SAAWtO,EAAIwO,GAS3B,IAAIxK,EAAW,CAKbD,MAAO,WACL,IAAIuI,EAAQzO,KAEZA,KAAK4Q,OACL9K,EAAOM,GAAG,WAAW,WACnBqI,EAAM1D,UAEN0D,EAAMmC,UACLxK,GAAG,WAAW,WACflB,EAAY5C,EAAMuO,KAClB5L,EAAS3C,EAAMuO,SAOnB9F,QAAS,WACPyF,EAAOrM,SAAQ,SAAU2M,GACvBA,EAAM/F,aAERyF,EAAS,GACTtL,EAAY5C,EAAMuO,MAMpBD,KAAM,WACJ,IAAId,EAAS9P,MA4IjB,WACEmG,EAAS8E,OAAS9H,EAAMb,EAAMwC,EAAQmG,QACtC9E,EAASsB,MAAQ3E,EAAKR,EAAM,IAAMwC,EAAQ2C,OAC1CtB,EAASH,KAAO7C,EAAMgD,EAASsB,MAAO3C,EAAQkB,MAC9CiC,EAAM9B,EAASsB,OAAStB,EAASH,KAAM,gCACvCG,EAASqB,OAAS1I,EAASqH,EAASH,KAAMlB,EAAQe,OAClD,IAAIyD,EAASyH,EAAUjM,EAAQwE,QAC/BnD,EAASmD,OAAS,CAChB8B,KAAMtI,EAAKwG,EAAQ,IAAMxE,EAAQsG,MACjCC,KAAMvI,EAAKwG,EAAQ,IAAMxE,EAAQuG,OAEnC,IAAI5B,EAAWsH,EAAUjM,EAAQ2E,UACjCtD,EAASsF,IAAM3I,EAAKiO,EAAUjM,EAAQ0G,UAAW,IAAM1G,EAAQ2G,KAC/DtF,EAASuF,KAAO5I,EAAK2G,EAAU,IAAM3E,EAAQ4G,MAC7CvF,EAASwF,MAAQ7I,EAAK2G,EAAU,IAAM3E,EAAQ6G,OAC9CxF,EAASsB,MAAMgJ,GAAKtK,EAASsB,MAAMgJ,IAAMnO,EAAKmO,GAAK,SACnDtK,EAASH,KAAKyK,GAAKtK,EAASH,KAAKyK,IAAMnO,EAAKmO,GAAK,QA1J/CO,GACA/L,EAAS3C,EAAMuO,KACf7Q,KAAKwH,OAAOrD,SAAQ,SAAU0B,EAAOnF,GACnCoP,EAAOmB,SAASpL,EAAOnF,GAAQ,OAWnCuQ,SAAU,SAAkBpL,EAAOnF,EAAOwQ,GACxC,IAAIC,EAzTW,SAAwBrL,EAAQpF,EAAOwQ,EAAWrL,GAMrE,IAAIgF,EAAe/E,EAAOc,QAAQiE,aAQ9BuG,EAAuB,uDAAyDvG,EAAe,cAAgB,IAO/GiG,EAAQ,CAMVjL,MAAOA,EAOPnF,MAAOA,EAOPwQ,UAAWA,EAOXhG,UAAW/H,EAAM0C,EAAOC,EAAOhB,QAAQoG,WAOvCmG,QAASH,GAAa,EAKtBhL,MAAO,WACL,IAAIuI,EAAQzO,KAEPA,KAAKqR,UACRxL,EAAM4K,GAAK3K,EAAOxD,KAAKmO,GAAK,SAAWtO,EAAIzB,EAAQ,IAGrDoF,EAAOM,GAAGgL,GAAsB,WAC9B,OAAO3C,EAAM6C,YACZlL,GAAGkK,GAAsBiB,GAAenL,GAAG,SAAS,WACrD,OAAON,EAAOuH,KAAK,QAASoB,KAC3B5I,GAMCgF,GACF/E,EAAOM,GAAG,cAAc,SAAUI,GAC5BA,IAAa0K,GACfM,GAAQ,GAAM,MAMpBhP,EAAWqD,EAAO,CAChB4L,QAAS,KAGXzR,KAAK0E,OAASW,EAAaQ,EAAO,UAAY,IAMhDkF,QAAS,WACPjF,EAAOsH,IAAIgE,GAAsBhE,IAAIkD,IAAsBlD,IAAI,QAASvH,GACxEX,EAAYW,EAAOlF,EAAOyH,IAC1BmJ,IACAjM,EAAgBtF,KAAKkL,UAAW,UAMlCoG,OAAQ,WACNE,EAAQxR,KAAK0R,YAAY,GAEzBF,EAAQxR,KAAK2R,aAAa,IAQ5BD,SAAU,WACR,OAAO5L,EAAOpF,QAAUA,GAQ1BiR,UAAW,WACT,IAAItJ,EAASrI,KAAK0R,WAElB,GAAI5L,EAAOkB,GAAGpB,IAASyC,EACrB,OAAOA,EAGT,IAAIuJ,EAAOnQ,KAAKmQ,KACZC,EAAYrM,EAAQM,EAAOC,WAAWI,SAASsB,OAC/CqK,EAAYtM,EAAQK,GAExB,OAAIC,EAAOc,QAAQ2D,YAAc8F,EACxBwB,EAAUE,KAAOD,EAAUC,KAAOD,EAAUE,QAAUJ,EAAKC,EAAUG,QAGvEH,EAAUI,MAAQH,EAAUG,MAAQH,EAAUI,OAASN,EAAKC,EAAUK,QAY/EC,SAAU,SAAkBlR,EAAMmR,GAChC,IAAIC,EAAO5Q,KAAK6Q,IAAIrR,EAAOP,GAM3B,OAJKoF,EAAOkB,GAAGtB,IAAW1F,KAAKqR,UAC7BgB,EAAO5Q,KAAKC,IAAI2Q,EAAMvM,EAAOjG,OAASwS,IAGjCA,EAAOD,IAUlB,SAASZ,EAAQnJ,EAAQkK,GACvB,IAAItQ,EAAOsQ,EAAgB,UAAY,SACnCpN,EAAYiD,EAAenG,GAE3BoG,GACFpD,EAASY,EAAOV,GAChBW,EAAOuH,KAAK,GAAKpL,EAAM6O,IAEnBvN,EAASsC,EAAOV,KAClBD,EAAYW,EAAOV,GACnBW,EAAOuH,KAAWkF,EAAgB,SAAW,WAAazB,IAShE,SAASS,IACP1N,EAAagC,EAAO,QAASiL,EAAMpM,QAGrC,OAAOoM,EAwHe0B,CAAe1M,EAAQpF,EAAOwQ,EAAWrL,GAC3DsL,EAAYjL,QACZsK,EAAOrD,KAAKgE,IASdsB,SAAU,SAAkB/R,GAC1B,OAAO8P,EAAOlN,QAAO,SAAUwN,GAC7B,OAAOA,EAAMpQ,QAAUA,KACtB,IAULgS,UAAW,SAAmBC,GAC5B,OAAOA,EAAgBnC,EAASA,EAAOlN,QAAO,SAAUwN,GACtD,OAAQA,EAAMO,YAWlBuB,gBAAiB,SAAyBtH,GACxC,IAAIuH,EAAM9M,EAAWe,WAAWgM,QAAQxH,GACpC1E,EAAUd,EAAOc,QACjBjF,GAAwB,IAAlBiF,EAAQuC,MAAkB,EAAIvC,EAAQoC,QAChD,OAAOwH,EAAOlN,QAAO,SAAUtC,GAC7B,IAAIN,EAAQM,EAAKN,MACjB,OAAOmS,GAAOnS,GAASA,EAAQmS,EAAMlR,MAYzCgO,IAAK,SAAa9J,EAAOnF,EAAOF,GAK9B,GAJqB,kBAAVqF,IACTA,EAAQ/B,EAAO+B,IAGbA,aAAiB4G,QAAS,CAC5B,IAAIjI,EAAMxE,KAAKwH,OAAO9G,GAEtB8B,EAAWqD,EAAO,CAChB4L,QAAS,SAGPjN,GACFD,EAAOsB,EAAOrB,GACdxE,KAAKwH,OAAOuL,OAAOrS,EAAO,EAAGmF,KAE7BlD,EAAO3C,KAAKgG,KAAMH,GAClB7F,KAAKwH,OAAO2F,KAAKtH,IAjqD3B,SAAgB9C,EAAKvC,GACnB,IAAIwS,EAASjQ,EAAIkQ,iBAAiB,OAC9BpT,EAASmT,EAAOnT,OAEpB,GAAIA,EAAQ,CACV,IAAIqT,EAAQ,EACZ3S,EAAKyS,GAAQ,SAAUG,GACrBA,EAAIC,OAASD,EAAIE,QAAU,aACnBH,IAAUrT,GACdW,aAMNA,IAqpDI8S,CAAOzN,GAAO,WACZrF,GAAYA,EAASqF,QAW3Bd,OAAQ,SAAgBrE,GACtBmC,EAAW7C,KAAKwH,OAAOuL,OAAOrS,EAAO,GAAG,KAQ1CH,KAAM,SAAcC,GAClBgQ,EAAOrM,QAAQ3D,IAQjB,aACE,OAAOR,KAAKwH,OAAO3H,QAQrB,YACE,OAAO2Q,EAAO3Q,SA+BlB,SAASgR,IACP,IAAI0C,EAAYzO,EAAQxC,KACpBsE,EAAUd,EAAOc,QACrB,MAAO,CAAC2M,EAAY,KAAO3M,EAAQ3E,KAAMsR,EAAY,KAAO3M,EAAQ2D,UAAW3D,EAAQqD,KAAOsJ,EAAY,cAAgB,GAAI3M,EAAQ+D,aAAe4I,EAAY,QAAU,GAAInL,EAAeC,QAShM,SAAS0I,EAAU5L,GACjB,OAAOhC,EAAMb,EAAM6C,IAAchC,EAAMgD,EAAS8E,OAAQ9F,GAG1D,OAAOgB,GAYLqN,GAAQ/R,KAAK+R,MAYbC,GAAa,SAAoB3N,EAAQC,GAM3C,IAAIa,EAOA8M,EAOA5M,EAAa,CAIfZ,MAAO,WACLU,EAAUd,EAAOc,QACjB8M,EAAS5N,EAAOkB,GAAGrB,GA4NrBG,EAAOM,GAAG,QAAQ,SAAUI,GAC1BV,EAAOpF,MAAQ8F,KACdJ,GAAG,mBAAmB,SAAUuN,GACjC/M,EAAU+M,GAAc/M,EACxBd,EAAOpF,MAAQY,EAAQwE,EAAOpF,MAAO,EAAGoG,EAAWD,eAhNrD2I,GAAI,SAAYC,EAASmE,GACvB,IAAIrN,EAAYvG,KAAK6T,KAAK7T,KAAKmQ,MAAMV,IACrC1J,EAAW+N,MAAMtE,GAAGjJ,EAAWvG,KAAKyI,OAAOlC,GAAYqN,IAUzDzD,MAAO,SAAeV,GACpB,IAAI/O,EAAQoF,EAAOpF,MACfqT,EAAUC,OAAOvE,GAASwE,MAAM,oBAChCC,EAAYH,EAAUA,EAAQ,GAAK,GACnC3R,EAAS2R,EAAU/D,SAAS+D,EAAQ,IAAM,EAE9C,OAAQG,GACN,IAAK,IACHxT,GAAS0B,GAAU,EACnB,MAEF,IAAK,IACH1B,GAAS0B,GAAU,EACnB,MAEF,IAAK,IACL,IAAK,IACH1B,EA2MR,SAAmB0B,EAAQ1B,EAAO0K,GAChC,GAAIhJ,GAAU,EACZ,OAAO0E,EAAWgM,QAAQ1Q,GAG5B,IAAI6G,EAAUrC,EAAQqC,QAClBkL,EAAO/I,GAAQ,EAAI,EAEvB,OAAInC,EACKvI,EAAQuI,EAAUkL,EAGpBrN,EAAWgM,QAAQhM,EAAWsN,OAAO1T,GAASyT,GAvNvCE,CAAUjS,EAAQ1B,EAAqB,MAAdwT,GACjC,MAEF,QACExT,EAAQsP,SAASP,GAGrB,OAAO/O,GAUToS,QAAS,SAAiBxH,GACxB,GAAIgJ,IACF,OAAOhJ,EAGT,IAAIzL,EAASiG,EAAOjG,OAChBmJ,EAAUpC,EAAQoC,QAClBtI,EAAQ4K,EAAOtC,EAOnB,OAJInJ,EAASmJ,IAFbtI,IAAiBV,KAAKuU,WAAavL,EAAUnJ,GAAU2T,GAAM9S,EAAQb,KAEpCa,EAAQb,IACvCa,EAAQb,EAASmJ,GAGZtI,GAUT0T,OAAQ,SAAgB1T,GACtB,GAAI4T,IACF,OAAO5T,EAGT,IAAIb,EAASiG,EAAOjG,OAChBmJ,EAAUpC,EAAQoC,QAEtB,OACSwK,GADL3T,EAASmJ,GAAWtI,GAASA,EAAQb,GACzBA,EAAS,GAAKmJ,EAGjBtI,EAAQsI,IAWvB6K,KAAM,SAAcnT,GAKlB,OAJKgT,IACHhT,EAAQkG,EAAQ6B,OAASzI,KAAKyI,OAAO/H,GAASY,EAAQZ,EAAO,EAAGV,KAAK6G,YAGhEnG,GAUT+H,OAAQ,SAAgB/H,GACtB,IAAI8T,EAAOxU,KAAK6G,UAEhB,GAAI6M,EAAQ,CACV,KAAOhT,EAAQ8T,GACb9T,GAAS8T,EAAO,EAGlB,KAAO9T,EAAQ,GACbA,GAAS8T,EAAO,OAGd9T,EAAQ8T,EACV9T,EAAQ,EACCA,EAAQ,IACjBA,EAAQ8T,GAIZ,OAAO9T,GAQT+T,MAAO,WACL,OAAO7N,EAAQ2D,YAAc6F,GAQ/B,iBACE,IAAIvQ,EAASiG,EAAOjG,OACpB,OAAOyU,IAAazU,EAAS4B,KAAKmQ,KAAK/R,EAAS+G,EAAQoC,UAQ1D,gBACE,IAAInJ,EAASiG,EAAOjG,OAEpB,OAAKA,EAIDyU,KAAc1N,EAAQ+D,cAAgB+I,EACjC7T,EAAS,EAGXA,EAAS+G,EAAQoC,QAPf,GAeX,gBACE,IAAIoC,EAAOtF,EAAOpF,MAAQ,EAM1B,OAJIgT,GAAU9M,EAAQ6B,UACpB2C,EAAOpL,KAAKyI,OAAO2C,IAGdA,GAAQ,EAAIA,GAAQ,GAQ7B,gBACE,IAAIC,EAAOvF,EAAOpF,MAAQ,EAM1B,OAJIgT,GAAU9M,EAAQ6B,UACpB4C,EAAOrL,KAAKyI,OAAO4C,IAGdvF,EAAOpF,MAAQ2K,GAAQA,GAAQrL,KAAK6G,WAAsB,IAATwE,EAAaA,GAAQ,IAuBjF,SAASiJ,IACP,OAAyB,IAAlB1N,EAAQuC,MA4BjB,OAAOrC,GAYLwL,GAAM7Q,KAAK6Q,IAYX7K,GAAQ,SAAe3B,EAAQC,GAMjC,IAAI2O,EAOAvO,EAOAH,EAOA2O,EAAa7O,EAAOc,QAAQ2D,YAAc8F,EAO1CuE,EAAS9O,EAAOkB,GAAGpB,GAOnBiP,EAAQ/O,EAAOc,QAAQ2D,YAAc6F,EAOrC0E,GAAgB,EAOhBX,EAAOU,EAAQ,GAAK,EAOpBf,EAAQ,CAMVK,KAAMA,EAKNjO,MAAO,WACLC,EAAWJ,EAAWI,SACtBuO,EAAS3O,EAAW2O,OACpB1O,EAAOG,EAASH,MAOlBiJ,QAAS,WACP,IAAIR,EAAQzO,KAEP4U,IACH5U,KAAK+U,KAAK,GACVjP,EAAOM,GAAG,0BAA0B,WAClCqI,EAAMsG,KAAKjP,EAAOpF,YAcxB8O,GAAI,SAAYjJ,EAAWC,EAAUoN,GACnC,IAAIoB,EAAcC,EAAmB1O,GACjCE,EAAYX,EAAOpF,MAEnBoF,EAAO4H,MAAM1G,GAAG3G,IAAYyU,IAIhCA,EAAgBvO,IAAcC,EAEzBoN,GACH9N,EAAOuH,KAAK,OAAQ7G,EAAUC,EAAWF,GAGvC9E,KAAK6Q,IAAI0C,EAAchV,KAAKyC,WAAa,GAAKmS,EAChD7O,EAAWyI,WAAWlI,MAAMC,EAAWC,EAAUC,EAAWzG,KAAKkV,QAAQF,IAAc,WACrFG,EAAgB5O,EAAWC,EAAUC,EAAWmN,MAG9CrN,IAAcE,GAA0C,SAA7BX,EAAOc,QAAQgE,UAC5C7E,EAAWe,WAAW0I,GAAGjJ,EAAYA,EAAYE,EAAWmN,GAE5DuB,EAAgB5O,EAAWC,EAAUC,EAAWmN,KAUtDmB,KAAM,SAAcrU,GAClBV,KAAKoV,UAAUH,EAAmBvU,KAQpC0U,UAAW,SAAmB3S,GAC5BD,EAAWwD,EAAM,CACfoB,UAAW,aAAeuN,EAAa,IAAM,KAAO,IAAMlS,EAAW,SAQzE4S,OAAQ,WACFvP,EAAOkB,GAAGrB,GACZ3F,KAAKsV,QAGLtV,KAAKoV,UAAUpV,KAAKyC,UAGtBD,EAAWwD,EAAM,CACfkB,WAAY,MAOhBoO,MAAO,WACL,IAAI7S,EAAW6P,GAAItS,KAAKyC,UACpBwP,EAAOK,GAAItS,KAAKuV,WAAW,IAC3BrD,EAAQI,GAAItS,KAAKuV,WAAWzP,EAAOjG,SACnC2V,EAAYtD,EAAQD,EAEpBxP,EAAWwP,EACbxP,GAAY+S,EACH/S,EAAWyP,IACpBzP,GAAY+S,GAGdxV,KAAKoV,UAAUjB,EAAO1R,IAUxBoR,KAAM,SAAcpR,GAClB,OAAKqD,EAAOc,QAAQgE,WAAa9E,EAAOkB,GAAGrB,GAClClD,EAIFnB,EAAQmB,EADJ0R,GAAQO,EAAOe,YAAcf,EAAOgB,KAAOhB,EAAOtL,KAC9B,IAUjC0J,QAAS,SAAiBrQ,GACxB,IAAIqN,EAAS9P,KAETU,EAAQ,EACRiV,EAAcC,IAUlB,OATAzP,EAASuM,WAAU,GAAMvO,SAAQ,SAAU2M,GACzC,IAAI+E,EAAa/E,EAAMpQ,MACnBoV,EAAWxD,GAAIxC,EAAOyF,WAAWM,GAAcpT,GAE/CqT,EAAWH,IACbA,EAAcG,EACdpV,EAAQmV,MAGLnV,GAUTwU,QAAS,SAAiBzS,GACxB,MAAO,CACL4E,EAAGsN,EAAa,EAAIlS,EACpB6E,EAAGqN,EAAalS,EAAW,IAW/B8S,WAAY,SAAoB7U,GAC9B,IAAI+B,EAAWiS,EAAOe,UAAU/U,GAASgU,EAAOqB,UAAUrV,GAASgU,EAAOtL,IAC1E,OAAO+K,GAAQ1R,EAAWzC,KAAKgW,OAAOtV,KAQxCsV,OAAQ,SAAgBtV,GACtB,IAAIyI,EAAQrD,EAAOc,QAAQuC,MACvB4M,EAAYrB,EAAOqB,UAAUrV,GAEjC,MAAc,WAAVyI,IACOuL,EAAOgB,KAAOK,GAAa,IAG7B/F,SAAS7G,IAAU,IAAM4M,EAAYrB,EAAOtL,MASvD,eACE,IAAIzE,EAAOgQ,EAAa,MAAQE,EAAQ,QAAU,OAClD,OAAOrP,EAAQQ,GAAMrB,IAASa,EAAQW,EAASsB,OAAO9C,GAAQ+P,EAAOrL,QAAQ1E,GAAQwP,KAazF,SAASgB,EAAgB5O,EAAWC,EAAUC,EAAWmN,GACvDpR,EAAWwD,EAAM,CACfkB,WAAY,KAEd4N,GAAgB,EAEXF,GACHd,EAAMiB,KAAKvO,GAGRoN,GACH9N,EAAOuH,KAAK,QAAS7G,EAAUC,EAAWF,GAU9C,SAAS0O,EAAmBvU,GAC1B,OAAOoT,EAAMD,KAAKC,EAAMyB,WAAW7U,IAGrC,OAAOoT,GAuBL5K,GAAS,SAAgBpD,EAAQC,GAMnC,IAAImD,EAAS,GAOT+M,EAAa,EAOb9P,EAAWJ,EAAWI,SAOtB+P,EAAS,CAIXhQ,MAAO,WACL,IAAIuI,EAAQzO,KAER8F,EAAOkB,GAAGrB,KACZiL,IACA9K,EAAOM,GAAG,kBAAkB,WAC1BqI,EAAM1D,aACL3E,GAAG,UAAWwK,GAAMxK,GAAG,UAAU,WAC9B6P,IAAeE,MAEjB1H,EAAM1D,UAENjF,EAAO8J,gBASf7E,QAAS,WACPlI,EAAWqG,GACXA,EAAS,IAQX,aACE,OAAOA,GAQT,aACE,OAAOA,EAAOrJ,SAQlB,SAAS+Q,IACPsF,EAAOnL,UAWT,SAAwBmI,GACtB,IAAIrT,EAASsG,EAAStG,OAClBoR,EAAW9K,EAAS8K,SAExB,GAAIpR,EAAQ,CAGV,IAFA,IAAI2H,EAASrB,EAASqB,OAEfA,EAAO3H,OAASqT,GACrB1L,EAASA,EAAO+H,OAAO/H,GAIzBA,EAAO4O,MAAM,EAAGlD,GAAO/O,SAAQ,SAAUpB,EAAKrC,GAC5C,IAAI6K,EAAQ8K,EAAYtT,GACxBJ,EAAOwD,EAASH,KAAMuF,GACtBrC,EAAOiE,KAAK5B,GACZ0F,EAAS1F,EAAO7K,EAAQb,EAAQa,EAAQb,MAG1C2H,EAAO4O,OAAOlD,GAAO/O,SAAQ,SAAUpB,EAAKrC,GAC1C,IAAI6K,EAAQ8K,EAAYtT,GACxBwB,EAAOgH,EAAO/D,EAAO,IACrB0B,EAAOiE,KAAK5B,GACZ0F,EAAS1F,EAAO7K,EAAQwS,GAAQrT,EAASa,EAAQwS,EAAQrT,GAAUA,OAhCvEyW,CADAL,EAAaE,KAiDf,SAASA,IACP,IAAIvP,EAAUd,EAAOc,QAErB,GAAIA,EAAQsC,OACV,OAAOtC,EAAQsC,OAIjB,IAAIqN,EAAY3P,EAAQkC,WAAalC,EAAQmC,WAAa5C,EAAStG,OAAS+G,EAAQoC,QAChFwN,EAAY5P,EAAQ2D,YAAc8F,EAAM,SAAW,QACnDoG,EAAYpU,EAAQyD,EAAOxD,KAAMsE,EAAQ,QAAU4P,IAOvD,OALIC,IAEFF,EAAY9U,KAAKmQ,KAAKzL,EAASsB,MAAM,SAAW+O,GAAaC,IAGxDF,GAAa3P,EAAQqD,KAAOrD,EAAQ0D,cAAgB,EAAI,GAWjE,SAAS+L,EAAYtT,GACnB,IAAIwI,EAAQxI,EAAI2T,WAAU,GAI1B,OAHAzR,EAASsG,EAAOzF,EAAOhB,QAAQyG,OAE/BjG,EAAgBiG,EAAO,MAChBA,EAGT,OAAO2K,GAgVT,SAASpL,GAAS6L,EAAMjH,GACtB,IAAIkH,EAEJ,OAAO,WACAA,IACHA,EAAUhP,YAAW,WACnB+O,IACAC,EAAU,OACTlH,KA0FT,IAAImH,GAAS,SAAgB/Q,EAAQC,GAMnC,IAn3GqB7E,EAAID,EAm3GrBkF,EAAWJ,EAAWI,SAOtBwO,EAAa7O,EAAOc,QAAQ2D,YAAc8F,EAO1CqE,GAj4GiBxT,EAi4GM,CAIzBgF,MAAO,WA8CPJ,EAAOM,GAAG,cAAe0E,IAAS,WAChChF,EAAOuH,KAAK,YACXvH,EAAOc,QAAQkE,UAAW4F,QAAQtK,GAAG,SAAU0Q,GAAQ1Q,GAAG,kBAAmBwK,GA9C9EA,IAEA5Q,KAAKyV,UAAYd,EAAa3U,KAAK+W,YAAc/W,KAAKgX,WACtDhX,KAAK+V,UAAYpB,EAAa3U,KAAKiX,YAAcjX,KAAKkX,YAMxDnM,QAAS,WACPzF,EAAgB,CAACa,EAASH,KAAMG,EAASsB,OAAQ,UAQnD,WACE,OAAOkN,EAAa3U,KAAK0H,OAAS1H,KAAK0C,QA15GlBzB,EA65GtB0T,EA1SU,SAAkB7O,EAAQC,GAMvC,IAcI0B,EAOAb,EArBAT,EAAWJ,EAAWI,SAOtB7D,EAAOwD,EAAOxD,KAelB,MAAO,CAML6U,OAAQ,eAKRvG,KAAM,WACJ5Q,KAAK8W,UAOPA,OAAQ,WACNlQ,EAAUd,EAAOc,QACjBa,EAAQtB,EAASsB,MACjBzH,KAAKoJ,IAAM/G,EAAQC,EAAMsE,EAAQwC,KACjC,IAAIC,EAAUzC,EAAQyC,QAClB0I,EAAM1P,EAAQC,EAAM+G,EAAQ0I,KAAO1I,GACnC2I,EAAS3P,EAAQC,EAAM+G,EAAQ2I,QAAU3I,GAC7CrJ,KAAKqJ,QAAU,CACb0I,IAAKA,EACLC,OAAQA,GAEVxP,EAAWiF,EAAO,CAChB2P,WAAYpV,EAAK+P,GACjBsF,cAAerV,EAAKgQ,MAWxB+E,YAAa,SAAqBrW,QAClB,IAAVA,IACFA,EAAQoF,EAAOjG,OAAS,GAG1B,IAAIiR,EAAQ3K,EAASsM,SAAS/R,GAE9B,OAAIoQ,EACKtL,EAAQsL,EAAMjL,OAAOmM,OAASxM,EAAQW,EAASH,MAAM+L,IAAM/R,KAAKoJ,IAGlE,GAQT8N,WAAY,WACV,OAAO7U,EAAQC,EAAMsE,EAAQ+B,YAAc3I,KAAK0C,QAUlDuU,YAAa,SAAqBvW,GAChC,GAAIkG,EAAQmC,WAAY,CACtB,IAAI+H,EAAQ3K,EAASsM,SAAS/R,GAC9B,OAAOoQ,EAAQA,EAAMjL,MAAMyR,aAAe,EAG5C,IAAI5P,EAASd,EAAQgC,cAAgB5I,KAAK0H,OAAS1H,KAAKoJ,KAAOxC,EAAQoC,QAAUhJ,KAAKoJ,IACtF,OAAO/G,EAAQC,EAAMoF,IAQvB,YACE,OAAOD,EAAM7E,aAQf,aACE,IAAI8E,EAASd,EAAQc,QAAU1H,KAAK0C,MAAQkE,EAAQiC,YAEpD,OADAZ,EAAMP,EAAQ,yCACPrF,EAAQC,EAAMoF,GAAU1H,KAAKqJ,QAAQ0I,IAAM/R,KAAKqJ,QAAQ2I,SA0KnDuF,CAASzR,EAAQC,GA3clB,SAAoBD,EAAQC,GAM3C,IAcI0B,EAdAtB,EAAWJ,EAAWI,SAOtB7D,EAAOwD,EAAOxD,KAcdsE,EAAUd,EAAOc,QACrB,MAAO,CAMLuQ,OAAQ,UAAYvQ,EAAQ2D,YAAc6F,EAAM,OAAS,SAOzD1I,OAAQ,EAKRkJ,KAAM,WACJ5Q,KAAK8W,UAOPA,OAAQ,WACNlQ,EAAUd,EAAOc,QACjBa,EAAQtB,EAASsB,MACjBzH,KAAKoJ,IAAM/G,EAAQC,EAAMsE,EAAQwC,KACjC,IAAIC,EAAUzC,EAAQyC,QAClB4I,EAAO5P,EAAQC,EAAM+G,EAAQ4I,MAAQ5I,GACrC6I,EAAQ7P,EAAQC,EAAM+G,EAAQ6I,OAAS7I,GAC3CrJ,KAAKqJ,QAAU,CACb4I,KAAMA,EACNC,MAAOA,GAET1P,EAAWiF,EAAO,CAChB+P,YAAaxV,EAAKiQ,GAClBwF,aAAczV,EAAKkQ,MAWvB8E,WAAY,SAAoBtW,QAChB,IAAVA,IACFA,EAAQoF,EAAOjG,OAAS,GAG1B,IAAIiR,EAAQ3K,EAASsM,SAAS/R,GAC1BgC,EAAQ,EAEZ,GAAIoO,EAAO,CACT,IAAIgB,EAAYtM,EAAQsL,EAAMjL,OAC1B6R,EAAWlS,EAAQW,EAASH,MAG9BtD,EADEkE,EAAQ2D,YAAc6F,EAChBsH,EAASxF,MAAQJ,EAAUG,KAE3BH,EAAUI,MAAQwF,EAASzF,KAGrCvP,GAAS1C,KAAKoJ,IAGhB,OAAO1G,GAUTwU,WAAY,SAAoBxW,GAC9B,GAAIkG,EAAQkC,UAAW,CACrB,IAAIgI,EAAQ3K,EAASsM,SAAS/R,GAC9B,OAAOoQ,EAAQA,EAAMjL,MAAM8R,YAAc,EAG3C,IAAIjV,EAAQkE,EAAQ+B,aAAe3I,KAAK0C,MAAQ1C,KAAKoJ,KAAOxC,EAAQoC,QAAUhJ,KAAKoJ,IACnF,OAAO/G,EAAQC,EAAMI,IAQvBuU,YAAa,WACX,IAAIvP,EAASd,EAAQc,QAAUd,EAAQgC,aAAe5I,KAAK0C,MAAQkE,EAAQiC,YAC3E,OAAOxG,EAAQC,EAAMoF,IAQvB,YACE,OAAOD,EAAM7E,YAAc5C,KAAKqJ,QAAQ4I,KAAOjS,KAAKqJ,QAAQ6I,QAoUjB0F,CAAW9R,EAAQC,GA55GlEzF,EAAKW,GAAMkD,SAAQ,SAAUjG,GACtBgD,EAAGhD,IACNb,OAAOC,eAAe4D,EAAIhD,EAAKb,OAAOwa,yBAAyB5W,EAAM/C,OAGlEgD,GA45GP,SAAS0P,IACP8D,EAAO9D,OACPpO,EAAWsD,EAAOxD,KAAM,CACtBwV,SAAU9V,EAAK8D,EAAOc,QAAQlE,SAEhCyD,EAAS5F,MAAK,SAAUuQ,GACtBA,EAAMjL,MAAMjB,MAAM8P,EAAOyC,QAAUnV,EAAK0S,EAAOtL,QAEjD0N,IAkBF,SAASA,IACP,IAAIlQ,EAAUd,EAAOc,QACrB8N,EAAOoC,SACPtU,EAAW2D,EAASsB,MAAO,CACzBC,OAAQ1F,EAAK0S,EAAOhN,UAEtB,IAAIuP,EAAcrQ,EAAQmC,WAAa,KAAO/G,EAAK0S,EAAOuC,eAC1D9Q,EAAS5F,MAAK,SAAUuQ,GACtBtO,EAAWsO,EAAM5F,UAAW,CAC1BxD,OAAQuP,IAEVzU,EAAWsO,EAAMjL,MAAO,CACtBnD,MAAOkE,EAAQkC,UAAY,KAAO9G,EAAK0S,EAAOwC,WAAWpG,EAAMpQ,QAC/DgH,OAAQoJ,EAAM5F,UAAY,KAAO+L,OAGrCnR,EAAOuH,KAAK,WAGd,OAAOqH,GAYLqD,GAAWtW,KAAK6Q,IA2BhBrI,GAAO,SAAcnE,EAAQC,GAM/B,IAcIiS,EAOAC,EAOAC,EAOAC,EAnCArE,EAAQ/N,EAAW+N,MAOnBhN,EAAaf,EAAWe,WAmCxB6N,EAAa7O,EAAOc,QAAQ2D,YAAc8F,EAO1C+H,EAAOzD,EAAa,IAAM,IAO1B0D,EAAO,CAMTC,UAAU,EAKVpS,MAAO,WACL,IAAIuI,EAAQzO,KAERmG,EAAWJ,EAAWI,SACtBsB,EAAQtB,EAASsB,MACrB3B,EAAOM,GAAG,uBAAwBE,EAAOmB,GAAOrB,GAAG,sBAAuBmS,EAAM9Q,EAAO,CACrF+Q,SAAS,IACRpS,GAAG,kDAAmDqS,EAAKhR,GAAOrB,GAAG,mBAAmB,WAEzF7F,EAAK4F,EAASH,KAAKiN,iBAAiB,WAAW,SAAUlQ,GACvD+C,EAAOsH,IAAI,YAAarK,GAAKqD,GAAG,aAAa,SAAUC,GACrDA,EAAEqS,mBACD3V,EAAK,CACNyV,SAAS,UAGZpS,GAAG,mBAAmB,WACvBqI,EAAM6J,UAAYxS,EAAOc,QAAQqD,UAUvC,SAAS3D,EAAMD,GACRgS,EAAKC,UAAaH,GAErBvH,EAAKvK,GAUT,SAASuK,EAAKvK,GACZ2R,EAAalE,EAAMoB,QAAQpB,EAAMrR,UACjCwV,EAAYU,EAAQtS,EAAG,IACvB6R,EAAcD,EAShB,SAASM,EAAKlS,GACZ,GAAI4R,EAGF,GAFAC,EAAcS,EAAQtS,EAAG4R,GAErBE,GAKF,GAJI9R,EAAEuS,YACJvS,EAAEqS,kBAGC5S,EAAOkB,GAAGpB,GAAO,CACpB,IAAInD,EAAWuV,EAAWI,GAAQF,EAAYlC,OAAOoC,GACrDtE,EAAMsB,UA8Cd,SAAgB3S,GACd,GAAIqD,EAAOkB,GAAGtB,GAAQ,CACpB,IAAIyO,EAAOL,EAAMK,KAEb0E,EAAS1E,EAAOL,EAAMD,KAAKC,EAAMyB,WAAW,IAE5CuD,EAAO3E,EAAOL,EAAMD,KAAKC,EAAMyB,WAAWzO,EAAWD,aAEzDpE,GAAY0R,GAEG0E,EACbpW,EAAWoW,EA7MI,EA6MwBpX,KAAKsX,IAAIF,EAASpW,GAChDA,EAAWqW,IACpBrW,EAAWqW,EA/MI,EA+MsBrX,KAAKsX,IAAItW,EAAWqW,IAG3DrW,GAAY0R,EAGd,OAAO1R,EAjEeuW,CAAOvW,UAsB/B,SAAoBzB,GAClB,IAAIgV,EAAShV,EAAKgV,OAElB,GAAIlQ,EAAO4H,MAAM1G,GAAG3G,IAAYyF,EAAOc,QAAQ8B,kBAC7C,OAAO,EAGT,IAAIuQ,EAA6D,IAArDxX,KAAKyX,KAAKnB,GAAS/B,EAAO1O,GAAKyQ,GAAS/B,EAAO3O,IAAY5F,KAAK0X,GAM5E,OAJIxE,IACFsE,EAAQ,GAAKA,GAGRA,EAAQnT,EAAOc,QAAQsD,oBAhCtBkP,CAAWlB,KACbpS,EAAOuH,KAAK,OAAQ4K,GACpBE,GAAa,EACbrE,EAAMuB,SAENzE,EAAKvK,IAgEb,SAASoS,IACPR,EAAY,KAERE,IACFrS,EAAOuH,KAAK,UAAW6K,GAY3B,SAAYmB,GACV,IAAIC,EAAWD,EAAKC,SAASlB,GACzBmB,EAAOxB,GAASuB,GAEpB,GAAIC,EAAO,EAAG,CACZ,IAAI3S,EAAUd,EAAOc,QACjBlG,EAAQoF,EAAOpF,MACfyT,EAAOmF,EAAW,GAAK,EAAI,EAC3B/S,EAAY7F,EAEhB,IAAKoF,EAAOkB,GAAGpB,GAAO,CACpB,IAAI4T,EAAc1F,EAAMrR,SAEpB8W,EAAO3S,EAAQwD,wBAA0B2N,GAASsB,EAAKrD,OAAOoC,IAASxR,EAAQuD,yBACjFqP,GAAerF,EAAO1S,KAAKC,IAAI6X,EAAO3S,EAAQyD,WAAYtE,EAAW2O,OAAOgB,MAAQ9O,EAAQ0D,eAAiB,KAG/G/D,EAAYuN,EAAMhB,QAAQ0G,GAQxBjT,IAAc7F,GAAS6Y,EA9Qd,KA+QXhT,EAAY7F,EAAQyT,EAAOL,EAAMK,MAG/BrO,EAAOkB,GAAGtB,KACZa,EAAYjF,EAAQiF,EAAW,EAAGO,EAAWD,YAG/CC,EAAW0I,GAAGjJ,EAAWK,EAAQ+D,eA5CjC6E,CAAG0I,GACHC,GAAa,GAwDjB,SAASQ,EAAQtS,EAAG4R,GAClB,IAAIwB,EAAYpT,EAAEoT,UACdC,EAAUrT,EAAEqT,QAEZC,EAAQD,EAAUA,EAAQ,GAAKrT,EAC/BuT,EAAUD,EAAMC,QAChBC,EAAUF,EAAME,QAEhBC,EAAQ7B,EAAU/W,IAAM,GACxB6Y,EAAUD,EAAMzS,EAChB2S,OAAoB,IAAZD,EAAqBH,EAAUG,EACvCE,EAAUH,EAAMxS,EAIhB0O,EAAS,CACX3O,EAAGuS,EAAUI,EACb1S,EAAGuS,QALmB,IAAZI,EAAqBJ,EAAUI,IAOvCC,EAAWT,GALCxB,EAAUkC,MAAQ,GAUlC,MAAO,CACLjZ,GAAI,CACFmG,EAAGuS,EACHtS,EAAGuS,GAEL7D,OAAQA,EACRmE,KAAMV,EACNH,SAXa,CACbjS,EAAG2O,EAAO3O,EAAI6S,EACd5S,EAAG0O,EAAO1O,EAAI4S,IAalB,OAAO7B,GAwBL+B,GAAQ,SAAetU,EAAQC,GAMjC,IAAIuS,GAAW,EAqCf,SAAS+B,EAAQhU,GACXiS,IACFjS,EAAEqS,iBACFrS,EAAEiU,kBACFjU,EAAEkU,4BAIN,MAtCY,CAMVxL,SAAUjJ,EAAOc,QAAQqD,KAKzB/D,MAAO,WACLJ,EAAOM,GAAG,QAASiU,EAAStU,EAAWI,SAASsB,MAAO,CACrD+S,SAAS,IACRpU,GAAG,QAAQ,WACZkS,GAAW,KACVlS,GAAG,WAAW,WAEfwB,YAAW,WACT0Q,GAAW,WAmCjBmC,GACK,EADLA,GAEK,EAFLA,GAGM,EAgUNnR,GAAS,SAAgBxD,EAAQC,EAAY7I,GAM/C,IAAIkO,EAOAC,EAqBA4E,EAdAnL,EAAUgB,EAAOhB,QAOjBxC,EAAOwD,EAAOxD,KAcd6D,EAAWJ,EAAWI,SA0E1B,SAASuU,IACP,IAAIC,EAAwB5U,EAAWe,WACnCL,EAAYkU,EAAsBlU,UAClCmU,EAAYD,EAAsBC,UAClCC,EAAW/U,EAAOjG,OAASiG,EAAOc,QAAQoC,SAAWlD,EAAOkB,GAAGrB,GACnEyF,EAAKkN,SAAW7R,EAAY,IAAMoU,EAClCxP,EAAKiN,SAAWsC,EAAY,IAAMC,EAClC/U,EAAOuH,KAAKnQ,EAAO,WAAYkO,EAAMC,EAAM5E,EAAWmU,GA0BxD,SAASE,EAAY1P,GAEnB,OAAOtH,EADK,kBAAqBgB,EAAQqG,MAAQ,KAAOC,EAAOtG,EAAQsG,KAAOtG,EAAQuG,MAA1E,mHAAoQvF,EAAOc,QAAQ2C,WAlLxR,yFAkL6S,QAItT,MAzGa,CAMXwF,SAAUjJ,EAAOc,QAAQ0C,OAKzBpD,MAAO,WAELkF,EAAOjF,EAASmD,OAAO8B,KACvBC,EAAOlF,EAASmD,OAAO+B,KAEjBD,GAASC,IAASvF,EAAOc,QAAQ0C,SACrC8B,EAAO0P,GAAY,GACnBzP,EAAOyP,GAAY,GACnB7K,GAAU,EA8DhB,WACE,IAAI8K,EAAU9c,EAAO,MAAO,CAC1B,MAAS6G,EAAQwE,SAEnB3G,EAAOoY,EAAS3P,GAChBzI,EAAOoY,EAAS1P,GAChB,IAAIJ,EAAS9E,EAAS8E,OAClB7H,EAAmC,WAA1B0C,EAAOc,QAAQ0C,QAAuB2B,EAASA,EAAS3I,EACrEiC,EAAOwW,EAAS3X,EAAO4X,mBArEnBC,IAGE7P,GAAQC,GAiCdvF,EAAOM,GAAG,SAAS,WACjBN,EAAO0J,GAAG,OACTpE,GAAMhF,GAAG,SAAS,WACnBN,EAAO0J,GAAG,OACTnE,GAAMjF,GAAG,+BAAgCsU,GAjC1C1a,KAAKsJ,OAAS,CACZ8B,KAAMA,EACNC,KAAMA,IAOV4D,QAAS,WACPnJ,EAAOuH,KAAKnQ,EAAO,WAAYkO,EAAMC,IAMvCN,QAAS,WACPzF,EAAgB,CAAC8F,EAAMC,GAAO,YAE1B4E,GACFpN,EAAWuI,EAAKhH,kBA4EpB8W,GAA0B,YAO1BC,GAAe,4BAaf3R,GAAa,SAAoB1D,EAAQC,EAAY7I,GAQvD,IAAIyP,EAAO,GAOPxG,EAAWJ,EAAWI,SAOtBiV,EAAa,CAIflV,MAAO,WACL,IAAIsD,EAAa1D,EAAOc,QAAQ4C,WAEhC,GAAIA,EAAY,CACdmD,EAgGN,WACE,IAAI/F,EAAUd,EAAOc,QACjB9B,EAAUgB,EAAOhB,QACjBkB,EAAO/H,EAAO,KAAM,CACtB,MAAS6G,EAAQ0E,aAEf6R,EAAQlV,EAASuM,WAAU,GAAOpP,QAAO,SAAUwN,GACrD,OAAyB,IAAlBlK,EAAQuC,OAAmB2H,EAAMpQ,MAAQkG,EAAQoC,UAAY,KACnEpI,KAAI,SAAUkQ,EAAOxF,GACtB,IAAIgQ,EAAKrd,EAAO,KAAM,IAClBsd,EAAStd,EAAO,SAAU,CAC5B,MAAS6G,EAAQwG,KACjBrJ,KAAM,WAOR,OALAU,EAAO2Y,EAAIC,GACX5Y,EAAOqD,EAAMsV,GACbxV,EAAOM,GAAG,SAAS,WACjBN,EAAO0J,GAAG,IAAMlE,KACfiQ,GACI,CACLD,GAAIA,EACJC,OAAQA,EACRjQ,KAAMA,EACNkF,OAAQrK,EAASyM,gBAAgBtH,OAGrC,MAAO,CACLtF,KAAMA,EACNqV,MAAOA,GA5HEG,GACP,IAAIvQ,EAAS9E,EAAS8E,OAEtBtI,EAD4B,WAAf6G,GAA2ByB,EAASA,EAASnF,EAAOxD,KAClDqK,EAAK3G,MACpBF,EAAOM,GAAG8U,GAAyBO,GAGrC3V,EAAOsH,IAAI+N,IAAc/U,GAAG+U,IAAc,WACxCC,EAAWrQ,UAEPjF,EAAOc,QAAQ4C,aACjB4R,EAAWlV,QACXkV,EAAWnM,eAQjBA,QAAS,WACP,GAAInJ,EAAOc,QAAQ4C,WAAY,CAC7B,IAAI9I,EAAQoF,EAAOpF,MACnBoF,EAAOuH,KAAKnQ,EAAO,WAAYyP,EAAM3M,KAAK0b,QAAQhb,IAClD+a,EAAiB/a,GAAQ,KAQ7BqK,QAAS,WACPlI,EAAW8J,EAAK3G,MAEZ2G,EAAK0O,OACP1O,EAAK0O,MAAMlX,SAAQ,SAAU0I,GAC3B/G,EAAOsH,IAAI,QAASP,EAAK0O,WAK7BzV,EAAOsH,IAAI8N,IACXvO,EAAO,IAUT+O,QAAS,SAAiBhb,GACxB,OAAOiM,EAAK0O,MAAMtV,EAAWe,WAAWsN,OAAO1T,KAQjD,WACE,OAAOiM,IAWX,SAAS8O,EAAiB/a,EAAO+F,GAC/B,IAAI2E,EAAOgQ,EAAWM,QAAQjV,GAC1B+F,EAAO4O,EAAWM,QAAQhb,GAC1B2H,EAASD,EAAeC,OAExB+C,GACFlG,EAAYkG,EAAKmQ,OAAQlT,GAGvBmE,GACFvH,EAASuH,EAAK+O,OAAQlT,GAGxBvC,EAAOuH,KAAKnQ,EAAO,WAAYyP,EAAMvB,EAAMoB,GAyC7C,OAAO4O,GAkBLO,GAAgB,mBAOhBC,GAAmB,0BA8MnBC,GAAgB,eAOhBC,GAAgB,gBAOhBC,GAAa,aAcbC,GAAc,cAOdC,GAAY,WAgBZC,GAAU,CACZC,IAAK,CACHC,UAAW,IACXC,WAAY,IAEZC,KAAM,IACNC,MAAO,KAETC,IAAK,CACHJ,UAAW,IACXC,WAAY,IAEZC,KAAM,IACNC,MAAO,KAETE,IAAK,CACHC,QAAS,IACTC,UAAW,IAEXC,GAAI,IACJC,KAAM,MA2ENC,GAAO,SAAchX,EAAQC,GAM/B,IAAI+F,EAAOhG,EAAOgG,KAOd3F,EAAWJ,EAAWI,SAOtB4W,EAAgB,CAACf,GAAaC,GAAWH,GAAeC,GAAYF,GAAe,QAsDvF,SAASmB,EAAYnX,EAAOyC,GAC1BzE,EAAagC,EAAOmW,IAAc1T,GAE9BxC,EAAOc,QAAQ8D,YACjB7G,EAAagC,EAAOoW,GAAW3T,EAAU,GAAK,GAYlD,SAAS2U,EAAW7R,EAAMC,GACxB,IAAI6R,EAAW/W,EAASsB,MAAMgJ,GAC9B5M,EAAauH,EAAM0Q,GAAeoB,GAClCrZ,EAAawH,EAAMyQ,GAAeoB,GAYpC,SAASC,EAAa/R,EAAMC,EAAM5E,EAAWmU,GAC3C,IAAIla,EAAQoF,EAAOpF,MACf0c,EAAY3W,GAAa,GAAK/F,EAAQ+F,EAAYqF,EAAKE,KAAOF,EAAKV,KACnEiS,EAAYzC,GAAa,GAAKla,EAAQka,EAAY9O,EAAKC,MAAQD,EAAKT,KACxExH,EAAauH,EAAM2Q,GAAYqB,GAC/BvZ,EAAawH,EAAM0Q,GAAYsB,GAWjC,SAASC,EAAe3Q,EAAM4Q,GACxBA,GACF1Z,EAAa0Z,EAAWhC,OAAQM,IAAe,GAGjDlP,EAAK0O,MAAMlX,SAAQ,SAAU0I,GAC3B,IAAIjG,EAAUd,EAAOc,QAEjB4W,EAAQ5b,GADiB,IAAlBgF,EAAQuC,OAAmBvC,EAAQoC,QAAU,EAAI8C,EAAKI,MAAQJ,EAAKG,OACpDY,EAAKvB,KAAO,GAClCiQ,EAAS1O,EAAK0O,OACd2B,EAAWrQ,EAAK2D,OAAO5P,KAAI,SAAUkQ,GACvC,OAAOA,EAAMjL,MAAM4K,MAErB5M,EAAa0X,EAAQO,GAAeoB,EAASO,KAAK,MAClD5Z,EAAa0X,EAAQQ,GAAYyB,MAYrC,SAASE,EAAiB/Q,EAAMvB,EAAMoB,GAChCpB,GACF9F,EAAgB8F,EAAKmQ,OAAQM,IAG3BrP,GACF3I,EAAa2I,EAAK+O,OAAQM,IAAe,GA8B7C,SAAS8B,EAAeC,GACtBzX,EAAS5F,MAAK,SAAUuQ,GACtB,IAAIjL,EAAQiL,EAAMjL,MACdqL,EAAYJ,EAAMI,UAEjB2M,EAAShY,IACZhC,EAAagC,EAAO,OAAQ,UAG9B,IAAIgQ,EAAa3E,GAAa,EAAIA,EAAYJ,EAAMpQ,MAChD8c,EAAQ5b,EAAQkK,EAAKG,OAAQ4J,EAAa,GAC1CiI,EAAYF,EAAK7X,WAAWI,SAASsM,SAASoD,GAClDhS,EAAagC,EAAOkW,GAAYyB,GAE5BM,GACFja,EAAagC,EAAOiW,GAAegC,EAAUjY,MAAM4K,OAYzD,SAASsN,EAAiB/c,EAAMqH,GAC9B,IAAIxC,EAAQ7E,EAAK6E,MAEbwC,EACFxE,EAAagC,EAAOgW,IAAe,GAEnCvW,EAAgBO,EAAOgW,IAY3B,SAASgC,EAAS9a,GAChB,MAAuB,WAAhBA,EAAIS,QAGb,MA7MW,CAMTuL,SAAUjJ,EAAOc,QAAQ6D,cAKzBvE,MAAO,WACLJ,EAAOM,GAAG,WAAW,SAAU0K,GAC7BkM,EAAYlM,EAAMjL,OAAO,MACxBO,GAAG,UAAU,SAAU0K,GACxBkM,EAAYlM,EAAMjL,OAAO,MACxBO,GAAG,iBAAkB6W,GAAY7W,GAAG,iBAAkB+W,GAAc/W,GAAG,qBAAsBkX,GAAgBlX,GAAG,qBAAsBsX,GAAkBtX,GAAG,WAAW,WACvKd,EAAgBS,EAAWmQ,OAAOhN,OAAQ6T,MAGxCjX,EAAOc,QAAQ+D,cACjB7E,EAAOM,GAAG,wCAAyCuX,GAAgBvX,GAAG,UAAU,SAAU0K,GACxFiN,EAAiBjN,GAAO,MACvB1K,GAAG,YAAY,SAAU0K,GAC1BiN,EAAiBjN,GAAO,MA+G9B,CAAC,OAAQ,SAAS3M,SAAQ,SAAUjH,GAClC,IAAI6F,EAAMoD,EAASjJ,GAEf6F,IACG8a,EAAS9a,IACZc,EAAad,EAAK,OAAQ,UAG5Bc,EAAad,EAAK+Y,GAAe3V,EAASsB,MAAMgJ,IAChD5M,EAAad,EAAKgZ,GAAYjQ,EAAK5O,SA9GvC6N,QAAS,WACP,IAAIiT,EAASjY,EAAWiY,OACpB1U,EAAS0U,EAASA,EAAO1U,OAAS,GACtChE,EAAgBa,EAASqB,OAAO+H,OAAO,CAACjG,EAAO8B,KAAM9B,EAAO+B,KAAMlF,EAASuF,KAAMvF,EAASwF,QAASoR,MA0LrGkB,GAAa,YAMbC,GAAe,mBAOfC,GAAe,CAAC,IAAK,QAAS,YA8S9BC,GAAW,CACbC,QAASzX,EACT0X,YA1IgB,SAAqBxY,GAMrC,IAcIyY,EAcAC,EA5BAxT,EAAclF,EAAOc,QAAQoE,YAO7ByT,EAAiB3T,GAAS4T,EAxBjB,IAsCT9d,EAAM,GA6DV,SAAS8d,IACP,IA6BI7R,EA7BA8R,GA6BA9R,EAAOjM,EAAI0C,QAAO,SAAUuJ,GAC9B,OAAOA,EAAK+R,IAAI7K,WACf,IACWlH,EAAK8R,OAAS,EA9B5B,GAAIA,IAAUH,EAAW,CACvBA,EAAYG,EACZ,IAAIjR,EAAQ5H,EAAO4H,MACf9G,EAAUoE,EAAY2T,IAAUJ,EAChCxT,EAAUnE,EAAQmE,QAElBA,GACFjF,EAAOc,QAAU2X,EACjBzY,EAAOiF,QAAoB,eAAZA,KAEX2C,EAAM1G,GAAG9G,IACX4F,EAAOI,QAGTJ,EAAOc,QAAUA,IAmBvB,MAnFkB,CAMhBmI,SAAU/D,GAAe6T,WAKzB3Y,MAAO,WACLtF,EAAMvD,OAAOiD,KAAK0K,GAAa8T,MAAK,SAAU1gB,EAAGrB,GAC/C,OAAQqB,GAAKrB,KACZ6D,KAAI,SAAU+d,GACf,MAAO,CACLA,MAAOA,EACPC,IAAKC,WAAW,cAAgBF,EAAQ,WAQ5C3e,KAAK+K,SAAQ,GACbmC,iBAAiB,SAAUuR,GAE3BF,EAAiBzY,EAAOc,QACxB8X,KAQF3T,QAAS,SAAiB8E,GACpBA,GACF/C,oBAAoB,SAAU2R,MA2DpC3X,WAAY2M,GACZtN,SAAUoK,GACVuD,MAAOrM,GACPyO,OAAQhN,GACRwL,OAAQmC,GACRwB,KAAMpO,GACN8U,MAAO3E,GACP4E,SAvkDa,SAAkBlZ,EAAQC,EAAY7I,GAMnD,IAOIwM,EAPAuV,EAAQ,GAcR9Y,EAAWJ,EAAWI,SAOtB6Y,EAAW,CAMbjQ,SAAUjJ,EAAOc,QAAQ6C,SAMzBvD,MAAO,WACL,IAAIU,EAAUd,EAAOc,QAEjBT,EAASqB,OAAO3H,OAAS+G,EAAQoC,UACnCU,EA5pBR,SAAwBlJ,EAAUkJ,EAAU8B,GAC1C,IAEIlF,EACA4Y,EACAC,EAHAC,EADU1O,OACsB0O,sBAIhCC,GAAS,EAETC,EAAO,SAASA,EAAKC,GAClBF,IACE/Y,IACHA,EAAQiZ,EAEJJ,GAAQA,EAAO,IACjB7Y,GAAS6Y,EAAOzV,IAKpByV,GADAD,EAASK,EAAYjZ,GACLoD,EAEZwV,GAAUxV,IACZpD,EAAQ,EACR6Y,EAAO,EACP3e,KAGEgL,GACFA,EAAS2T,GAGXC,EAAsBE,KAI1B,MAAO,CACL3T,MAAO,WACL0T,GAAS,EACT/Y,EAAQ,GAEVoF,KAAM,SAAc8T,GAClBlZ,EAAQ,EAEJkZ,IACFL,EAAO,GAGLE,IACFA,GAAS,EACTD,EAAsBE,MA2mBXG,EAAe,WACxB3Z,EAAO0J,GAAG,OACT5I,EAAQ8C,UAAU,SAAUyV,GAC7BrZ,EAAOuH,KAAKnQ,EAAO,WAAYiiB,GAE3BhZ,EAASsF,KACXjJ,EAAW2D,EAASsF,IAAK,CACvB/I,MAAc,IAAPyc,EAAa,SAuDhC,WACE,IAAIvY,EAAUd,EAAOc,QACjByI,EAAUvJ,EAAOuJ,QACjBnL,EAAO,CAAC4B,EAAOxD,KAAM+M,EAAUA,EAAQ/M,KAAO,MAE9CsE,EAAQ+C,eACV+V,EAASxb,EAAM,aAAcuW,IAAmB,GAChDiF,EAASxb,EAAM,aAAcuW,IAAmB,IAG9C7T,EAAQgD,eACV8V,EAASxb,EAAM,WAAYuW,IAAmB,GAC9CiF,EAASxb,EAAM,UAAWuW,IAAmB,IAG3CtU,EAASuF,MACX5F,EAAOM,GAAG,SAAS,WAEjB4Y,EAAStT,KAAK+O,IACduE,EAAStT,KAAK+O,MACbtU,EAASuF,MAGVvF,EAASwF,OACX+T,EAAS,CAACvZ,EAASwF,OAAQ,QAAS8O,IAAoB,GAG1D3U,EAAOM,GAAG,gBAAgB,WACxB4Y,EAAStT,UAEVtF,GAAG,WAAW,WACb4Y,EAASrT,WAlFPxN,GACA6B,KAAK0L,SASTA,KAAM,SAAciU,QACL,IAATA,IACFA,EAAO,IAGTV,EAAQA,EAAM3b,QAAO,SAAUsc,GAC7B,OAAOA,IAAMD,MAGJ9f,SACTiG,EAAOuH,KAAKnQ,EAAO,SACnBwM,EAASgC,KAAK5F,EAAOc,QAAQiD,iBAUjC8B,MAAO,SAAegU,QACP,IAATA,IACFA,EAAO,GAGTjW,EAASiC,SAEoB,IAAzBsT,EAAMY,QAAQF,IAChBV,EAAM9R,KAAKwS,GAGQ,IAAjBV,EAAMpf,QACRiG,EAAOuH,KAAKnQ,EAAO,YAoDzB,SAASwiB,EAASxb,EAAM6I,EAAO4S,EAAMjU,GACnCxH,EAAKC,SAAQ,SAAUpB,GACrB+C,EAAOM,GAAG2G,GAAO,WACfiS,EAAStT,EAAO,OAAS,SAASiU,KACjC5c,MAIP,OAAOic,GA26CPc,MAp5CU,SAAeha,EAAQC,GA8CjC,SAAShG,EAAMggB,GACbha,EAAWI,SAAS5F,MAAK,SAAUuQ,GACjC,IAAIqC,EAAMhQ,EAAM2N,EAAMjL,MAAO,QAAU1C,EAAM2N,EAAM5F,UAAW,OAE1DiI,GAAOA,EAAI6M,KACbxV,EAAM2I,EAAK4M,MAYjB,SAASvV,EAAM2I,EAAK4M,GAClBvd,EAAW2Q,EAAI/O,cAAe,CAC5B6b,WAAYF,EAAU,GAAK,+BAAkC5M,EAAI6M,IAAM,OAEzExd,EAAW2Q,EAAK,CACd1B,QAASsO,EAAU,GAAK,SAI5B,MA3DY,CAMVhR,SAbYjJ,EAAOc,QAaD4D,MAKlBtE,MAAO,WACLJ,EAAOM,GAAG,mBAAmB,SAAU+M,GACrC3I,EAAM2I,GAAK,MAEbrN,EAAOM,GAAG,2BAA2B,WACnC,OAAOrG,GAAM,OAOjBgL,QAAS,WACPhL,GAAM,MAg3CVie,OAAQ1U,GACR8R,WAAY5R,GACZ0W,SAt5Ba,SAAkBpa,EAAQC,EAAY7I,GAMnD,IAAI0d,EAOA5H,EAOApM,EAAUd,EAAOc,QAOjBuZ,EAAoC,eAArBvZ,EAAQkD,SAsD3B,SAAS8G,IACPoC,EAAS,GACT4H,EAAY,EAUd,SAAS8D,EAAMhe,GACbA,EAAQ0f,MAAM1f,GAASoF,EAAOpF,MAAQA,GACtCsS,EAASA,EAAO1P,QAAO,SAAU+c,GAC/B,OAAIA,EAAMvP,MAAMqB,SAASzR,EAAOkG,EAAQoC,SAAWpC,EAAQmD,aAAe,MACxEuW,EAAKD,EAAMlN,IAAKkN,EAAMvP,QACf,OAMC,IACVhL,EAAOsH,IAAI,SAAWlQ,GAa1B,SAASojB,EAAKnN,EAAKrC,GACjB7L,EAAS6L,EAAMjL,MAAOuC,EAAeG,SACrC,IAAIqD,EAAU3N,EAAO,OAAQ,CAC3B,MAAS6H,EAAOhB,QAAQ8G,UAE1BjJ,EAAOwQ,EAAI/O,cAAewH,GAE1BuH,EAAIC,OAAS,WACXE,EAAOH,EAAKvH,EAASkF,GAAO,IAG9BqC,EAAIE,QAAU,WACZC,EAAOH,EAAKvH,EAASkF,GAAO,IAG9BjN,EAAasP,EAAK,SAAU9N,EAAa8N,EAAKyI,KAAqB,IACnE/X,EAAasP,EAAK,MAAO9N,EAAa8N,EAAKwI,KAAkB,IAO/D,SAAS4E,IACP,GAAI3F,EAAY5H,EAAOnT,OAAQ,CAC7B,IAAIwgB,EAAQrN,EAAO4H,GACnB0F,EAAKD,EAAMlN,IAAKkN,EAAMvP,OAGxB8J,IAYF,SAAStH,EAAOH,EAAKvH,EAASkF,EAAOjJ,GACnC3C,EAAY4L,EAAMjL,MAAOuC,EAAeG,SAEnCV,IACHhF,EAAW+I,GACXpJ,EAAW2Q,EAAK,CACd1B,QAAS,KAEX3L,EAAOuH,KAAKnQ,EAAO,UAAWiW,GAAK9F,KAAK,WAGtC8S,GACFI,IAIJ,MA7Ie,CAMbxR,SAAUnI,EAAQkD,SAKlB5D,MAAO,WACLJ,EAAOM,GAAG,mBAAmB,WAC3BwK,IACA7K,EAAWI,SAAS5F,MAAK,SAAUuQ,GACjCvQ,EAAKuQ,EAAMjL,MAAMoN,iBAAiB,wBAA+B2I,GAAmB,MAAM,SAAUzI,GAC7FA,EAAI6M,KAAQ7M,EAAIqN,SACnBxN,EAAO7F,KAAK,CACVgG,IAAKA,EACLrC,MAAOA,IAETtO,EAAW2Q,EAAK,CACd1B,QAAS,gBAMb0O,GACFI,OAICJ,GACHra,EAAOM,GAAG,yBAA2BlJ,EAAMwhB,IAO/C3T,QAAS6F,IA40BX6P,SAloBa,SAAkB3a,GAM/B,IAAInG,EACJ,MAAO,CAILuG,MAAO,WACLJ,EAAOM,GAAG,mBAAmB,WAC3B,IAAIQ,EAAUd,EAAOc,QACjBtE,EAAOwD,EAAOxD,KACd1B,EAAMsb,GAAQtV,EAAQ2D,WACtBP,EAAWpD,EAAQoD,SAEnBrK,IACFmG,EAAOsH,IAAI,UAAWzN,GACtB2F,EAAgBhD,EAAM2Z,KAGpBjS,IACe,YAAbA,GACFrK,EAAS2C,EACTuB,EAAavB,EAAM2Z,GAAW,IAE9Btc,EAASgE,SAGXmC,EAAOM,GAAG,WAAW,SAAUC,GACzBzF,EAAIyF,EAAEnI,MACR4H,EAAO0J,GAAG5O,EAAIyF,EAAEnI,QAEjByB,UAgmBX+gB,KAnTS,SAAc5a,GAMvB,IAAIuJ,EAAUvJ,EAAOuJ,QAOjB1E,EAAe0E,GAAWA,EAAQzI,QAAQ+D,aA+C9C,SAASgW,IACP7a,EAAOM,GAAG6X,IAAY,SAAUzX,EAAUC,EAAWF,GACnD8I,EAAQjC,IAAI6Q,IAAYzO,GAAGH,EAAQrI,GAAGrB,GAAQY,EAAYC,GAAU,GACpEoa,OASJ,SAASA,IACPvR,EAAQjJ,GAAG6X,IAAY,SAAUzX,EAAUC,EAAWF,GACpDT,EAAOsH,IAAI6Q,IAAYzO,GAAG1J,EAAOkB,GAAGrB,GAAQY,EAAYC,GAAU,GAClEma,OAQJ,SAASxiB,IACPkR,EAAQtJ,WAAWI,SAAS5F,MAAK,SAAUS,GACzC,IAAI6E,EAAQ7E,EAAK6E,MACbnF,EAAQM,EAAKN,MAKjBoF,EAAOsH,IAAI8Q,GAAcrY,GAAOO,GAAG8X,IAAc,SAAU7X,GAEpDA,EAAEkV,QAAuB,IAAblV,EAAEkV,QACjBsF,EAAYngB,KAEbmF,GAMHC,EAAOsH,IAAI,QAASvH,GAAOO,GAAG,SAAS,SAAUC,GAC3C8X,GAAa0B,QAAQxZ,EAAEnI,MAAQ,IACjCmI,EAAEqS,iBACFmI,EAAYngB,MAEbmF,EAAO,CACR2S,SAAS,OAYf,SAASqI,EAAYngB,GACfoF,EAAO4H,MAAM1G,GAAG7G,IAClBkP,EAAQG,GAAG9O,GAIf,MA1GW,CAMTqO,WAAYM,EAKZnJ,MAAO,WACLya,IACAC,IAEIjW,IACFxM,IACA2H,EAAOM,GAAG,WAAW,WACnBwB,YAAW,WACTzJ,IACAkR,EAAQhC,KAAK,qBAAsBvH,WAS3CmJ,QAAS,WACHtE,GACF0E,EAAQhC,KAAK,qBAAsBvH,MAiQzCgb,KAAMhE,IAkCJiE,GAA6B,SAAUC,GAjB3C,IAAwBC,EAAUC,EAoBhC,SAASpb,EAAOxD,EAAMsE,GACpB,OAAOoa,EAAMlkB,KAAKkD,KAAMsC,EAAMsE,EAASwX,KAAape,KAGtD,OAxBgCkhB,EAkBTF,GAlBDC,EAkBPnb,GAjBNvH,UAAYlB,OAAOY,OAAOijB,EAAW3iB,WAC9C0iB,EAAS1iB,UAAUY,YAAc8hB,EACjCA,EAASE,UAAYD,EAqBdpb,EAPwB,CAQ/BA,KAcFsb,EAA2B,GAQ/B,SAAS7kB,EAAoBC,GAK3B,GAAI4kB,EAAyB5kB,GAE3B,OAAO4kB,EAAyB5kB,GAAUC,QAS5C,IAAIC,EAAS0kB,EAAyB5kB,GAAY,CAQhDC,QAAS,IAoBX,OATA4C,EAAoB7C,GAAUE,EAAQA,EAAOD,QAASF,GAS/CG,EAAOD,QA2GhB,OAxFEF,EAAoBU,EAAI,SAAUR,EAAS4kB,GAEzC,IAAK,IAAInjB,KAAOmjB,EAEV9kB,EAAoBa,EAAEikB,EAAYnjB,KAAS3B,EAAoBa,EAAEX,EAASyB,IAE5Eb,OAAOC,eAAeb,EAASyB,EAAK,CAClCX,YAAY,EACZC,IAAK6jB,EAAWnjB,MAwBxB3B,EAAoBa,EAAI,SAAU8B,EAAKyF,GACrC,OAAOtH,OAAOkB,UAAUC,eAAe1B,KAAKoC,EAAKyF,IAmBnDpI,EAAoBkB,EAAI,SAAUhB,GAEV,qBAAXiB,QAA0BA,OAAOC,aAE1CN,OAAOC,eAAeb,EAASiB,OAAOC,YAAa,CACjDC,MAAO,WAOXP,OAAOC,eAAeb,EAAS,aAAc,CAC3CmB,OAAO,KAuBNrB,EAAoB,KAz/LxB,IAFmE,WAAtByC,EAAQvC,IAA8F,WAArBuC,EAAQtC,GAAuBA,EAAOD,QAAUsC,KAA+D,EAAO,QAAW,2BAAP,EAAF,GAAS,kC,sDCTxQ,mBAEe,IAFf,OAEmB+G,GAAQ,kBAAmB,CAC1C7D,KAAS,QACT+G,QAAS,EACTP,QAAQ,EACR1B,MAAO,IACP0C,UAAU,EACVC,SAAU,IACVC,cAAc,EACdC,cAAc,EACd9E,QAAS,CACLwE,OAAQ,oCAITpD","file":"js/javascripts/shared/welcome/heroSlider-973c0aa1ab6bd5a1290a.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 = \"//d3n1zec9rgiduo.cloudfront.net/packs/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 925);\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};","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _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:\n        /***/\n        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});","import Splide from '@splidejs/splide'\n\nconst splide = new Splide( '#js-hero-slider', {\n    type   : 'slide',\n    perPage: 1,\n    rewind: true,\n    speed: 300,\n    autoplay: true,\n    interval: 10000,\n    pauseOnHover: false,\n    pauseOnFocus: false,\n    classes: {\n        arrows: 'splide__arrows hidden md:block',\n    },\n} )\n\nsplide.mount();\n"],"sourceRoot":""}