{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/body-scroll-lock/lib/bodyScrollLock.esm.js","webpack:///./node_modules/@motionone/dom/dist/utils/resolve-elements.es.js","webpack:///./node_modules/@motionone/utils/dist/is-function.es.js","webpack:///./node_modules/@motionone/dom/dist/gestures/in-view.es.js","webpack:///./node_modules/@motionone/utils/dist/defaults.es.js","webpack:///./node_modules/@motionone/utils/dist/time.es.js","webpack:///./node_modules/@motionone/utils/dist/noop.es.js","webpack:///./node_modules/@motionone/dom/dist/animate/utils/stop-animation.es.js","webpack:///./node_modules/@motionone/dom/dist/animate/utils/controls.es.js","webpack:///./node_modules/@motionone/utils/dist/is-easing-generator.es.js","webpack:///./node_modules/@motionone/utils/dist/is-number.es.js","webpack:///./node_modules/@motionone/utils/dist/is-easing-list.es.js","webpack:///./node_modules/@motionone/utils/dist/mix.es.js","webpack:///./node_modules/@motionone/utils/dist/progress.es.js","webpack:///./node_modules/@motionone/utils/dist/offset.es.js","webpack:///./node_modules/@motionone/utils/dist/clamp.es.js","webpack:///./node_modules/@motionone/utils/dist/interpolate.es.js","webpack:///./node_modules/@motionone/utils/dist/easing.es.js","webpack:///./node_modules/@motionone/utils/dist/wrap.es.js","webpack:///./node_modules/@motionone/easing/dist/cubic-bezier.es.js","webpack:///./node_modules/@motionone/easing/dist/steps.es.js","webpack:///./node_modules/@motionone/utils/dist/is-cubic-bezier.es.js","webpack:///./node_modules/@motionone/animation/dist/utils/easing.es.js","webpack:///./node_modules/@motionone/animation/dist/Animation.es.js","webpack:///./node_modules/@motionone/types/dist/MotionValue.es.js","webpack:///./node_modules/@motionone/dom/dist/animate/data.es.js","webpack:///./node_modules/@motionone/dom/dist/animate/utils/transforms.es.js","webpack:///./node_modules/@motionone/dom/dist/animate/utils/css-var.es.js","webpack:///./node_modules/@motionone/dom/dist/animate/utils/feature-detection.es.js","webpack:///./node_modules/@motionone/dom/dist/animate/utils/easing.es.js","webpack:///./node_modules/@motionone/dom/dist/animate/utils/get-style-name.es.js","webpack:///./node_modules/@motionone/dom/dist/animate/style.es.js","webpack:///./node_modules/@motionone/utils/dist/is-string.es.js","webpack:///./node_modules/@motionone/dom/dist/animate/animate-style.es.js","webpack:///./node_modules/@motionone/utils/dist/array.es.js","webpack:///./node_modules/@motionone/dom/dist/animate/utils/keyframes.es.js","webpack:///./node_modules/@motionone/dom/dist/animate/utils/get-unit.es.js","webpack:///./node_modules/@motionone/dom/dist/animate/utils/options.es.js","webpack:///./node_modules/@motionone/dom/dist/utils/stagger.es.js","webpack:///./node_modules/@motionone/dom/dist/animate/index.es.js","webpack:///./node_modules/@motionone/dom/dist/animate/create-animate.es.js","webpack:///./node_modules/motion/dist/animate.es.js","webpack:///./node_modules/tslib/tslib.es6.js","webpack:///./node_modules/@motionone/dom/dist/gestures/resize/handle-element.es.js","webpack:///./node_modules/@motionone/dom/dist/gestures/resize/handle-window.es.js","webpack:///./node_modules/@motionone/dom/dist/gestures/scroll/info.es.js","webpack:///./node_modules/@motionone/utils/dist/velocity.es.js","webpack:///./node_modules/@motionone/dom/dist/gestures/scroll/offsets/presets.es.js","webpack:///./node_modules/@motionone/dom/dist/gestures/scroll/offsets/edge.es.js","webpack:///./node_modules/@motionone/dom/dist/gestures/scroll/offsets/offset.es.js","webpack:///./node_modules/@motionone/dom/dist/gestures/scroll/offsets/index.es.js","webpack:///./node_modules/@motionone/dom/dist/gestures/scroll/offsets/inset.es.js","webpack:///./node_modules/@motionone/dom/dist/gestures/scroll/on-scroll-handler.es.js","webpack:///./node_modules/@motionone/dom/dist/gestures/scroll/index.es.js","webpack:///./node_modules/@motionone/dom/dist/gestures/resize/index.es.js","webpack:///./node_modules/split-type/dist/index.js","webpack:///./node_modules/@splidejs/splide/dist/js/splide.esm.js","webpack:///./assets/scripts/template-parts/blocks/testimonial-slider.js","webpack:///./assets/scripts/template-parts/blocks/media-text.js","webpack:///./assets/scripts/global.js","webpack:///./assets/scripts/template-parts/patterns/home-hero.js","webpack:///./assets/scripts/theme.js","webpack:///./assets/scripts/template-parts/patterns/home-video.js","webpack:///./assets/scripts/template-parts/patterns/rtb.js","webpack:///./assets/scripts/template-parts/blocks/accordion.js","webpack:///./assets/scripts/animations.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","hasPassiveEvents","window","passiveTestOptions","addEventListener","removeEventListener","isIosDevice","navigator","platform","test","maxTouchPoints","locks","documentListenerAdded","initialClientY","previousBodyOverflowSetting","previousBodyPosition","previousBodyPaddingRight","allowTouchMove","el","some","lock","options","preventDefault","rawEvent","e","event","target","touches","length","restoreOverflowSetting","undefined","document","body","style","paddingRight","overflow","restorePositionSetting","y","parseInt","top","x","left","position","scrollTo","disableBodyScroll","targetElement","concat","arr","Array","isArray","arr2","from","_toConsumableArray","requestAnimationFrame","_window","scrollY","scrollX","innerHeight","setTimeout","bottomBarHeight","_reserveScrollBarGap","reserveScrollBarGap","scrollBarGap","innerWidth","documentElement","clientWidth","computedBodyPaddingRight","getComputedStyle","getPropertyValue","setOverflowHidden","ontouchstart","targetTouches","clientY","ontouchmove","scrollTop","scrollHeight","clientHeight","isTargetElementTotallyScrolled","stopPropagation","handleScroll","passive","console","error","resolveElements","elements","selectorCache","_a","querySelectorAll","Element","isFunction","thresholds","any","all","inView","elementOrSelector","onStart","root","margin","rootMargin","amount","IntersectionObserver","activeIntersections","WeakMap","observer","entries","forEach","entry","onEnd","isIntersecting","Boolean","newOnEnd","set","unobserve","delete","threshold","element","observe","disconnect","defaults","duration","delay","endDelay","repeat","easing","seconds","milliseconds","noop","noopReturn","v","stopAnimation","animation","needsCommit","playState","stop","commitStyles","cancel","createAnimation","factory","withControls","animationFactory","Proxy","animations","map","filter","activeAnimation","finished","Promise","selectFinished","catch","callback","isEasingGenerator","isNumber","isEasingList","mix","min","max","progress","fillOffset","offset","remaining","offsetProgress","push","defaultOffset","clamp","Math","interpolate","output","input","remainder","progressInRange","rangeSize","wrap","getEasingForSegment","segmentEasing","calcBezier","a1","a2","cubicBezier","mX1","mY1","mX2","mY2","getTForX","aX","lowerBound","upperBound","currentX","currentT","abs","binarySubdivide","isCubicBezier","namedEasings","ease","functionArgsRegex","getEasingFunction","definition","startsWith","args","exec","argsArray","split","steps","direction","expanded","rounded","floor","ceil","parseFloat","trim","keyframes","initialDuration","this","startTime","rate","cancelTimestamp","totalDuration","resolve","reject","custom","updateDuration","interpolate$1","tick","timestamp","pauseTime","currentIteration","iterationProgress","iterationIsOdd","latest","frameRequestId","play","now","performance","cancelAnimationFrame","MotionValue","then","clearAnimation","generator","getAnimationData","has","transforms","values","Map","axes","transformAlias","z","rotation","syntax","initialValue","toDefaultUnit","baseTransformProperties","translate","rotate","scale","skew","transformDefinitions","asTransformCssVar","axis","compareTransformOrder","a","b","indexOf","transformLookup","Set","isTransform","buildTransformTemplate","sort","reduce","transformListToString","template","isCssVar","registeredProperties","testAnimation","createElement","animate","featureTests","cssRegisterProperty","CSS","waapi","partialKeyframes","opacity","linearEasing","results","supports","convertEasing","points","numPoints","round","substring","generateLinearEasingPoints","cubicBezierAsString","getStyleName","setProperty","isString","animateStyle","keyframesDefinition","AnimationPolyfill","record","__MOTION_DEV_TOOLS_RECORD","isRecording","persist","allowWebkitAcceleration","data","valueIsTransform","canAnimateNatively","array","item","transform","addTransformToElement","motionValue","motionValues","getMotionValue","readInitialValue","_b","hydrateKeyframes","keyframesList","toUnit","finalKeyframe","unit","match","getUnitConverter","add","registerProperty","inherits","registerCssVariable","unshift","animationOptions","iterations","fill","thisEasing","onfinish","oncancel","playbackRate","assign","setAnimation","getOptions","stagger","start","total","fromIndex","lastIndex","getFromIndex","distance","maxDelay","easingFunction","resolveOption","option","AnimatePolyfill","numElements","animationFactories","valueOptions","animateProgress","keyframesOrOptions","__rest","getOwnPropertySymbols","propertyIsEnumerable","SuppressedError","resizeHandlers","notifyTarget","contentRect","borderBoxSize","handler","contentSize","inlineSize","blockSize","width","height","SVGElement","getBBox","offsetWidth","offsetHeight","getElementSize","notifyAll","resizeElement","ResizeObserver","elementHandlers","size","windowCallbacks","windowResizeHandler","resizeWindow","info","keys","updateAxisInfo","axisName","time","prev","current","prevTime","scrollLength","elapsed","velocity","frameDuration","ScrollOffset","Enter","Exit","Any","All","namedEdges","center","end","resolveEdge","edge","inset","delta","asNumber","endsWith","resolveOffset","containerLength","targetLength","targetInset","offsetDefinition","targetPoint","containerPoint","includes","point","resolveOffsets","container","lengthLabel","HTMLElement","offsetLeft","offsetTop","offsetParent","SVGGraphicsElement","tagName","parentNode","calcInset","targetSize","scrollWidth","containerSize","hasChanged","numOffsets","interpolatorOffsets","createOnScrollHandler","onScroll","measure","targetOffset","node","update","updateScrollInfo","notify","scrubAnimation","controls","axisInfo","pause","forEachNative","timingOptions","effect","updateTiming","currentTime","scrollListeners","resizeListeners","onScrollHandlers","getEventTarget","containerHandlers","containerHandler","listener","onLoadProcesss","extend","getOwnPropertyNames","extended","currentValue","getOwnPropertyDescriptor","newValue","parseSettings","settings","types","String","type","absolute","parseTypes","none","lines","words","chars","isObject","isNode","nodeType","toArray","isLength","isArrayLike","slice","getTargetElements","getElementById","result","append","nodes","appendChild","createTextNode","replaceChildren","lastChild","removeChild","replaceWith","parent","ownerDocument","insertBefore","previousSibling","replaceChild","DocumentFragment","cache","uid","owner","warn","id","getPrototypeOf","remove","rsAstral","rsCombo","rsFitz","rsNonAstral","rsRegional","rsSurrPair","reOptMod","rsSeq","join","rsSymbol","reUnicode","RegExp","reHasUnicode","hasUnicode","string","stringToArray","unicodeToArray","asciiToArray","toChars","separator","attributes","attribute","rawValue","setAttribute","splitClass","lineClass","wordClass","charClass","splitWordsAndChars","textNode","TAG_NAME","VALUE","nodeValue","splitText","createDocumentFragment","replace","toWords","WORD","idx","wordElement","characterElementsForCurrentWord","CHAR","characterElement","class","children","isWord","isWordStart","isWordEnd","repositionAfterSplit","scrollPos","getElementsByTagName","wordsInEachLine","elementHeight","elementWidth","contentBox","wordsInCurrentLine","lineOffsetY","parentElement","nextSibling","nextElementSibling","cs","align","textAlign","lineThreshold","fontSize","cssWidth","cssHeight","isWordLike","parentX","parentY","parentRect","getBoundingClientRect","getPosition","nodeName","wordsInThisLine","lineElement","lineDimensions","wordOrElement","next","unSplitWords","childNodes","child","isLine","parentData","isChildOfLineNode","_defaults","SplitType","isSplit","html","innerHTML","revert","pageXOffset","pageYOffset","wordsAndChars","isRoot","display","prevSibling","text","textContent","textAfter","textBefore","_defineProperties","props","descriptor","configurable","writable","STATES","CREATED","MOUNTED","IDLE","MOVING","SCROLLING","DRAGGING","DESTROYED","empty","arrayLike","apply","func","arguments","nextTick","raf","typeOf","subject","isNull","isUndefined","isHTMLElement","defaultView","iteratee","items","toggleClass","elm","classes","classList","addClass","before","ref","matches","selector","children2","firstElementChild","ownKeys","forOwn","right","reverse","source","merge","omit","removeAttribute","elms","attrs","attr","value2","tag","prop","display2","focus","preventScroll","getAttribute","hasClass","className","contains","rect","parseHtml","DOMParser","parseFromString","prevent","stopImmediatePropagation","query","querySelector","queryAll","removeClass","timeOf","timeStamp","assert","condition","message","Error","approximatelyEqual","epsilon","between","number","exclusive","minimum","maximum","sign","format","replacements","replacement","pad","ids","uniqueId","prefix","EventBinder","listeners","forEachEvent","targets","events","events2","eventNS","fragment","namespace","isEventTarget","remover","unbind","dispatch","detail","CustomEvent","bubbles","createEvent","initCustomEvent","dispatchEvent","destroy","EventInterface","Splide2","bus","binder","on","off","emit","RequestInterval","interval","onInterval","onUpdate","limit","Date","paused","count","resume","rewind","isPaused","ORIENTATION_MAP","X","Y","ArrowLeft","ARROW","ArrowRight","Direction","Components2","axisOnly","index","toLowerCase","charAt","toUpperCase","orient","ROLE","ALL_ATTRIBUTES","ARIA_PREFIX","CLASS_ROOT","CLASS_ACTIVE","STATUS_CLASS_PREFIX","STATUS_CLASSES","CLASSES","slide","CLASS_PREFIX","clone","CLASS_SLIDE","arrows","arrow","CLASS_ARROW","pagination","page","CLASS_PAGINATION","spinner","POINTER_UP_EVENTS","LOOP","Slide$1","slideIndex","destroyed","Components","isNavigation","updateOnMove","i18n","slideFocus","styles","label","isClone","initNavigation","splides","Slide2","splide","Slides","getAt","slideX","onMove","curr","active","isActive","self","visible","is","trackRect","Elements","track","slideRect","isVisible","hidden","state","focusableNodes","activeElement","updateVisibility","cloneStatus","mount","slideLabel","useContainer","isWithin","diff","PATH","SCROLL_LISTENER_OPTIONS","capture","NORMALIZATION_MAP","Spacebar","Right","Left","Up","Down","normalizeKey","TRIGGER_KEYS","ComponentConstructors","freeze","__proto__","Media","breakpoints","reducedMotion","queries","completely","register","options2","queryList","matchMedia","merged","merged2","refresh","opts","base","setup","isMin","mediaQuery","enable","list","isUsingKey","_EventInterface","slides","rootClasses","trackClasses","find","bar","CLASS_PROGRESS","toggle","role","carousel","init","getClasses","labelledby","closest","drag","POINTER_DOWN_EVENTS","_EventInterface2","_Components2$Elements","Slides2","forEach$1","Slide1","excludeClones","matcher","getIn","Controller","toIndex","hasFocus","perPage","images","img","getLength","isEnough","Layout","vertical","rootRect","_EventInterface3","_Components2$Elements2","styleSlides","cssPadding","resize","force","newRect","cssTrackHeight","gap","autoWidth","fixedWidth","cssSlideSize","fixedHeight","autoHeight","isOverflow","padding","heightRatio","listSize","slideSize","withoutGap","Slide","getGap","totalSize","sliderSize","getPadding","Clones","cloneCount","clones","remount","computeCloneCount","isHead","cloneNode","cloneDeep","generate","clones2","fixedSize","Move","Transition","_EventInterface4","_Components2$Layout","_Components2$Directio","_Components2$Elements3","reposition","isBusy","Scroll","jump","toPosition","preventLoop","destination","exceededMax","getEnd","shift","loop","backwards","excess","getLimit","minDistance","Infinity","trimming","trimSpace","move","dest","shifted","exceededLimit","exceededMin","endIndex","slideCount","perMove","_EventInterface5","_Components2$Slides","omitEnd","isLoop","isSlide","getNext","getAdjacent","getPrev","currIndex","prevIndex","onResized","computeDestIndex","snapPage","computeMovableDestIndex","toPage","setIndex","waitForTransition","go","control","allowSameIndex","_ref","indicator","parse","scroll","snap","getIndex","toDest","Arrows","created","wrapperClasses","placeholder","wrapper","enabled","createArrow","CLASS_ARROWS","prev2","arrowPath","nextIndex","prevLabel","last","nextLabel","first","disabled","Autoplay","hovered","focused","_EventInterface6","_Components2$Elements4","autoplay","stopped","resetProgress","autoToggle","DATA_ATTRIBUTE","pauseOnHover","pauseOnFocus","listen","Cover","cover","cover2","src","_EventInterface8","friction","onScrolled","noConstrain","clear","noDistance","to","easingFunc","pow","Drag","basePosition","baseEvent","prevBaseEvent","isFree","dragging","clickPrevented","_EventInterface9","_Components2$Directio2","exceeded","disable","onPointerDown","isTouch","isTouchEvent","target2","noDrag","button","onPointerMove","onPointerUp","save","cancelable","diffCoord","expired","diffTime","hasExceeded","isSliderDirection","dragMinThreshold","isObj","mouse","touch","shouldStart","computeVelocity","flickPower","flickMaxPages","computeDestination","rewindByDrag","onClick","orthogonal","coordOf","getBaseEvent","changedTouches","TouchEvent","isDragging","Keyboard","_EventInterface10","keyboard","onKeydown","_disabled","LazyLoad","_EventInterface11","isSequential","lazyLoad","srcset","SRC_DATA_ATTRIBUTE","loadNext","check","preloadPages","load","onLoad","Pagination","paginationClasses","dir","getDirection","nextPage","paginationDirection","_button","select","li","pageX","paginationKeyboard","createPagination","Sync","isParent","sync","Wheel","lastTime","onWheel","deltaY","_min","wheelMinThreshold","sleep","wheelSleep","releaseWheel","shouldPrevent","wheel","Live","live","sr","DEFAULTS","speed","rewindSpeed","Fade","done","endCallback","transition","getSpeed","useScroll","Splide","_Splide","states","_o","_E","JSON","Constructor","protoProps","staticProps","_proto","Extensions","_this","_C","_T","Component","component","_this$event","$","splideElement","targetSlide","newVisibleSlide","currentSlide","updateVisibleSlide","handleArrowClick","setupArrowListeners","leftSlider","setupSlideListeners","setupMoveListener","firstSlide","initializeFirstSlide","jQuery","each","slideToggle","css","slideDown","headerHeight","outerHeight","buttonWidth","homeHero","prepend","smallCta","smallCtaText","video","videoSrc","newSrc","show","hide","enableBodyScroll","homeVideo","columnLink","rtb","testimonialSlider","click","$this","slideUp","accordion","accordionScript","sideDishes","clipPath","startPt","parents","numberWords","section","copyBox","preFooter","mnkyImg","wrapInner","spaceHolder","horizontal","windowH","windowW","anotherWrapperRealDimensions","minMovement","sticky","totalMove","opacityZone","opacityLevel","leaveInfo","latestPosts","socialBar","mStart","movement","yOff","textLines"],"mappings":"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","file":"/scripts/theme.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 = \"/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 1);\n","function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\n// Older browsers don't support event options, feature detect it.\n\n// Adopted and modified solution from Bohdan Didukh (2017)\n// https://stackoverflow.com/questions/41594997/ios-10-safari-prevent-scrolling-behind-a-fixed-overlay-and-maintain-scroll-posi\n\nvar hasPassiveEvents = false;\nif (typeof window !== 'undefined') {\n  var passiveTestOptions = {\n    get passive() {\n      hasPassiveEvents = true;\n      return undefined;\n    }\n  };\n  window.addEventListener('testPassive', null, passiveTestOptions);\n  window.removeEventListener('testPassive', null, passiveTestOptions);\n}\n\nvar isIosDevice = typeof window !== 'undefined' && window.navigator && window.navigator.platform && (/iP(ad|hone|od)/.test(window.navigator.platform) || window.navigator.platform === 'MacIntel' && window.navigator.maxTouchPoints > 1);\n\n\nvar locks = [];\nvar documentListenerAdded = false;\nvar initialClientY = -1;\nvar previousBodyOverflowSetting = void 0;\nvar previousBodyPosition = void 0;\nvar previousBodyPaddingRight = void 0;\n\n// returns true if `el` should be allowed to receive touchmove events.\nvar allowTouchMove = function allowTouchMove(el) {\n  return locks.some(function (lock) {\n    if (lock.options.allowTouchMove && lock.options.allowTouchMove(el)) {\n      return true;\n    }\n\n    return false;\n  });\n};\n\nvar preventDefault = function preventDefault(rawEvent) {\n  var e = rawEvent || window.event;\n\n  // For the case whereby consumers adds a touchmove event listener to document.\n  // Recall that we do document.addEventListener('touchmove', preventDefault, { passive: false })\n  // in disableBodyScroll - so if we provide this opportunity to allowTouchMove, then\n  // the touchmove event on document will break.\n  if (allowTouchMove(e.target)) {\n    return true;\n  }\n\n  // Do not prevent if the event has more than one touch (usually meaning this is a multi touch gesture like pinch to zoom).\n  if (e.touches.length > 1) return true;\n\n  if (e.preventDefault) e.preventDefault();\n\n  return false;\n};\n\nvar setOverflowHidden = function setOverflowHidden(options) {\n  // If previousBodyPaddingRight is already set, don't set it again.\n  if (previousBodyPaddingRight === undefined) {\n    var _reserveScrollBarGap = !!options && options.reserveScrollBarGap === true;\n    var scrollBarGap = window.innerWidth - document.documentElement.clientWidth;\n\n    if (_reserveScrollBarGap && scrollBarGap > 0) {\n      var computedBodyPaddingRight = parseInt(window.getComputedStyle(document.body).getPropertyValue('padding-right'), 10);\n      previousBodyPaddingRight = document.body.style.paddingRight;\n      document.body.style.paddingRight = computedBodyPaddingRight + scrollBarGap + 'px';\n    }\n  }\n\n  // If previousBodyOverflowSetting is already set, don't set it again.\n  if (previousBodyOverflowSetting === undefined) {\n    previousBodyOverflowSetting = document.body.style.overflow;\n    document.body.style.overflow = 'hidden';\n  }\n};\n\nvar restoreOverflowSetting = function restoreOverflowSetting() {\n  if (previousBodyPaddingRight !== undefined) {\n    document.body.style.paddingRight = previousBodyPaddingRight;\n\n    // Restore previousBodyPaddingRight to undefined so setOverflowHidden knows it\n    // can be set again.\n    previousBodyPaddingRight = undefined;\n  }\n\n  if (previousBodyOverflowSetting !== undefined) {\n    document.body.style.overflow = previousBodyOverflowSetting;\n\n    // Restore previousBodyOverflowSetting to undefined\n    // so setOverflowHidden knows it can be set again.\n    previousBodyOverflowSetting = undefined;\n  }\n};\n\nvar setPositionFixed = function setPositionFixed() {\n  return window.requestAnimationFrame(function () {\n    // If previousBodyPosition is already set, don't set it again.\n    if (previousBodyPosition === undefined) {\n      previousBodyPosition = {\n        position: document.body.style.position,\n        top: document.body.style.top,\n        left: document.body.style.left\n      };\n\n      // Update the dom inside an animation frame \n      var _window = window,\n          scrollY = _window.scrollY,\n          scrollX = _window.scrollX,\n          innerHeight = _window.innerHeight;\n\n      document.body.style.position = 'fixed';\n      document.body.style.top = -scrollY;\n      document.body.style.left = -scrollX;\n\n      setTimeout(function () {\n        return window.requestAnimationFrame(function () {\n          // Attempt to check if the bottom bar appeared due to the position change\n          var bottomBarHeight = innerHeight - window.innerHeight;\n          if (bottomBarHeight && scrollY >= innerHeight) {\n            // Move the content further up so that the bottom bar doesn't hide it\n            document.body.style.top = -(scrollY + bottomBarHeight);\n          }\n        });\n      }, 300);\n    }\n  });\n};\n\nvar restorePositionSetting = function restorePositionSetting() {\n  if (previousBodyPosition !== undefined) {\n    // Convert the position from \"px\" to Int\n    var y = -parseInt(document.body.style.top, 10);\n    var x = -parseInt(document.body.style.left, 10);\n\n    // Restore styles\n    document.body.style.position = previousBodyPosition.position;\n    document.body.style.top = previousBodyPosition.top;\n    document.body.style.left = previousBodyPosition.left;\n\n    // Restore scroll\n    window.scrollTo(x, y);\n\n    previousBodyPosition = undefined;\n  }\n};\n\n// https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollHeight#Problems_and_solutions\nvar isTargetElementTotallyScrolled = function isTargetElementTotallyScrolled(targetElement) {\n  return targetElement ? targetElement.scrollHeight - targetElement.scrollTop <= targetElement.clientHeight : false;\n};\n\nvar handleScroll = function handleScroll(event, targetElement) {\n  var clientY = event.targetTouches[0].clientY - initialClientY;\n\n  if (allowTouchMove(event.target)) {\n    return false;\n  }\n\n  if (targetElement && targetElement.scrollTop === 0 && clientY > 0) {\n    // element is at the top of its scroll.\n    return preventDefault(event);\n  }\n\n  if (isTargetElementTotallyScrolled(targetElement) && clientY < 0) {\n    // element is at the bottom of its scroll.\n    return preventDefault(event);\n  }\n\n  event.stopPropagation();\n  return true;\n};\n\nexport var disableBodyScroll = function disableBodyScroll(targetElement, options) {\n  // targetElement must be provided\n  if (!targetElement) {\n    // eslint-disable-next-line no-console\n    console.error('disableBodyScroll unsuccessful - targetElement must be provided when calling disableBodyScroll on IOS devices.');\n    return;\n  }\n\n  // disableBodyScroll must not have been called on this targetElement before\n  if (locks.some(function (lock) {\n    return lock.targetElement === targetElement;\n  })) {\n    return;\n  }\n\n  var lock = {\n    targetElement: targetElement,\n    options: options || {}\n  };\n\n  locks = [].concat(_toConsumableArray(locks), [lock]);\n\n  if (isIosDevice) {\n    setPositionFixed();\n  } else {\n    setOverflowHidden(options);\n  }\n\n  if (isIosDevice) {\n    targetElement.ontouchstart = function (event) {\n      if (event.targetTouches.length === 1) {\n        // detect single touch.\n        initialClientY = event.targetTouches[0].clientY;\n      }\n    };\n    targetElement.ontouchmove = function (event) {\n      if (event.targetTouches.length === 1) {\n        // detect single touch.\n        handleScroll(event, targetElement);\n      }\n    };\n\n    if (!documentListenerAdded) {\n      document.addEventListener('touchmove', preventDefault, hasPassiveEvents ? { passive: false } : undefined);\n      documentListenerAdded = true;\n    }\n  }\n};\n\nexport var clearAllBodyScrollLocks = function clearAllBodyScrollLocks() {\n  if (isIosDevice) {\n    // Clear all locks ontouchstart/ontouchmove handlers, and the references.\n    locks.forEach(function (lock) {\n      lock.targetElement.ontouchstart = null;\n      lock.targetElement.ontouchmove = null;\n    });\n\n    if (documentListenerAdded) {\n      document.removeEventListener('touchmove', preventDefault, hasPassiveEvents ? { passive: false } : undefined);\n      documentListenerAdded = false;\n    }\n\n    // Reset initial clientY.\n    initialClientY = -1;\n  }\n\n  if (isIosDevice) {\n    restorePositionSetting();\n  } else {\n    restoreOverflowSetting();\n  }\n\n  locks = [];\n};\n\nexport var enableBodyScroll = function enableBodyScroll(targetElement) {\n  if (!targetElement) {\n    // eslint-disable-next-line no-console\n    console.error('enableBodyScroll unsuccessful - targetElement must be provided when calling enableBodyScroll on IOS devices.');\n    return;\n  }\n\n  locks = locks.filter(function (lock) {\n    return lock.targetElement !== targetElement;\n  });\n\n  if (isIosDevice) {\n    targetElement.ontouchstart = null;\n    targetElement.ontouchmove = null;\n\n    if (documentListenerAdded && locks.length === 0) {\n      document.removeEventListener('touchmove', preventDefault, hasPassiveEvents ? { passive: false } : undefined);\n      documentListenerAdded = false;\n    }\n  }\n\n  if (isIosDevice) {\n    restorePositionSetting();\n  } else {\n    restoreOverflowSetting();\n  }\n};\n\n","function resolveElements(elements, selectorCache) {\n    var _a;\n    if (typeof elements === \"string\") {\n        if (selectorCache) {\n            (_a = selectorCache[elements]) !== null && _a !== void 0 ? _a : (selectorCache[elements] = document.querySelectorAll(elements));\n            elements = selectorCache[elements];\n        }\n        else {\n            elements = document.querySelectorAll(elements);\n        }\n    }\n    else if (elements instanceof Element) {\n        elements = [elements];\n    }\n    /**\n     * Return an empty array\n     */\n    return Array.from(elements || []);\n}\n\nexport { resolveElements };\n","const isFunction = (value) => typeof value === \"function\";\n\nexport { isFunction };\n","import { resolveElements } from '../utils/resolve-elements.es.js';\nimport { isFunction } from '@motionone/utils';\n\nconst thresholds = {\n    any: 0,\n    all: 1,\n};\nfunction inView(elementOrSelector, onStart, { root, margin: rootMargin, amount = \"any\" } = {}) {\n    /**\n     * If this browser doesn't support IntersectionObserver, return a dummy stop function.\n     * Default triggering of onStart is tricky - it could be used for starting/stopping\n     * videos, lazy loading content etc. We could provide an option to enable a fallback, or\n     * provide a fallback callback option.\n     */\n    if (typeof IntersectionObserver === \"undefined\") {\n        return () => { };\n    }\n    const elements = resolveElements(elementOrSelector);\n    const activeIntersections = new WeakMap();\n    const onIntersectionChange = (entries) => {\n        entries.forEach((entry) => {\n            const onEnd = activeIntersections.get(entry.target);\n            /**\n             * If there's no change to the intersection, we don't need to\n             * do anything here.\n             */\n            if (entry.isIntersecting === Boolean(onEnd))\n                return;\n            if (entry.isIntersecting) {\n                const newOnEnd = onStart(entry);\n                if (isFunction(newOnEnd)) {\n                    activeIntersections.set(entry.target, newOnEnd);\n                }\n                else {\n                    observer.unobserve(entry.target);\n                }\n            }\n            else if (onEnd) {\n                onEnd(entry);\n                activeIntersections.delete(entry.target);\n            }\n        });\n    };\n    const observer = new IntersectionObserver(onIntersectionChange, {\n        root,\n        rootMargin,\n        threshold: typeof amount === \"number\" ? amount : thresholds[amount],\n    });\n    elements.forEach((element) => observer.observe(element));\n    return () => observer.disconnect();\n}\n\nexport { inView };\n","const defaults = {\n    duration: 0.3,\n    delay: 0,\n    endDelay: 0,\n    repeat: 0,\n    easing: \"ease\",\n};\n\nexport { defaults };\n","const time = {\n    ms: (seconds) => seconds * 1000,\n    s: (milliseconds) => milliseconds / 1000,\n};\n\nexport { time };\n","const noop = () => { };\nconst noopReturn = (v) => v;\n\nexport { noop, noopReturn };\n","function stopAnimation(animation, needsCommit = true) {\n    if (!animation || animation.playState === \"finished\")\n        return;\n    // Suppress error thrown by WAAPI\n    try {\n        if (animation.stop) {\n            animation.stop();\n        }\n        else {\n            needsCommit && animation.commitStyles();\n            animation.cancel();\n        }\n    }\n    catch (e) { }\n}\n\nexport { stopAnimation };\n","import { defaults, noop, time } from '@motionone/utils';\nimport { stopAnimation } from './stop-animation.es.js';\n\nconst createAnimation = (factory) => factory();\nconst withControls = (animationFactory, options, duration = defaults.duration) => {\n    return new Proxy({\n        animations: animationFactory.map(createAnimation).filter(Boolean),\n        duration,\n        options,\n    }, controls);\n};\n/**\n * TODO:\n * Currently this returns the first animation, ideally it would return\n * the first active animation.\n */\nconst getActiveAnimation = (state) => state.animations[0];\nconst controls = {\n    get: (target, key) => {\n        const activeAnimation = getActiveAnimation(target);\n        switch (key) {\n            case \"duration\":\n                return target.duration;\n            case \"currentTime\":\n                return time.s((activeAnimation === null || activeAnimation === void 0 ? void 0 : activeAnimation[key]) || 0);\n            case \"playbackRate\":\n            case \"playState\":\n                return activeAnimation === null || activeAnimation === void 0 ? void 0 : activeAnimation[key];\n            case \"finished\":\n                if (!target.finished) {\n                    target.finished = Promise.all(target.animations.map(selectFinished)).catch(noop);\n                }\n                return target.finished;\n            case \"stop\":\n                return () => {\n                    target.animations.forEach((animation) => stopAnimation(animation));\n                };\n            case \"forEachNative\":\n                /**\n                 * This is for internal use only, fire a callback for each\n                 * underlying animation.\n                 */\n                return (callback) => {\n                    target.animations.forEach((animation) => callback(animation, target));\n                };\n            default:\n                return typeof (activeAnimation === null || activeAnimation === void 0 ? void 0 : activeAnimation[key]) === \"undefined\"\n                    ? undefined\n                    : () => target.animations.forEach((animation) => animation[key]());\n        }\n    },\n    set: (target, key, value) => {\n        switch (key) {\n            case \"currentTime\":\n                value = time.ms(value);\n            case \"currentTime\":\n            case \"playbackRate\":\n                for (let i = 0; i < target.animations.length; i++) {\n                    target.animations[i][key] = value;\n                }\n                return true;\n        }\n        return false;\n    },\n};\nconst selectFinished = (animation) => animation.finished;\n\nexport { controls, withControls };\n","const isEasingGenerator = (easing) => typeof easing === \"object\" &&\n    Boolean(easing.createAnimation);\n\nexport { isEasingGenerator };\n","const isNumber = (value) => typeof value === \"number\";\n\nexport { isNumber };\n","import { isNumber } from './is-number.es.js';\n\nconst isEasingList = (easing) => Array.isArray(easing) && !isNumber(easing[0]);\n\nexport { isEasingList };\n","const mix = (min, max, progress) => -progress * min + progress * max + min;\n\nexport { mix };\n","const progress = (min, max, value) => max - min === 0 ? 1 : (value - min) / (max - min);\n\nexport { progress };\n","import { mix } from './mix.es.js';\nimport { progress } from './progress.es.js';\n\nfunction fillOffset(offset, remaining) {\n    const min = offset[offset.length - 1];\n    for (let i = 1; i <= remaining; i++) {\n        const offsetProgress = progress(0, remaining, i);\n        offset.push(mix(min, 1, offsetProgress));\n    }\n}\nfunction defaultOffset(length) {\n    const offset = [0];\n    fillOffset(offset, length - 1);\n    return offset;\n}\n\nexport { defaultOffset, fillOffset };\n","const clamp = (min, max, v) => Math.min(Math.max(v, min), max);\n\nexport { clamp };\n","import { mix } from './mix.es.js';\nimport { noopReturn } from './noop.es.js';\nimport { fillOffset, defaultOffset } from './offset.es.js';\nimport { progress } from './progress.es.js';\nimport { getEasingForSegment } from './easing.es.js';\nimport { clamp } from './clamp.es.js';\n\nfunction interpolate(output, input = defaultOffset(output.length), easing = noopReturn) {\n    const length = output.length;\n    /**\n     * If the input length is lower than the output we\n     * fill the input to match. This currently assumes the input\n     * is an animation progress value so is a good candidate for\n     * moving outside the function.\n     */\n    const remainder = length - input.length;\n    remainder > 0 && fillOffset(input, remainder);\n    return (t) => {\n        let i = 0;\n        for (; i < length - 2; i++) {\n            if (t < input[i + 1])\n                break;\n        }\n        let progressInRange = clamp(0, 1, progress(input[i], input[i + 1], t));\n        const segmentEasing = getEasingForSegment(easing, i);\n        progressInRange = segmentEasing(progressInRange);\n        return mix(output[i], output[i + 1], progressInRange);\n    };\n}\n\nexport { interpolate };\n","import { isEasingList } from './is-easing-list.es.js';\nimport { wrap } from './wrap.es.js';\n\nfunction getEasingForSegment(easing, i) {\n    return isEasingList(easing)\n        ? easing[wrap(0, easing.length, i)]\n        : easing;\n}\n\nexport { getEasingForSegment };\n","const wrap = (min, max, v) => {\n    const rangeSize = max - min;\n    return ((((v - min) % rangeSize) + rangeSize) % rangeSize) + min;\n};\n\nexport { wrap };\n","import { noopReturn } from '@motionone/utils';\n\n/*\n  Bezier function generator\n\n  This has been modified from Gaëtan Renaudeau's BezierEasing\n  https://github.com/gre/bezier-easing/blob/master/src/index.js\n  https://github.com/gre/bezier-easing/blob/master/LICENSE\n  \n  I've removed the newtonRaphsonIterate algo because in benchmarking it\n  wasn't noticiably faster than binarySubdivision, indeed removing it\n  usually improved times, depending on the curve.\n\n  I also removed the lookup table, as for the added bundle size and loop we're\n  only cutting ~4 or so subdivision iterations. I bumped the max iterations up\n  to 12 to compensate and this still tended to be faster for no perceivable\n  loss in accuracy.\n\n  Usage\n    const easeOut = cubicBezier(.17,.67,.83,.67);\n    const x = easeOut(0.5); // returns 0.627...\n*/\n// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.\nconst calcBezier = (t, a1, a2) => (((1.0 - 3.0 * a2 + 3.0 * a1) * t + (3.0 * a2 - 6.0 * a1)) * t + 3.0 * a1) * t;\nconst subdivisionPrecision = 0.0000001;\nconst subdivisionMaxIterations = 12;\nfunction binarySubdivide(x, lowerBound, upperBound, mX1, mX2) {\n    let currentX;\n    let currentT;\n    let i = 0;\n    do {\n        currentT = lowerBound + (upperBound - lowerBound) / 2.0;\n        currentX = calcBezier(currentT, mX1, mX2) - x;\n        if (currentX > 0.0) {\n            upperBound = currentT;\n        }\n        else {\n            lowerBound = currentT;\n        }\n    } while (Math.abs(currentX) > subdivisionPrecision &&\n        ++i < subdivisionMaxIterations);\n    return currentT;\n}\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n    // If this is a linear gradient, return linear easing\n    if (mX1 === mY1 && mX2 === mY2)\n        return noopReturn;\n    const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);\n    // If animation is at start/end, return t without easing\n    return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n}\n\nexport { cubicBezier };\n","import { clamp } from '@motionone/utils';\n\nconst steps = (steps, direction = \"end\") => (progress) => {\n    progress =\n        direction === \"end\"\n            ? Math.min(progress, 0.999)\n            : Math.max(progress, 0.001);\n    const expanded = progress * steps;\n    const rounded = direction === \"end\" ? Math.floor(expanded) : Math.ceil(expanded);\n    return clamp(0, 1, rounded / steps);\n};\n\nexport { steps };\n","import { isNumber } from './is-number.es.js';\n\nconst isCubicBezier = (easing) => Array.isArray(easing) && isNumber(easing[0]);\n\nexport { isCubicBezier };\n","import { cubicBezier, steps } from '@motionone/easing';\nimport { isFunction, isCubicBezier, noopReturn } from '@motionone/utils';\n\nconst namedEasings = {\n    ease: cubicBezier(0.25, 0.1, 0.25, 1.0),\n    \"ease-in\": cubicBezier(0.42, 0.0, 1.0, 1.0),\n    \"ease-in-out\": cubicBezier(0.42, 0.0, 0.58, 1.0),\n    \"ease-out\": cubicBezier(0.0, 0.0, 0.58, 1.0),\n};\nconst functionArgsRegex = /\\((.*?)\\)/;\nfunction getEasingFunction(definition) {\n    // If already an easing function, return\n    if (isFunction(definition))\n        return definition;\n    // If an easing curve definition, return bezier function\n    if (isCubicBezier(definition))\n        return cubicBezier(...definition);\n    // If we have a predefined easing function, return\n    if (namedEasings[definition])\n        return namedEasings[definition];\n    // If this is a steps function, attempt to create easing curve\n    if (definition.startsWith(\"steps\")) {\n        const args = functionArgsRegex.exec(definition);\n        if (args) {\n            const argsArray = args[1].split(\",\");\n            return steps(parseFloat(argsArray[0]), argsArray[1].trim());\n        }\n    }\n    return noopReturn;\n}\n\nexport { getEasingFunction };\n","import { noopReturn, defaults, isEasingGenerator, isEasingList, interpolate } from '@motionone/utils';\nimport { getEasingFunction } from './utils/easing.es.js';\n\nclass Animation {\n    constructor(output, keyframes = [0, 1], { easing, duration: initialDuration = defaults.duration, delay = defaults.delay, endDelay = defaults.endDelay, repeat = defaults.repeat, offset, direction = \"normal\", } = {}) {\n        this.startTime = null;\n        this.rate = 1;\n        this.t = 0;\n        this.cancelTimestamp = null;\n        this.easing = noopReturn;\n        this.duration = 0;\n        this.totalDuration = 0;\n        this.repeat = 0;\n        this.playState = \"idle\";\n        this.finished = new Promise((resolve, reject) => {\n            this.resolve = resolve;\n            this.reject = reject;\n        });\n        easing = easing || defaults.easing;\n        if (isEasingGenerator(easing)) {\n            const custom = easing.createAnimation(keyframes);\n            easing = custom.easing;\n            keyframes = custom.keyframes || keyframes;\n            initialDuration = custom.duration || initialDuration;\n        }\n        this.repeat = repeat;\n        this.easing = isEasingList(easing) ? noopReturn : getEasingFunction(easing);\n        this.updateDuration(initialDuration);\n        const interpolate$1 = interpolate(keyframes, offset, isEasingList(easing) ? easing.map(getEasingFunction) : noopReturn);\n        this.tick = (timestamp) => {\n            var _a;\n            // TODO: Temporary fix for OptionsResolver typing\n            delay = delay;\n            let t = 0;\n            if (this.pauseTime !== undefined) {\n                t = this.pauseTime;\n            }\n            else {\n                t = (timestamp - this.startTime) * this.rate;\n            }\n            this.t = t;\n            // Convert to seconds\n            t /= 1000;\n            // Rebase on delay\n            t = Math.max(t - delay, 0);\n            /**\n             * If this animation has finished, set the current time\n             * to the total duration.\n             */\n            if (this.playState === \"finished\" && this.pauseTime === undefined) {\n                t = this.totalDuration;\n            }\n            /**\n             * Get the current progress (0-1) of the animation. If t is >\n             * than duration we'll get values like 2.5 (midway through the\n             * third iteration)\n             */\n            const progress = t / this.duration;\n            // TODO progress += iterationStart\n            /**\n             * Get the current iteration (0 indexed). For instance the floor of\n             * 2.5 is 2.\n             */\n            let currentIteration = Math.floor(progress);\n            /**\n             * Get the current progress of the iteration by taking the remainder\n             * so 2.5 is 0.5 through iteration 2\n             */\n            let iterationProgress = progress % 1.0;\n            if (!iterationProgress && progress >= 1) {\n                iterationProgress = 1;\n            }\n            /**\n             * If iteration progress is 1 we count that as the end\n             * of the previous iteration.\n             */\n            iterationProgress === 1 && currentIteration--;\n            /**\n             * Reverse progress if we're not running in \"normal\" direction\n             */\n            const iterationIsOdd = currentIteration % 2;\n            if (direction === \"reverse\" ||\n                (direction === \"alternate\" && iterationIsOdd) ||\n                (direction === \"alternate-reverse\" && !iterationIsOdd)) {\n                iterationProgress = 1 - iterationProgress;\n            }\n            const p = t >= this.totalDuration ? 1 : Math.min(iterationProgress, 1);\n            const latest = interpolate$1(this.easing(p));\n            output(latest);\n            const isAnimationFinished = this.pauseTime === undefined &&\n                (this.playState === \"finished\" || t >= this.totalDuration + endDelay);\n            if (isAnimationFinished) {\n                this.playState = \"finished\";\n                (_a = this.resolve) === null || _a === void 0 ? void 0 : _a.call(this, latest);\n            }\n            else if (this.playState !== \"idle\") {\n                this.frameRequestId = requestAnimationFrame(this.tick);\n            }\n        };\n        this.play();\n    }\n    play() {\n        const now = performance.now();\n        this.playState = \"running\";\n        if (this.pauseTime !== undefined) {\n            this.startTime = now - this.pauseTime;\n        }\n        else if (!this.startTime) {\n            this.startTime = now;\n        }\n        this.cancelTimestamp = this.startTime;\n        this.pauseTime = undefined;\n        this.frameRequestId = requestAnimationFrame(this.tick);\n    }\n    pause() {\n        this.playState = \"paused\";\n        this.pauseTime = this.t;\n    }\n    finish() {\n        this.playState = \"finished\";\n        this.tick(0);\n    }\n    stop() {\n        var _a;\n        this.playState = \"idle\";\n        if (this.frameRequestId !== undefined) {\n            cancelAnimationFrame(this.frameRequestId);\n        }\n        (_a = this.reject) === null || _a === void 0 ? void 0 : _a.call(this, false);\n    }\n    cancel() {\n        this.stop();\n        this.tick(this.cancelTimestamp);\n    }\n    reverse() {\n        this.rate *= -1;\n    }\n    commitStyles() { }\n    updateDuration(duration) {\n        this.duration = duration;\n        this.totalDuration = duration * (this.repeat + 1);\n    }\n    get currentTime() {\n        return this.t;\n    }\n    set currentTime(t) {\n        if (this.pauseTime !== undefined || this.rate === 0) {\n            this.pauseTime = t;\n        }\n        else {\n            this.startTime = performance.now() - t / this.rate;\n        }\n    }\n    get playbackRate() {\n        return this.rate;\n    }\n    set playbackRate(rate) {\n        this.rate = rate;\n    }\n}\n\nexport { Animation };\n","/**\n * The MotionValue tracks the state of a single animatable\n * value. Currently, updatedAt and current are unused. The\n * long term idea is to use this to minimise the number\n * of DOM reads, and to abstract the DOM interactions here.\n */\nclass MotionValue {\n    setAnimation(animation) {\n        this.animation = animation;\n        animation === null || animation === void 0 ? void 0 : animation.finished.then(() => this.clearAnimation()).catch(() => { });\n    }\n    clearAnimation() {\n        this.animation = this.generator = undefined;\n    }\n}\n\nexport { MotionValue };\n","import { MotionValue } from '@motionone/types';\n\nconst data = new WeakMap();\nfunction getAnimationData(element) {\n    if (!data.has(element)) {\n        data.set(element, {\n            transforms: [],\n            values: new Map(),\n        });\n    }\n    return data.get(element);\n}\nfunction getMotionValue(motionValues, name) {\n    if (!motionValues.has(name)) {\n        motionValues.set(name, new MotionValue());\n    }\n    return motionValues.get(name);\n}\n\nexport { getAnimationData, getMotionValue };\n","import { noopReturn, addUniqueItem } from '@motionone/utils';\nimport { getAnimationData } from '../data.es.js';\n\n/**\n * A list of all transformable axes. We'll use this list to generated a version\n * of each axes for each transform.\n */\nconst axes = [\"\", \"X\", \"Y\", \"Z\"];\n/**\n * An ordered array of each transformable value. By default, transform values\n * will be sorted to this order.\n */\nconst order = [\"translate\", \"scale\", \"rotate\", \"skew\"];\nconst transformAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n};\nconst rotation = {\n    syntax: \"<angle>\",\n    initialValue: \"0deg\",\n    toDefaultUnit: (v) => v + \"deg\",\n};\nconst baseTransformProperties = {\n    translate: {\n        syntax: \"<length-percentage>\",\n        initialValue: \"0px\",\n        toDefaultUnit: (v) => v + \"px\",\n    },\n    rotate: rotation,\n    scale: {\n        syntax: \"<number>\",\n        initialValue: 1,\n        toDefaultUnit: noopReturn,\n    },\n    skew: rotation,\n};\nconst transformDefinitions = new Map();\nconst asTransformCssVar = (name) => `--motion-${name}`;\n/**\n * Generate a list of every possible transform key\n */\nconst transforms = [\"x\", \"y\", \"z\"];\norder.forEach((name) => {\n    axes.forEach((axis) => {\n        transforms.push(name + axis);\n        transformDefinitions.set(asTransformCssVar(name + axis), baseTransformProperties[name]);\n    });\n});\n/**\n * A function to use with Array.sort to sort transform keys by their default order.\n */\nconst compareTransformOrder = (a, b) => transforms.indexOf(a) - transforms.indexOf(b);\n/**\n * Provide a quick way to check if a string is the name of a transform\n */\nconst transformLookup = new Set(transforms);\nconst isTransform = (name) => transformLookup.has(name);\nconst addTransformToElement = (element, name) => {\n    // Map x to translateX etc\n    if (transformAlias[name])\n        name = transformAlias[name];\n    const { transforms } = getAnimationData(element);\n    addUniqueItem(transforms, name);\n    /**\n     * TODO: An optimisation here could be to cache the transform in element data\n     * and only update if this has changed.\n     */\n    element.style.transform = buildTransformTemplate(transforms);\n};\nconst buildTransformTemplate = (transforms) => transforms\n    .sort(compareTransformOrder)\n    .reduce(transformListToString, \"\")\n    .trim();\nconst transformListToString = (template, name) => `${template} ${name}(var(${asTransformCssVar(name)}))`;\n\nexport { addTransformToElement, asTransformCssVar, axes, buildTransformTemplate, compareTransformOrder, isTransform, transformAlias, transformDefinitions };\n","import { transformDefinitions } from './transforms.es.js';\n\nconst isCssVar = (name) => name.startsWith(\"--\");\nconst registeredProperties = new Set();\nfunction registerCssVariable(name) {\n    if (registeredProperties.has(name))\n        return;\n    registeredProperties.add(name);\n    try {\n        const { syntax, initialValue } = transformDefinitions.has(name)\n            ? transformDefinitions.get(name)\n            : {};\n        CSS.registerProperty({\n            name,\n            inherits: false,\n            syntax,\n            initialValue,\n        });\n    }\n    catch (e) { }\n}\n\nexport { isCssVar, registerCssVariable, registeredProperties };\n","const testAnimation = (keyframes, options) => document.createElement(\"div\").animate(keyframes, options);\nconst featureTests = {\n    cssRegisterProperty: () => typeof CSS !== \"undefined\" &&\n        Object.hasOwnProperty.call(CSS, \"registerProperty\"),\n    waapi: () => Object.hasOwnProperty.call(Element.prototype, \"animate\"),\n    partialKeyframes: () => {\n        try {\n            testAnimation({ opacity: [1] });\n        }\n        catch (e) {\n            return false;\n        }\n        return true;\n    },\n    finished: () => Boolean(testAnimation({ opacity: [0, 1] }, { duration: 0.001 }).finished),\n    linearEasing: () => {\n        try {\n            testAnimation({ opacity: 0 }, { easing: \"linear(0, 1)\" });\n        }\n        catch (e) {\n            return false;\n        }\n        return true;\n    },\n};\nconst results = {};\nconst supports = {};\nfor (const key in featureTests) {\n    supports[key] = () => {\n        if (results[key] === undefined)\n            results[key] = featureTests[key]();\n        return results[key];\n    };\n}\n\nexport { supports };\n","import { isFunction, defaults, isCubicBezier, progress } from '@motionone/utils';\nimport { supports } from './feature-detection.es.js';\n\n// Create a linear easing point for every x second\nconst resolution = 0.015;\nconst generateLinearEasingPoints = (easing, duration) => {\n    let points = \"\";\n    const numPoints = Math.round(duration / resolution);\n    for (let i = 0; i < numPoints; i++) {\n        points += easing(progress(0, numPoints - 1, i)) + \", \";\n    }\n    return points.substring(0, points.length - 2);\n};\nconst convertEasing = (easing, duration) => {\n    if (isFunction(easing)) {\n        return supports.linearEasing()\n            ? `linear(${generateLinearEasingPoints(easing, duration)})`\n            : defaults.easing;\n    }\n    else {\n        return isCubicBezier(easing) ? cubicBezierAsString(easing) : easing;\n    }\n};\nconst cubicBezierAsString = ([a, b, c, d]) => `cubic-bezier(${a}, ${b}, ${c}, ${d})`;\n\nexport { convertEasing, cubicBezierAsString, generateLinearEasingPoints };\n","import { isTransform, asTransformCssVar, transformAlias } from './transforms.es.js';\n\nfunction getStyleName(key) {\n    if (transformAlias[key])\n        key = transformAlias[key];\n    return isTransform(key) ? asTransformCssVar(key) : key;\n}\n\nexport { getStyleName };\n","import { isCssVar } from './utils/css-var.es.js';\nimport { getStyleName } from './utils/get-style-name.es.js';\nimport { transformDefinitions } from './utils/transforms.es.js';\n\nconst style = {\n    get: (element, name) => {\n        name = getStyleName(name);\n        let value = isCssVar(name)\n            ? element.style.getPropertyValue(name)\n            : getComputedStyle(element)[name];\n        if (!value && value !== 0) {\n            const definition = transformDefinitions.get(name);\n            if (definition)\n                value = definition.initialValue;\n        }\n        return value;\n    },\n    set: (element, name, value) => {\n        name = getStyleName(name);\n        if (isCssVar(name)) {\n            element.style.setProperty(name, value);\n        }\n        else {\n            element.style[name] = value;\n        }\n    },\n};\n\nexport { style };\n","const isString = (value) => typeof value === \"string\";\n\nexport { isString };\n","import { getAnimationData, getMotionValue } from './data.es.js';\nimport { isCssVar, registerCssVariable } from './utils/css-var.es.js';\nimport { defaults, isEasingGenerator, isFunction, isEasingList, isNumber, time, noop } from '@motionone/utils';\nimport { isTransform, addTransformToElement, transformDefinitions } from './utils/transforms.es.js';\nimport { convertEasing } from './utils/easing.es.js';\nimport { supports } from './utils/feature-detection.es.js';\nimport { hydrateKeyframes, keyframesList } from './utils/keyframes.es.js';\nimport { style } from './style.es.js';\nimport { getStyleName } from './utils/get-style-name.es.js';\nimport { stopAnimation } from './utils/stop-animation.es.js';\nimport { getUnitConverter } from './utils/get-unit.es.js';\n\nfunction getDevToolsRecord() {\n    return window.__MOTION_DEV_TOOLS_RECORD;\n}\nfunction animateStyle(element, key, keyframesDefinition, options = {}, AnimationPolyfill) {\n    const record = getDevToolsRecord();\n    const isRecording = options.record !== false && record;\n    let animation;\n    let { duration = defaults.duration, delay = defaults.delay, endDelay = defaults.endDelay, repeat = defaults.repeat, easing = defaults.easing, persist = false, direction, offset, allowWebkitAcceleration = false, } = options;\n    const data = getAnimationData(element);\n    const valueIsTransform = isTransform(key);\n    let canAnimateNatively = supports.waapi();\n    /**\n     * If this is an individual transform, we need to map its\n     * key to a CSS variable and update the element's transform style\n     */\n    valueIsTransform && addTransformToElement(element, key);\n    const name = getStyleName(key);\n    const motionValue = getMotionValue(data.values, name);\n    /**\n     * Get definition of value, this will be used to convert numerical\n     * keyframes into the default value type.\n     */\n    const definition = transformDefinitions.get(name);\n    /**\n     * Stop the current animation, if any. Because this will trigger\n     * commitStyles (DOM writes) and we might later trigger DOM reads,\n     * this is fired now and we return a factory function to create\n     * the actual animation that can get called in batch,\n     */\n    stopAnimation(motionValue.animation, !(isEasingGenerator(easing) && motionValue.generator) &&\n        options.record !== false);\n    /**\n     * Batchable factory function containing all DOM reads.\n     */\n    return () => {\n        const readInitialValue = () => { var _a, _b; return (_b = (_a = style.get(element, name)) !== null && _a !== void 0 ? _a : definition === null || definition === void 0 ? void 0 : definition.initialValue) !== null && _b !== void 0 ? _b : 0; };\n        /**\n         * Replace null values with the previous keyframe value, or read\n         * it from the DOM if it's the first keyframe.\n         */\n        let keyframes = hydrateKeyframes(keyframesList(keyframesDefinition), readInitialValue);\n        /**\n         * Detect unit type of keyframes.\n         */\n        const toUnit = getUnitConverter(keyframes, definition);\n        if (isEasingGenerator(easing)) {\n            const custom = easing.createAnimation(keyframes, key !== \"opacity\", readInitialValue, name, motionValue);\n            easing = custom.easing;\n            keyframes = custom.keyframes || keyframes;\n            duration = custom.duration || duration;\n        }\n        /**\n         * If this is a CSS variable we need to register it with the browser\n         * before it can be animated natively. We also set it with setProperty\n         * rather than directly onto the element.style object.\n         */\n        if (isCssVar(name)) {\n            if (supports.cssRegisterProperty()) {\n                registerCssVariable(name);\n            }\n            else {\n                canAnimateNatively = false;\n            }\n        }\n        /**\n         * If we've been passed a custom easing function, and this browser\n         * does **not** support linear() easing, and the value is a transform\n         * (and thus a pure number) we can still support the custom easing\n         * by falling back to the animation polyfill.\n         */\n        if (valueIsTransform &&\n            !supports.linearEasing() &&\n            (isFunction(easing) || (isEasingList(easing) && easing.some(isFunction)))) {\n            canAnimateNatively = false;\n        }\n        /**\n         * If we can animate this value with WAAPI, do so.\n         */\n        if (canAnimateNatively) {\n            /**\n             * Convert numbers to default value types. Currently this only supports\n             * transforms but it could also support other value types.\n             */\n            if (definition) {\n                keyframes = keyframes.map((value) => isNumber(value) ? definition.toDefaultUnit(value) : value);\n            }\n            /**\n             * If this browser doesn't support partial/implicit keyframes we need to\n             * explicitly provide one.\n             */\n            if (keyframes.length === 1 &&\n                (!supports.partialKeyframes() || isRecording)) {\n                keyframes.unshift(readInitialValue());\n            }\n            const animationOptions = {\n                delay: time.ms(delay),\n                duration: time.ms(duration),\n                endDelay: time.ms(endDelay),\n                easing: !isEasingList(easing)\n                    ? convertEasing(easing, duration)\n                    : undefined,\n                direction,\n                iterations: repeat + 1,\n                fill: \"both\",\n            };\n            animation = element.animate({\n                [name]: keyframes,\n                offset,\n                easing: isEasingList(easing)\n                    ? easing.map((thisEasing) => convertEasing(thisEasing, duration))\n                    : undefined,\n            }, animationOptions);\n            /**\n             * Polyfill finished Promise in browsers that don't support it\n             */\n            if (!animation.finished) {\n                animation.finished = new Promise((resolve, reject) => {\n                    animation.onfinish = resolve;\n                    animation.oncancel = reject;\n                });\n            }\n            const target = keyframes[keyframes.length - 1];\n            animation.finished\n                .then(() => {\n                if (persist)\n                    return;\n                // Apply styles to target\n                style.set(element, name, target);\n                // Ensure fill modes don't persist\n                animation.cancel();\n            })\n                .catch(noop);\n            /**\n             * This forces Webkit to run animations on the main thread by exploiting\n             * this condition:\n             * https://trac.webkit.org/browser/webkit/trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp?rev=281238#L1099\n             *\n             * This fixes Webkit's timing bugs, like accelerated animations falling\n             * out of sync with main thread animations and massive delays in starting\n             * accelerated animations in WKWebView.\n             */\n            if (!allowWebkitAcceleration)\n                animation.playbackRate = 1.000001;\n            /**\n             * If we can't animate the value natively then we can fallback to the numbers-only\n             * polyfill for transforms.\n             */\n        }\n        else if (AnimationPolyfill && valueIsTransform) {\n            /**\n             * If any keyframe is a string (because we measured it from the DOM), we need to convert\n             * it into a number before passing to the Animation polyfill.\n             */\n            keyframes = keyframes.map((value) => typeof value === \"string\" ? parseFloat(value) : value);\n            /**\n             * If we only have a single keyframe, we need to create an initial keyframe by reading\n             * the current value from the DOM.\n             */\n            if (keyframes.length === 1) {\n                keyframes.unshift(parseFloat(readInitialValue()));\n            }\n            animation = new AnimationPolyfill((latest) => {\n                style.set(element, name, toUnit ? toUnit(latest) : latest);\n            }, keyframes, Object.assign(Object.assign({}, options), { duration,\n                easing }));\n        }\n        else {\n            const target = keyframes[keyframes.length - 1];\n            style.set(element, name, definition && isNumber(target)\n                ? definition.toDefaultUnit(target)\n                : target);\n        }\n        if (isRecording) {\n            record(element, key, keyframes, {\n                duration,\n                delay: delay,\n                easing,\n                repeat,\n                offset,\n            }, \"motion-one\");\n        }\n        motionValue.setAnimation(animation);\n        return animation;\n    };\n}\n\nexport { animateStyle };\n","function addUniqueItem(array, item) {\n    array.indexOf(item) === -1 && array.push(item);\n}\nfunction removeItem(arr, item) {\n    const index = arr.indexOf(item);\n    index > -1 && arr.splice(index, 1);\n}\n\nexport { addUniqueItem, removeItem };\n","function hydrateKeyframes(keyframes, readInitialValue) {\n    for (let i = 0; i < keyframes.length; i++) {\n        if (keyframes[i] === null) {\n            keyframes[i] = i ? keyframes[i - 1] : readInitialValue();\n        }\n    }\n    return keyframes;\n}\nconst keyframesList = (keyframes) => Array.isArray(keyframes) ? keyframes : [keyframes];\n\nexport { hydrateKeyframes, keyframesList };\n","import { noopReturn, isString } from '@motionone/utils';\n\nfunction getUnitConverter(keyframes, definition) {\n    var _a;\n    let toUnit = (definition === null || definition === void 0 ? void 0 : definition.toDefaultUnit) || noopReturn;\n    const finalKeyframe = keyframes[keyframes.length - 1];\n    if (isString(finalKeyframe)) {\n        const unit = ((_a = finalKeyframe.match(/(-?[\\d.]+)([a-z%]*)/)) === null || _a === void 0 ? void 0 : _a[2]) || \"\";\n        if (unit)\n            toUnit = (value) => value + unit;\n    }\n    return toUnit;\n}\n\nexport { getUnitConverter };\n","const getOptions = (options, key) => \n/**\n * TODO: Make test for this\n * Always return a new object otherwise delay is overwritten by results of stagger\n * and this results in no stagger\n */\noptions[key] ? Object.assign(Object.assign({}, options), options[key]) : Object.assign({}, options);\n\nexport { getOptions };\n","import { isNumber, isFunction } from '@motionone/utils';\nimport { getEasingFunction } from '@motionone/animation';\n\nfunction stagger(duration = 0.1, { start = 0, from = 0, easing } = {}) {\n    return (i, total) => {\n        const fromIndex = isNumber(from) ? from : getFromIndex(from, total);\n        const distance = Math.abs(fromIndex - i);\n        let delay = duration * distance;\n        if (easing) {\n            const maxDelay = total * duration;\n            const easingFunction = getEasingFunction(easing);\n            delay = easingFunction(delay / maxDelay) * maxDelay;\n        }\n        return start + delay;\n    };\n}\nfunction getFromIndex(from, total) {\n    if (from === \"first\") {\n        return 0;\n    }\n    else {\n        const lastIndex = total - 1;\n        return from === \"last\" ? lastIndex : lastIndex / 2;\n    }\n}\nfunction resolveOption(option, i, total) {\n    return isFunction(option) ? option(i, total) : option;\n}\n\nexport { getFromIndex, resolveOption, stagger };\n","import { Animation } from '@motionone/animation';\nimport { createAnimate } from './create-animate.es.js';\n\nconst animate = createAnimate(Animation);\n\nexport { animate };\n","import { invariant } from 'hey-listen';\nimport { animateStyle } from './animate-style.es.js';\nimport { getOptions } from './utils/options.es.js';\nimport { resolveElements } from '../utils/resolve-elements.es.js';\nimport { withControls } from './utils/controls.es.js';\nimport { resolveOption } from '../utils/stagger.es.js';\n\nfunction createAnimate(AnimatePolyfill) {\n    return function animate(elements, keyframes, options = {}) {\n        elements = resolveElements(elements);\n        const numElements = elements.length;\n        invariant(Boolean(numElements), \"No valid element provided.\");\n        invariant(Boolean(keyframes), \"No keyframes defined.\");\n        /**\n         * Create and start new animations\n         */\n        const animationFactories = [];\n        for (let i = 0; i < numElements; i++) {\n            const element = elements[i];\n            for (const key in keyframes) {\n                const valueOptions = getOptions(options, key);\n                valueOptions.delay = resolveOption(valueOptions.delay, i, numElements);\n                const animation = animateStyle(element, key, keyframes[key], valueOptions, AnimatePolyfill);\n                animationFactories.push(animation);\n            }\n        }\n        return withControls(animationFactories, options, \n        /**\n         * TODO:\n         * If easing is set to spring or glide, duration will be dynamically\n         * generated. Ideally we would dynamically generate this from\n         * animation.effect.getComputedTiming().duration but this isn't\n         * supported in iOS13 or our number polyfill. Perhaps it's possible\n         * to Proxy animations returned from animateStyle that has duration\n         * as a getter.\n         */\n        options.duration);\n    };\n}\n\nexport { createAnimate };\n","import { animate as animate$1, withControls } from '@motionone/dom';\nimport { isFunction } from '@motionone/utils';\nimport { Animation } from '@motionone/animation';\n\nfunction animateProgress(target, options = {}) {\n    return withControls([\n        () => {\n            const animation = new Animation(target, [0, 1], options);\n            animation.finished.catch(() => { });\n            return animation;\n        },\n    ], options, options.duration);\n}\nfunction animate(target, keyframesOrOptions, options) {\n    const factory = isFunction(target) ? animateProgress : animate$1;\n    return factory(target, keyframesOrOptions, options);\n}\n\nexport { animate, animateProgress };\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise, SuppressedError, Symbol */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n    function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n    var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n    var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n    var _, done = false;\r\n    for (var i = decorators.length - 1; i >= 0; i--) {\r\n        var context = {};\r\n        for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n        for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n        context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n        var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n        if (kind === \"accessor\") {\r\n            if (result === void 0) continue;\r\n            if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n            if (_ = accept(result.get)) descriptor.get = _;\r\n            if (_ = accept(result.set)) descriptor.set = _;\r\n            if (_ = accept(result.init)) initializers.unshift(_);\r\n        }\r\n        else if (_ = accept(result)) {\r\n            if (kind === \"field\") initializers.unshift(_);\r\n            else descriptor[key] = _;\r\n        }\r\n    }\r\n    if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n    done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n    var useValue = arguments.length > 2;\r\n    for (var i = 0; i < initializers.length; i++) {\r\n        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n    }\r\n    return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n    return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n    if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n    return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport function __addDisposableResource(env, value, async) {\r\n    if (value !== null && value !== void 0) {\r\n        if (typeof value !== \"object\") throw new TypeError(\"Object expected.\");\r\n        var dispose;\r\n        if (async) {\r\n            if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\r\n            dispose = value[Symbol.asyncDispose];\r\n        }\r\n        if (dispose === void 0) {\r\n            if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\r\n            dispose = value[Symbol.dispose];\r\n        }\r\n        if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\r\n        env.stack.push({ value: value, dispose: dispose, async: async });\r\n    }\r\n    else if (async) {\r\n        env.stack.push({ async: true });\r\n    }\r\n    return value;\r\n}\r\n\r\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n    var e = new Error(message);\r\n    return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n};\r\n\r\nexport function __disposeResources(env) {\r\n    function fail(e) {\r\n        env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\r\n        env.hasError = true;\r\n    }\r\n    function next() {\r\n        while (env.stack.length) {\r\n            var rec = env.stack.pop();\r\n            try {\r\n                var result = rec.dispose && rec.dispose.call(rec.value);\r\n                if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\r\n            }\r\n            catch (e) {\r\n                fail(e);\r\n            }\r\n        }\r\n        if (env.hasError) throw env.error;\r\n    }\r\n    return next();\r\n}\r\n\r\nexport default {\r\n    __extends,\r\n    __assign,\r\n    __rest,\r\n    __decorate,\r\n    __param,\r\n    __metadata,\r\n    __awaiter,\r\n    __generator,\r\n    __createBinding,\r\n    __exportStar,\r\n    __values,\r\n    __read,\r\n    __spread,\r\n    __spreadArrays,\r\n    __spreadArray,\r\n    __await,\r\n    __asyncGenerator,\r\n    __asyncDelegator,\r\n    __asyncValues,\r\n    __makeTemplateObject,\r\n    __importStar,\r\n    __importDefault,\r\n    __classPrivateFieldGet,\r\n    __classPrivateFieldSet,\r\n    __classPrivateFieldIn,\r\n    __addDisposableResource,\r\n    __disposeResources,\r\n};\r\n","import { resolveElements } from '../../utils/resolve-elements.es.js';\n\nconst resizeHandlers = new WeakMap();\nlet observer;\nfunction getElementSize(target, borderBoxSize) {\n    if (borderBoxSize) {\n        const { inlineSize, blockSize } = borderBoxSize[0];\n        return { width: inlineSize, height: blockSize };\n    }\n    else if (target instanceof SVGElement && \"getBBox\" in target) {\n        return target.getBBox();\n    }\n    else {\n        return {\n            width: target.offsetWidth,\n            height: target.offsetHeight,\n        };\n    }\n}\nfunction notifyTarget({ target, contentRect, borderBoxSize, }) {\n    var _a;\n    (_a = resizeHandlers.get(target)) === null || _a === void 0 ? void 0 : _a.forEach((handler) => {\n        handler({\n            target,\n            contentSize: contentRect,\n            get size() {\n                return getElementSize(target, borderBoxSize);\n            },\n        });\n    });\n}\nfunction notifyAll(entries) {\n    entries.forEach(notifyTarget);\n}\nfunction createResizeObserver() {\n    if (typeof ResizeObserver === \"undefined\")\n        return;\n    observer = new ResizeObserver(notifyAll);\n}\nfunction resizeElement(target, handler) {\n    if (!observer)\n        createResizeObserver();\n    const elements = resolveElements(target);\n    elements.forEach((element) => {\n        let elementHandlers = resizeHandlers.get(element);\n        if (!elementHandlers) {\n            elementHandlers = new Set();\n            resizeHandlers.set(element, elementHandlers);\n        }\n        elementHandlers.add(handler);\n        observer === null || observer === void 0 ? void 0 : observer.observe(element);\n    });\n    return () => {\n        elements.forEach((element) => {\n            const elementHandlers = resizeHandlers.get(element);\n            elementHandlers === null || elementHandlers === void 0 ? void 0 : elementHandlers.delete(handler);\n            if (!(elementHandlers === null || elementHandlers === void 0 ? void 0 : elementHandlers.size)) {\n                observer === null || observer === void 0 ? void 0 : observer.unobserve(element);\n            }\n        });\n    };\n}\n\nexport { resizeElement };\n","const windowCallbacks = new Set();\nlet windowResizeHandler;\nfunction createWindowResizeHandler() {\n    windowResizeHandler = () => {\n        const size = {\n            width: window.innerWidth,\n            height: window.innerHeight,\n        };\n        const info = {\n            target: window,\n            size,\n            contentSize: size,\n        };\n        windowCallbacks.forEach((callback) => callback(info));\n    };\n    window.addEventListener(\"resize\", windowResizeHandler);\n}\nfunction resizeWindow(callback) {\n    windowCallbacks.add(callback);\n    if (!windowResizeHandler)\n        createWindowResizeHandler();\n    return () => {\n        windowCallbacks.delete(callback);\n        if (!windowCallbacks.size && windowResizeHandler) {\n            windowResizeHandler = undefined;\n        }\n    };\n}\n\nexport { resizeWindow };\n","import { progress, velocityPerSecond } from '@motionone/utils';\n\n/**\n * A time in milliseconds, beyond which we consider the scroll velocity to be 0.\n */\nconst maxElapsed = 50;\nconst createAxisInfo = () => ({\n    current: 0,\n    offset: [],\n    progress: 0,\n    scrollLength: 0,\n    targetOffset: 0,\n    targetLength: 0,\n    containerLength: 0,\n    velocity: 0,\n});\nconst createScrollInfo = () => ({\n    time: 0,\n    x: createAxisInfo(),\n    y: createAxisInfo(),\n});\nconst keys = {\n    x: {\n        length: \"Width\",\n        position: \"Left\",\n    },\n    y: {\n        length: \"Height\",\n        position: \"Top\",\n    },\n};\nfunction updateAxisInfo(element, axisName, info, time) {\n    const axis = info[axisName];\n    const { length, position } = keys[axisName];\n    const prev = axis.current;\n    const prevTime = info.time;\n    axis.current = element[\"scroll\" + position];\n    axis.scrollLength = element[\"scroll\" + length] - element[\"client\" + length];\n    axis.offset.length = 0;\n    axis.offset[0] = 0;\n    axis.offset[1] = axis.scrollLength;\n    axis.progress = progress(0, axis.scrollLength, axis.current);\n    const elapsed = time - prevTime;\n    axis.velocity =\n        elapsed > maxElapsed ? 0 : velocityPerSecond(axis.current - prev, elapsed);\n}\nfunction updateScrollInfo(element, info, time) {\n    updateAxisInfo(element, \"x\", info, time);\n    updateAxisInfo(element, \"y\", info, time);\n    info.time = time;\n}\n\nexport { createScrollInfo, updateScrollInfo };\n","/*\n  Convert velocity into velocity per second\n\n  @param [number]: Unit per frame\n  @param [number]: Frame duration in ms\n*/\nfunction velocityPerSecond(velocity, frameDuration) {\n    return frameDuration ? velocity * (1000 / frameDuration) : 0;\n}\n\nexport { velocityPerSecond };\n","const ScrollOffset = {\n    Enter: [\n        [0, 1],\n        [1, 1],\n    ],\n    Exit: [\n        [0, 0],\n        [1, 0],\n    ],\n    Any: [\n        [1, 0],\n        [0, 1],\n    ],\n    All: [\n        [0, 0],\n        [1, 1],\n    ],\n};\n\nexport { ScrollOffset };\n","import { isString, isNumber } from '@motionone/utils';\n\nconst namedEdges = {\n    start: 0,\n    center: 0.5,\n    end: 1,\n};\nfunction resolveEdge(edge, length, inset = 0) {\n    let delta = 0;\n    /**\n     * If we have this edge defined as a preset, replace the definition\n     * with the numerical value.\n     */\n    if (namedEdges[edge] !== undefined) {\n        edge = namedEdges[edge];\n    }\n    /**\n     * Handle unit values\n     */\n    if (isString(edge)) {\n        const asNumber = parseFloat(edge);\n        if (edge.endsWith(\"px\")) {\n            delta = asNumber;\n        }\n        else if (edge.endsWith(\"%\")) {\n            edge = asNumber / 100;\n        }\n        else if (edge.endsWith(\"vw\")) {\n            delta = (asNumber / 100) * document.documentElement.clientWidth;\n        }\n        else if (edge.endsWith(\"vh\")) {\n            delta = (asNumber / 100) * document.documentElement.clientHeight;\n        }\n        else {\n            edge = asNumber;\n        }\n    }\n    /**\n     * If the edge is defined as a number, handle as a progress value.\n     */\n    if (isNumber(edge)) {\n        delta = length * edge;\n    }\n    return inset + delta;\n}\n\nexport { namedEdges, resolveEdge };\n","import { isNumber, isString } from '@motionone/utils';\nimport { resolveEdge, namedEdges } from './edge.es.js';\n\nconst defaultOffset = [0, 0];\nfunction resolveOffset(offset, containerLength, targetLength, targetInset) {\n    let offsetDefinition = Array.isArray(offset) ? offset : defaultOffset;\n    let targetPoint = 0;\n    let containerPoint = 0;\n    if (isNumber(offset)) {\n        /**\n         * If we're provided offset: [0, 0.5, 1] then each number x should become\n         * [x, x], so we default to the behaviour of mapping 0 => 0 of both target\n         * and container etc.\n         */\n        offsetDefinition = [offset, offset];\n    }\n    else if (isString(offset)) {\n        offset = offset.trim();\n        if (offset.includes(\" \")) {\n            offsetDefinition = offset.split(\" \");\n        }\n        else {\n            /**\n             * If we're provided a definition like \"100px\" then we want to apply\n             * that only to the top of the target point, leaving the container at 0.\n             * Whereas a named offset like \"end\" should be applied to both.\n             */\n            offsetDefinition = [offset, namedEdges[offset] ? offset : `0`];\n        }\n    }\n    targetPoint = resolveEdge(offsetDefinition[0], targetLength, targetInset);\n    containerPoint = resolveEdge(offsetDefinition[1], containerLength);\n    return targetPoint - containerPoint;\n}\n\nexport { resolveOffset };\n","import { interpolate, defaultOffset } from '@motionone/utils';\nimport { calcInset } from './inset.es.js';\nimport { ScrollOffset } from './presets.es.js';\nimport { resolveOffset } from './offset.es.js';\n\nconst point = { x: 0, y: 0 };\nfunction resolveOffsets(container, info, options) {\n    let { offset: offsetDefinition = ScrollOffset.All } = options;\n    const { target = container, axis = \"y\" } = options;\n    const lengthLabel = axis === \"y\" ? \"height\" : \"width\";\n    const inset = target !== container ? calcInset(target, container) : point;\n    /**\n     * Measure the target and container. If they're the same thing then we\n     * use the container's scrollWidth/Height as the target, from there\n     * all other calculations can remain the same.\n     */\n    const targetSize = target === container\n        ? { width: container.scrollWidth, height: container.scrollHeight }\n        : { width: target.clientWidth, height: target.clientHeight };\n    const containerSize = {\n        width: container.clientWidth,\n        height: container.clientHeight,\n    };\n    /**\n     * Reset the length of the resolved offset array rather than creating a new one.\n     * TODO: More reusable data structures for targetSize/containerSize would also be good.\n     */\n    info[axis].offset.length = 0;\n    /**\n     * Populate the offset array by resolving the user's offset definition into\n     * a list of pixel scroll offets.\n     */\n    let hasChanged = !info[axis].interpolate;\n    const numOffsets = offsetDefinition.length;\n    for (let i = 0; i < numOffsets; i++) {\n        const offset = resolveOffset(offsetDefinition[i], containerSize[lengthLabel], targetSize[lengthLabel], inset[axis]);\n        if (!hasChanged && offset !== info[axis].interpolatorOffsets[i]) {\n            hasChanged = true;\n        }\n        info[axis].offset[i] = offset;\n    }\n    /**\n     * If the pixel scroll offsets have changed, create a new interpolator function\n     * to map scroll value into a progress.\n     */\n    if (hasChanged) {\n        info[axis].interpolate = interpolate(defaultOffset(numOffsets), info[axis].offset);\n        info[axis].interpolatorOffsets = [...info[axis].offset];\n    }\n    info[axis].progress = info[axis].interpolate(info[axis].current);\n}\n\nexport { resolveOffsets };\n","function calcInset(element, container) {\n    let inset = { x: 0, y: 0 };\n    let current = element;\n    while (current && current !== container) {\n        if (current instanceof HTMLElement) {\n            inset.x += current.offsetLeft;\n            inset.y += current.offsetTop;\n            current = current.offsetParent;\n        }\n        else if (current instanceof SVGGraphicsElement && \"getBBox\" in current) {\n            const { top, left } = current.getBBox();\n            inset.x += left;\n            inset.y += top;\n            /**\n             * Assign the next parent element as the <svg /> tag.\n             */\n            while (current && current.tagName !== \"svg\") {\n                current = current.parentNode;\n            }\n        }\n    }\n    return inset;\n}\n\nexport { calcInset };\n","import { isFunction, noopReturn } from '@motionone/utils';\nimport { updateScrollInfo } from './info.es.js';\nimport { resolveOffsets } from './offsets/index.es.js';\n\nfunction measure(container, target = container, info) {\n    /**\n     * Find inset of target within scrollable container\n     */\n    info.x.targetOffset = 0;\n    info.y.targetOffset = 0;\n    if (target !== container) {\n        let node = target;\n        while (node && node != container) {\n            info.x.targetOffset += node.offsetLeft;\n            info.y.targetOffset += node.offsetTop;\n            node = node.offsetParent;\n        }\n    }\n    info.x.targetLength =\n        target === container ? target.scrollWidth : target.clientWidth;\n    info.y.targetLength =\n        target === container ? target.scrollHeight : target.clientHeight;\n    info.x.containerLength = container.clientWidth;\n    info.y.containerLength = container.clientHeight;\n}\nfunction createOnScrollHandler(element, onScroll, info, options = {}) {\n    const axis = options.axis || \"y\";\n    return {\n        measure: () => measure(element, options.target, info),\n        update: (time) => {\n            updateScrollInfo(element, info, time);\n            if (options.offset || options.target) {\n                resolveOffsets(element, info, options);\n            }\n        },\n        notify: isFunction(onScroll)\n            ? () => onScroll(info)\n            : scrubAnimation(onScroll, info[axis]),\n    };\n}\nfunction scrubAnimation(controls, axisInfo) {\n    controls.pause();\n    controls.forEachNative((animation, { easing }) => {\n        var _a, _b;\n        if (animation.updateDuration) {\n            if (!easing)\n                animation.easing = noopReturn;\n            animation.updateDuration(1);\n        }\n        else {\n            const timingOptions = { duration: 1000 };\n            if (!easing)\n                timingOptions.easing = \"linear\";\n            (_b = (_a = animation.effect) === null || _a === void 0 ? void 0 : _a.updateTiming) === null || _b === void 0 ? void 0 : _b.call(_a, timingOptions);\n        }\n    });\n    return () => {\n        controls.currentTime = axisInfo.progress;\n    };\n}\n\nexport { createOnScrollHandler };\n","import { __rest } from 'tslib';\nimport { resize } from '../resize/index.es.js';\nimport { createScrollInfo } from './info.es.js';\nimport { createOnScrollHandler } from './on-scroll-handler.es.js';\n\nconst scrollListeners = new WeakMap();\nconst resizeListeners = new WeakMap();\nconst onScrollHandlers = new WeakMap();\nconst getEventTarget = (element) => element === document.documentElement ? window : element;\nfunction scroll(onScroll, _a = {}) {\n    var { container = document.documentElement } = _a, options = __rest(_a, [\"container\"]);\n    let containerHandlers = onScrollHandlers.get(container);\n    /**\n     * Get the onScroll handlers for this container.\n     * If one isn't found, create a new one.\n     */\n    if (!containerHandlers) {\n        containerHandlers = new Set();\n        onScrollHandlers.set(container, containerHandlers);\n    }\n    /**\n     * Create a new onScroll handler for the provided callback.\n     */\n    const info = createScrollInfo();\n    const containerHandler = createOnScrollHandler(container, onScroll, info, options);\n    containerHandlers.add(containerHandler);\n    /**\n     * Check if there's a scroll event listener for this container.\n     * If not, create one.\n     */\n    if (!scrollListeners.has(container)) {\n        const listener = () => {\n            const time = performance.now();\n            for (const handler of containerHandlers)\n                handler.measure();\n            for (const handler of containerHandlers)\n                handler.update(time);\n            for (const handler of containerHandlers)\n                handler.notify();\n        };\n        scrollListeners.set(container, listener);\n        const target = getEventTarget(container);\n        window.addEventListener(\"resize\", listener, { passive: true });\n        if (container !== document.documentElement) {\n            resizeListeners.set(container, resize(container, listener));\n        }\n        target.addEventListener(\"scroll\", listener, { passive: true });\n    }\n    const listener = scrollListeners.get(container);\n    const onLoadProcesss = requestAnimationFrame(listener);\n    return () => {\n        var _a;\n        if (typeof onScroll !== \"function\")\n            onScroll.stop();\n        cancelAnimationFrame(onLoadProcesss);\n        /**\n         * Check if we even have any handlers for this container.\n         */\n        const containerHandlers = onScrollHandlers.get(container);\n        if (!containerHandlers)\n            return;\n        containerHandlers.delete(containerHandler);\n        if (containerHandlers.size)\n            return;\n        /**\n         * If no more handlers, remove the scroll listener too.\n         */\n        const listener = scrollListeners.get(container);\n        scrollListeners.delete(container);\n        if (listener) {\n            getEventTarget(container).removeEventListener(\"scroll\", listener);\n            (_a = resizeListeners.get(container)) === null || _a === void 0 ? void 0 : _a();\n            window.removeEventListener(\"resize\", listener);\n        }\n    };\n}\n\nexport { scroll };\n","import { resizeElement } from './handle-element.es.js';\nimport { resizeWindow } from './handle-window.es.js';\nimport { isFunction } from '@motionone/utils';\n\nfunction resize(a, b) {\n    return isFunction(a) ? resizeWindow(a) : resizeElement(a, b);\n}\n\nexport { resize };\n","/**\n * SplitType\n * https://github.com/lukePeavey/SplitType\n * @version 0.3.3\n * @author Luke Peavey <lwpeavey@gmail.com>\n */\n\n// Polyfill the following DOM methods that are not supported in IE 11.\n\n(() => {\n  function append(...nodes) {\n    const length = nodes.length;\n\n    for (let i = 0; i < length; i++) {\n      const node = nodes[i];\n      if (node.nodeType === 1 || node.nodeType === 11) this.appendChild(node);else this.appendChild(document.createTextNode(String(node)));\n    }\n  }\n\n  function replaceChildren(...nodes) {\n    while (this.lastChild) {\n      this.removeChild(this.lastChild);\n    }\n\n    if (nodes.length) this.append(...nodes);\n  }\n\n  function replaceWith(...nodes) {\n    const parent = this.parentNode;\n    let i = nodes.length;\n    if (!parent) return;\n    if (!i) parent.removeChild(this);\n\n    while (i--) {\n      let node = nodes[i];\n\n      if (typeof node !== 'object') {\n        node = this.ownerDocument.createTextNode(node);\n      } else if (node.parentNode) {\n        node.parentNode.removeChild(node);\n      }\n\n      if (!i) {\n        parent.replaceChild(node, this);\n      } else {\n        parent.insertBefore(this.previousSibling, node);\n      }\n    }\n  }\n\n  if (typeof Element !== 'undefined') {\n    if (!Element.prototype.append) {\n      Element.prototype.append = append;\n      DocumentFragment.prototype.append = append;\n    }\n\n    if (!Element.prototype.replaceChildren) {\n      Element.prototype.replaceChildren = replaceChildren;\n      DocumentFragment.prototype.replaceChildren = replaceChildren;\n    }\n\n    if (!Element.prototype.replaceWith) {\n      Element.prototype.replaceWith = replaceWith;\n      DocumentFragment.prototype.replaceWith = replaceWith;\n    }\n  }\n})();\n\n/**\n * Shallow merges the properties of an object with the target object. Only\n * includes properties that exist on the target object. Non-writable properties\n * on the target object will not be over-written.\n *\n * @param {Object} target\n * @param {Object} object\n */\nfunction extend(target, object) {\n  return Object.getOwnPropertyNames(Object(target)).reduce((extended, key) => {\n    const currentValue = Object.getOwnPropertyDescriptor(Object(target), key);\n    const newValue = Object.getOwnPropertyDescriptor(Object(object), key);\n    return Object.defineProperty(extended, key, newValue || currentValue);\n  }, {});\n}\n\n/**\n * Checks if given value is a string\n *\n * @param {any} value\n * @return {boolean} `true` if `value` is a string, else `false`\n */\nfunction isString(value) {\n  return typeof value === 'string';\n}\n\nfunction isArray(value) {\n  return Array.isArray(value);\n}\n\n/**\n * Parses user supplied settings objects.\n */\n\nfunction parseSettings(settings = {}) {\n  const object = extend(settings); // `split` may be used as an alias for the `types` option\n  // Parse the `types` settings into an array of valid split types.\n  // If `types` is explicitly set to an empty string or array, text will not be\n  // split at all.\n\n  let types;\n\n  if (object.types !== undefined) {\n    types = object.types;\n  } else if (object.split !== undefined) {\n    types = object.split;\n  }\n\n  if (types !== undefined) {\n    object.types = (isString(types) || isArray(types) ? String(types) : '').split(',').map(type => String(type).trim()).filter(type => /((line)|(word)|(char))/i.test(type));\n  } // Support `position: absolute` as an alias for `absolute: true`\n\n\n  if (object.absolute || object.position) {\n    object.absolute = object.absolute || /absolute/.test(settings.position);\n  }\n\n  return object;\n}\n\n/**\n * Takes a list of `types` and returns an object\n *\n * @param {string | string[]} value a comma separated list of split types\n * @return {{lines: boolean, words: boolean, chars: boolean}}\n */\n\nfunction parseTypes(value) {\n  const types = isString(value) || isArray(value) ? String(value) : '';\n  return {\n    none: !types,\n    lines: /line/i.test(types),\n    words: /word/i.test(types),\n    chars: /char/i.test(types)\n  };\n}\n\n/**\n * Returns true if `value` is a non-null object.\n * @param {any} value\n * @return {boolean}\n */\nfunction isObject(value) {\n  return value !== null && typeof value === 'object';\n}\n\n/**\n * Returns true if `input` is one of the following:\n * - `Element`\n * - `Text`\n * - `DocumentFragment`\n */\n\nfunction isNode(input) {\n  return isObject(input) && /^(1|3|11)$/.test(input.nodeType);\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n * Original source: Lodash\n *\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3)\n * // => true\n *\n * _.isLength(Number.MIN_VALUE)\n * // => false\n *\n * _.isLength(Infinity)\n * // => false\n *\n * _.isLength('3')\n * // => false\n */\n\nfunction isLength(value) {\n  return typeof value === 'number' && value > -1 && value % 1 === 0;\n}\n/**\n * Checks if `value` is an array-like object\n * @param {any} value\n * @return {boolean} true if `value` is array-like`, else `false`\n * @example\n * isArrayLike(new Array())\n * // => true\n *\n * isArrayLike(document.querySelectorAll('div'))\n * // => true\n *\n * isArrayLike(document.getElementsByTagName('div'))\n * // => true\n *\n * isArrayLike(() => {})\n * // => false\n *\n * isArrayLike({foo: 'bar'})\n * // => false\n *\n * * isArrayLike(null)\n * // => false\n */\n\n\nfunction isArrayLike(value) {\n  return isObject(value) && isLength(value.length);\n}\n\n/**\n * Coerces `value` to an `Array`.\n *\n * @param {any} value\n * @return {any[]}\n * @example\n * // If `value` is any `Array`, returns original `Array`\n * let arr = [1, 2]\n * toArray(arr)\n * // => arr\n *\n * // If `value` is an `ArrayLike`, its equivalent to `Array.from(value)`\n * let nodeList = document.querySelectorAll('div')\n * toArray(nodeList)\n * // => HTMLElement[] s\n *\n * // If value is falsy, returns empty array\n * toArray(null)\n * // => []\n *\n * // For any other type of value, its equivalent to `Array.of(value)`\n * let element = document.createElement('div')\n * toArray(element)\n * // => [element]\n *\n */\n\nfunction toArray(value) {\n  if (isArray(value)) return value;\n  if (value == null) return [];\n  return isArrayLike(value) ? Array.prototype.slice.call(value) : [value];\n}\n\n/**\n * Processes target elements for the splitType function.\n *\n * @param {any} target Can be one of the following:\n * 1. `string` - A css selector\n * 2. `HTMLElement` - A single element\n * 3. `NodeList` - A nodeList\n * 4. `Element[]` - An array of elements\n * 5. `Array<NodeList|Element[]>` - An nested array of elements\n * @returns {Element[]} A flat array HTML elements\n * @return A flat array of elements or empty array if no elements are found\n */\n\nfunction getTargetElements(target) {\n  let elements = target; // If `target` is a selector string...\n\n  if (isString(target)) {\n    if (/^(#[a-z]\\w+)$/.test(target.trim())) {\n      // If `target` is an ID, use `getElementById`\n      elements = document.getElementById(target.trim().slice(1));\n    } else {\n      // Else use `querySelectorAll`\n      elements = document.querySelectorAll(target);\n    }\n  } // Return a flattened array of elements\n\n\n  return toArray(elements).reduce((result, element) => {\n    return [...result, ...toArray(element).filter(isNode)];\n  }, []);\n}\n\nconst {\n  entries,\n  keys,\n  values\n} = Object;\n\nconst expando = `_splittype`;\nconst cache = {};\nlet uid = 0;\n/**\n * Stores data associated with DOM elements or other objects. This is a\n * simplified version of jQuery's data method.\n *\n * @signature Data(owner)\n * @description Get the data store object for the given owner.\n * @param {Object} owner the object that data will be associated with.\n * @return {Object} the data object for given `owner`. If no data exists\n *     for the given object, creates a new data store and returns it.\n *\n * @signature Data(owner, key)\n * @description Get the value\n * @param {Object} owner\n * @param {string} key\n * @return {any} the value of the provided key. If key does not exist, returns\n *     undefined.\n *\n * @signature Data(owner, key, value)\n * @description Sets the given key/value pair in data store\n * @param {Object} owner\n * @param {string} key\n * @param {any} value\n */\n\nfunction set(owner, key, value) {\n  if (!isObject(owner)) {\n    console.warn('[data.set] owner is not an object');\n    return null;\n  }\n\n  const id = owner[expando] || (owner[expando] = ++uid);\n  const data = cache[id] || (cache[id] = {});\n\n  if (value === undefined) {\n    if (!!key && Object.getPrototypeOf(key) === Object.prototype) {\n      cache[id] = { ...data,\n        ...key\n      };\n    }\n  } else if (key !== undefined) {\n    data[key] = value;\n  }\n\n  return value;\n}\nfunction get(owner, key) {\n  const id = isObject(owner) ? owner[expando] : null;\n  const data = id && cache[id] || {};\n\n  if (key === undefined) {\n    return data;\n  }\n\n  return data[key];\n}\n/**\n * Remove all data associated with the given element\n */\n\nfunction remove(element) {\n  const id = element && element[expando];\n\n  if (id) {\n    delete element[id];\n    delete cache[id];\n  }\n}\n/**\n * Remove all temporary data from the store.\n */\n\nfunction cleanup() {\n  entries(cache).forEach(([id, {\n    isRoot,\n    isSplit\n  }]) => {\n    if (!isRoot || !isSplit) {\n      cache[id] = null;\n      delete cache[id];\n    }\n  });\n}\n\n/**\n * Splits a string into an array of words.\n *\n * @param {string} string\n * @param {string | RegExp} [separator = ' ']\n * @return {string[]} Array of words\n */\nfunction toWords(value, separator = ' ') {\n  const string = value ? String(value) : '';\n  return string.trim().replace(/\\s+/g, ' ').split(separator);\n}\n\n/**\n * Based on lodash#split <https://lodash.com/license>\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters &\n * Editors\n */\nconst rsAstralRange = '\\\\ud800-\\\\udfff';\nconst rsComboMarksRange = '\\\\u0300-\\\\u036f\\\\ufe20-\\\\ufe23';\nconst rsComboSymbolsRange = '\\\\u20d0-\\\\u20f0';\nconst rsVarRange = '\\\\ufe0e\\\\ufe0f';\n/** Used to compose unicode capture groups. */\n\nconst rsAstral = `[${rsAstralRange}]`;\nconst rsCombo = `[${rsComboMarksRange}${rsComboSymbolsRange}]`;\nconst rsFitz = '\\\\ud83c[\\\\udffb-\\\\udfff]';\nconst rsModifier = `(?:${rsCombo}|${rsFitz})`;\nconst rsNonAstral = `[^${rsAstralRange}]`;\nconst rsRegional = '(?:\\\\ud83c[\\\\udde6-\\\\uddff]){2}';\nconst rsSurrPair = '[\\\\ud800-\\\\udbff][\\\\udc00-\\\\udfff]';\nconst rsZWJ = '\\\\u200d';\n/** Used to compose unicode regexes. */\n\nconst reOptMod = `${rsModifier}?`;\nconst rsOptVar = `[${rsVarRange}]?`;\nconst rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*';\nconst rsSeq = rsOptVar + reOptMod + rsOptJoin;\nconst rsSymbol = `(?:${[`${rsNonAstral}${rsCombo}?`, rsCombo, rsRegional, rsSurrPair, rsAstral].join('|')}\n)`;\n/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */\n\nconst reUnicode = RegExp(`${rsFitz}(?=${rsFitz})|${rsSymbol}${rsSeq}`, 'g');\n/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */\n\nconst unicodeRange = [rsZWJ, rsAstralRange, rsComboMarksRange, rsComboSymbolsRange, rsVarRange];\nconst reHasUnicode = RegExp(`[${unicodeRange.join('')}]`);\n/**\n * Converts an ASCII `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\n\nfunction asciiToArray(string) {\n  return string.split('');\n}\n/**\n * Checks if `string` contains Unicode symbols.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {boolean} Returns `true` if a symbol is found, else `false`.\n */\n\n\nfunction hasUnicode(string) {\n  return reHasUnicode.test(string);\n}\n/**\n * Converts a Unicode `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\n\n\nfunction unicodeToArray(string) {\n  return string.match(reUnicode) || [];\n}\n/**\n * Converts `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\n\n\nfunction stringToArray(string) {\n  return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string);\n}\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values.\n *\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\n\nfunction toString(value) {\n  return value == null ? '' : String(value);\n}\n/**\n * Splits `string` into an array of characters. If `separator` is omitted,\n * it behaves likes split.split('').\n *\n * Unlike native string.split(''), it can split strings that contain unicode\n * characters like emojis and symbols.\n *\n * @param {string} [string=''] The string to split.\n * @param {RegExp|string} [separator=''] The separator pattern to split by.\n * @returns {Array} Returns the string segments.\n * @example\n * toChars('foo');\n * // => ['f', 'o', 'o']\n *\n * toChars('foo bar');\n * // => [\"f\", \"o\", \"o\", \" \", \"b\", \"a\", \"r\"]\n *\n * toChars('f😀o');\n * // => ['f', '😀', 'o']\n *\n * toChars('f-😀-o', /-/);\n * // => ['f', '😀', 'o']\n *\n */\n\n\nfunction toChars(string, separator = '') {\n  string = toString(string);\n\n  if (string && isString(string)) {\n    if (!separator && hasUnicode(string)) {\n      return stringToArray(string);\n    }\n  }\n\n  return string.split(separator);\n}\n\n/**\n * Create an HTML element with the the given attributes\n *\n * attributes can include standard HTML attribute, as well as the following\n * \"special\" properties:\n *   - children: HTMLElement | ArrayLike<HTMLElement>\n *   - textContent: string\n *   - innerHTML: string\n *\n * @param {string} name\n * @param  {Object} [attributes]\n * @returns {HTMLElement}\n */\n\nfunction createElement(name, attributes) {\n  const element = document.createElement(name);\n\n  if (!attributes) {\n    // When called without the second argument, its just return the result\n    // of `document.createElement`\n    return element;\n  }\n\n  Object.keys(attributes).forEach(attribute => {\n    const rawValue = attributes[attribute];\n    const value = isString(rawValue) ? rawValue.trim() : rawValue; // Ignore attribute if the value is `null` or an empty string\n\n    if (value === null || value === '') return;\n\n    if (attribute === 'children') {\n      // Children can be one or more Elements or DOM strings\n      element.append(...toArray(value));\n    } else {\n      // Handle standard HTML attributes\n      element.setAttribute(attribute, value);\n    }\n  });\n  return element;\n}\n\nvar defaults = {\n  splitClass: '',\n  lineClass: 'line',\n  wordClass: 'word',\n  charClass: 'char',\n  types: ['lines', 'words', 'chars'],\n  absolute: false,\n  tagName: 'div'\n};\n\n/**\n * Splits the text content of a single TextNode into words and/or characters.\n *\n * This functions gets called for every text node inside the target element. It\n * replaces the text node with a document fragment containing the split text.\n * Returns an array of the split word and character elements from this node.\n *\n * @param {TextNode} textNode\n * @param {Object} settings\n * @return {{words: Element[], chars: Element[]}}\n */\n\nfunction splitWordsAndChars(textNode, settings) {\n  settings = extend(defaults, settings); // The split types\n\n  const types = parseTypes(settings.types); // the tag name for split text nodes\n\n  const TAG_NAME = settings.tagName; // value of the text node\n\n  const VALUE = textNode.nodeValue; // `splitText` is a wrapper to hold the HTML structure\n\n  const splitText = document.createDocumentFragment(); // Arrays of split word and character elements\n\n  let words = [];\n  let chars = [];\n\n  if (/^\\s/.test(VALUE)) {\n    splitText.append(' ');\n  } // Create an array of wrapped word elements.\n\n\n  words = toWords(VALUE).reduce((result, WORD, idx, arr) => {\n    // Let `wordElement` be the wrapped element for the current word\n    let wordElement;\n    let characterElementsForCurrentWord; // -> If splitting text into characters...\n\n    if (types.chars) {\n      // Iterate through the characters in the current word\n      characterElementsForCurrentWord = toChars(WORD).map(CHAR => {\n        const characterElement = createElement(TAG_NAME, {\n          class: `${settings.splitClass} ${settings.charClass}`,\n          style: 'display: inline-block;',\n          children: CHAR\n        });\n        set(characterElement, 'isChar', true);\n        chars = [...chars, characterElement];\n        return characterElement;\n      });\n    } // END IF;\n\n\n    if (types.words || types.lines) {\n      // -> If Splitting Text Into Words...\n      //    Create an element to wrap the current word. If we are also\n      //    splitting text into characters, the word element will contain the\n      //    wrapped character nodes for this word. If not, it will contain the\n      //    plain text content (WORD)\n      wordElement = createElement(TAG_NAME, {\n        class: `${settings.wordClass} ${settings.splitClass}`,\n        style: `display: inline-block; ${types.words && settings.absolute ? `position: relative;` : ''}`,\n        children: types.chars ? characterElementsForCurrentWord : WORD\n      });\n      set(wordElement, {\n        isWord: true,\n        isWordStart: true,\n        isWordEnd: true\n      });\n      splitText.appendChild(wordElement);\n    } else {\n      // -> If NOT splitting into words OR lines...\n      //    Append the characters elements directly to splitText.\n      characterElementsForCurrentWord.forEach(characterElement => {\n        splitText.appendChild(characterElement);\n      });\n    }\n\n    if (idx < arr.length - 1) {\n      // Add a space after the word.\n      splitText.append(' ');\n    } // If not splitting text into words, we return an empty array\n\n\n    return types.words ? result.concat(wordElement) : result;\n  }, []); // END LOOP;\n  // Add a trailing white space to maintain word spacing\n\n  if (/\\s$/.test(VALUE)) {\n    splitText.append(' ');\n  }\n\n  textNode.replaceWith(splitText);\n  return {\n    words,\n    chars\n  };\n}\n\n/**\n * Splits the text content of a target element into words and/or characters.\n * The function is recursive, it will also split the text content of any child\n * elements into words/characters, while preserving the nested elements.\n *\n * @param {Node} node an HTML Element or Text Node\n * @param {Object} setting splitType settings\n */\n\nfunction split(node, settings) {\n  const type = node.nodeType; // Arrays of split words and characters\n\n  const wordsAndChars = {\n    words: [],\n    chars: []\n  }; // Only proceed if `node` is an `Element`, `Fragment`, or `Text`\n\n  if (!/(1|3|11)/.test(type)) {\n    return wordsAndChars;\n  } // A) IF `node` is TextNode that contains characters other than white space...\n  //    Split the text content of the node into words and/or characters\n  //    return an object containing the split word and character elements\n\n\n  if (type === 3 && /\\S/.test(node.nodeValue)) {\n    return splitWordsAndChars(node, settings);\n  } // B) ELSE `node` is an 'Element'\n  //    Iterate through its child nodes, calling the `split` function\n  //    recursively for each child node.\n\n\n  const childNodes = toArray(node.childNodes);\n\n  if (childNodes.length) {\n    set(node, 'isSplit', true); // we need to set a few styles on nested html elements\n\n    if (!get(node).isRoot) {\n      node.style.display = 'inline-block';\n      node.style.position = 'relative'; // To maintain original spacing around nested elements when we are\n      // splitting text into lines, we need to check if the element should\n      // have a space before and after, and store that value for later.\n      // Note: this was necessary to maintain the correct spacing when nested\n      // elements do not align with word boundaries. For example, a nested\n      // element only wraps part of a word.\n\n      const nextSibling = node.nextSibling;\n      const prevSibling = node.previousSibling;\n      const text = node.textContent || '';\n      const textAfter = nextSibling ? nextSibling.textContent : ' ';\n      const textBefore = prevSibling ? prevSibling.textContent : ' ';\n      set(node, {\n        isWordEnd: /\\s$/.test(text) || /^\\s/.test(textAfter),\n        isWordStart: /^\\s/.test(text) || /\\s$/.test(textBefore)\n      });\n    }\n  } // Iterate through child nodes, calling `split` recursively\n  // Returns an object containing all split words and chars\n\n\n  return childNodes.reduce((result, child) => {\n    const {\n      words,\n      chars\n    } = split(child, settings);\n    return {\n      words: [...result.words, ...words],\n      chars: [...result.chars, ...chars]\n    };\n  }, wordsAndChars);\n}\n\n/**\n * Gets the height and position of an element relative to offset parent.\n * Should be equivalent to offsetTop and offsetHeight, but with sub-pixel\n * precision.\n *\n * TODO needs work\n */\nfunction getPosition(node, isWord, settings, scrollPos) {\n  if (!settings.absolute) {\n    return {\n      top: isWord ? node.offsetTop : null\n    };\n  }\n\n  const parent = node.offsetParent;\n  const [scrollX, scrollY] = scrollPos;\n  let parentX = 0;\n  let parentY = 0;\n\n  if (parent && parent !== document.body) {\n    const parentRect = parent.getBoundingClientRect();\n    parentX = parentRect.x + scrollX;\n    parentY = parentRect.y + scrollY;\n  }\n\n  const {\n    width,\n    height,\n    x,\n    y\n  } = node.getBoundingClientRect();\n  const top = y + scrollY - parentY;\n  const left = x + scrollX - parentX;\n  return {\n    width,\n    height,\n    top,\n    left\n  };\n}\n\n/**\n * Recursively \"un-splits\" text into words.\n * This is used when splitting text into lines but not words.\n * We initially split the text into words so we can maintain the correct line\n * breaks. Once text has been split into lines, we \"un-split\" the words...\n * @param {Element}\n * @return {void}\n */\n\nfunction unSplitWords(element) {\n  if (!get(element).isWord) {\n    toArray(element.children).forEach(child => unSplitWords(child));\n  } else {\n    remove(element);\n    element.replaceWith(...element.childNodes);\n  }\n}\n\nconst createFragment = () => document.createDocumentFragment();\n\nfunction repositionAfterSplit(element, settings, scrollPos) {\n  const types = parseTypes(settings.types);\n  const TAG_NAME = settings.tagName;\n  const nodes = element.getElementsByTagName('*');\n  const wordsInEachLine = [];\n  let wordsInCurrentLine = [];\n  let lineOffsetY = null;\n  let elementHeight;\n  let elementWidth;\n  let contentBox;\n  let lines = [];\n  /**------------------------------------------------\n   ** GET STYLES AND POSITIONS\n   **-----------------------------------------------*/\n  // There is no built-in way to detect natural line breaks in text (when a\n  // block of text wraps to fit its container). To split text into lines, we\n  // have to detect line breaks by checking the top offset of words. This is\n  // why text was split into words first. To apply absolute\n  // positioning, its also necessary to record the size and position of every\n  // split node (lines, words, characters).\n  // To consolidate DOM getting/settings, this is all done at the same time,\n  // before actually splitting text into lines, which involves restructuring\n  // the DOM again.\n  // Cache the element's parent and next sibling (for DOM removal).\n\n  const parent = element.parentElement;\n  const nextSibling = element.nextElementSibling; // a wrapper for the new HTML structure\n\n  const splitText = createFragment(); // get the computed style object for the element\n\n  const cs = window.getComputedStyle(element);\n  const align = cs.textAlign;\n  const fontSize = parseFloat(cs.fontSize);\n  const lineThreshold = fontSize * 0.2; // IF using absolute position...\n\n  if (settings.absolute) {\n    // Let contentBox be an object containing the width and offset position of\n    // the element's content box (the area inside padding box). This is needed\n    // (for absolute positioning) to set the width and position of line\n    // elements, which have not been created yet.\n    contentBox = {\n      left: element.offsetLeft,\n      top: element.offsetTop,\n      width: element.offsetWidth\n    }; // Let elementWidth and elementHeight be the actual width/height of the\n    // element. Also check if the element has inline height or width styles\n    // already set. If it does, cache those values for later.\n\n    elementWidth = element.offsetWidth;\n    elementHeight = element.offsetHeight; // Store the original inline height and width of the element\n\n    set(element, {\n      cssWidth: element.style.width,\n      cssHeight: element.style.height\n    });\n  } // Iterate over every node in the target element\n\n\n  toArray(nodes).forEach(node => {\n    // node is a word element or custom html element\n    const isWordLike = node.parentElement === element; // TODO needs work\n    // Get te size and position of split text nodes\n\n    const {\n      width,\n      height,\n      top,\n      left\n    } = getPosition(node, isWordLike, settings, scrollPos); // If element is a `<br>` tag return here\n\n    if (/^br$/i.test(node.nodeName)) return;\n\n    if (types.lines && isWordLike) {\n      // We compare the top offset of the current word to the top offset of\n      // previous words on the current line. If the difference is greater than\n      // our defined threshold (20%), we assume this word is on a new line.\n      if (lineOffsetY === null || top - lineOffsetY >= lineThreshold) {\n        lineOffsetY = top;\n        wordsInEachLine.push(wordsInCurrentLine = []);\n      } // Add the current word node to the line array\n\n\n      wordsInCurrentLine.push(node);\n    } // END IF\n\n\n    if (settings.absolute) {\n      // Store the size and position split text nodes\n      set(node, {\n        top,\n        left,\n        width,\n        height\n      });\n    }\n  }); // END LOOP\n  // Remove the element from the DOM\n\n  if (parent) {\n    parent.removeChild(element);\n  }\n  /**------------------------------------------------\n   ** SPLIT LINES\n   **-----------------------------------------------*/\n\n\n  if (types.lines) {\n    // Iterate over lines of text (see 11 b)\n    // Let `line` be the array of words in the current line.\n    // Return an array of the wrapped line elements (lineElements)\n    lines = wordsInEachLine.map(wordsInThisLine => {\n      // Create an element to wrap the current line.\n      const lineElement = createElement(TAG_NAME, {\n        class: `${settings.splitClass} ${settings.lineClass}`,\n        style: `display: block; text-align: ${align}; width: 100%;`\n      });\n      set(lineElement, 'isLine', true);\n      const lineDimensions = {\n        height: 0,\n        top: 1e4\n      }; // Append the `lineElement` to `container`\n\n      splitText.appendChild(lineElement); // Iterate over the word-level elements in the current line.\n      // Note: wordOrElement can either be a word node or nested element\n\n      wordsInThisLine.forEach((wordOrElement, idx, arr) => {\n        const {\n          isWordEnd,\n          top,\n          height\n        } = get(wordOrElement);\n        const next = arr[idx + 1]; // Determine line height / y-position\n        // we use the height and offsetTop of the words which we already\n        // recorded. Because custom nested elements could have their own\n        // styles, the words on a line may not all be the same height or\n        // y position. So we take the greatest height / y - offset of the\n        // words on this line.\n\n        lineDimensions.height = Math.max(lineDimensions.height, height);\n        lineDimensions.top = Math.min(lineDimensions.top, top); // append the current word/element\n\n        lineElement.appendChild(wordOrElement); // Determine if there should space after the current element...\n        // If this is not the last word on the current line.\n        // TODO - logic for handing spacing can be improved\n\n        if (isWordEnd && get(next).isWordStart) {\n          lineElement.append(' ');\n        }\n      }); // END LOOP\n\n      if (settings.absolute) {\n        set(lineElement, {\n          height: lineDimensions.height,\n          top: lineDimensions.top\n        });\n      }\n\n      return lineElement;\n    }); // END LOOP\n\n    if (!types.words) {\n      unSplitWords(splitText);\n    } // 10. Insert the new container\n\n\n    element.replaceChildren(splitText);\n  }\n  /**------------------------------------------------\n   **  SET ABSOLUTE POSITION\n   **-----------------------------------------------*/\n  // Apply absolute positioning to all child elements of the target element.\n  // This includes split lines, words, chars, and custom HTML elements that were\n  // included by the user. The size and position of child elements has already\n  // been recorded before splitting text into lines.\n\n\n  if (settings.absolute) {\n    // Set the width/height of the parent element so it does not collapse\n    // when its children are set to absolute position.\n    element.style.width = `${element.style.width || elementWidth}px`;\n    element.style.height = `${elementHeight}px`; // Iterate over all child elements\n\n    toArray(nodes).forEach(node => {\n      const {\n        isLine,\n        top,\n        left,\n        width,\n        height\n      } = get(node);\n      const parentData = get(node.parentElement);\n      const isChildOfLineNode = !isLine && parentData.isLine; // Set the top position of the current node.\n      // -> If `node` a line element, we use the top offset of its first child\n      // -> If `node` the child of line element, then its top offset is zero\n\n      node.style.top = `${isChildOfLineNode ? top - parentData.top : top}px`; // Set the left position of the current node.\n      // -> IF `node` is a line element, this is equal to the position left of\n      //    the content box of the parent element\n      // -> IF `node` is the child of a line element, the value has to adjusted\n      //    so its relative to the line element\n\n      node.style.left = isLine ? `${contentBox.left}px` : `${left - (isChildOfLineNode ? contentBox.left : 0)}px`; // Set the height of the current node to the cached value.\n\n      node.style.height = `${height}px`; //  Set the width of the current node.\n      //  If its a line element, width is equal to the width of the contentBox.\n\n      node.style.width = isLine ? `${contentBox.width}px` : `${width}px`; // Finally, set the node's position to absolute.\n\n      node.style.position = 'absolute';\n    });\n  } // end if;\n  // 14. Re-attach the element to the DOM\n\n\n  if (parent) {\n    if (nextSibling) parent.insertBefore(element, nextSibling);else parent.appendChild(element);\n  }\n\n  return lines;\n}\n\nlet _defaults = extend(defaults, {});\n\nclass SplitType {\n  /**\n   * The internal data store\n   */\n  static get data() {\n    return cache;\n  }\n  /**\n   * The default settings for all splitType instances\n   * @static\n   */\n\n\n  static get defaults() {\n    return _defaults;\n  }\n  /**\n   * Sets the default settings for all SplitType instances.\n   *\n   * Setting `SplitType.defaults` to an object will merge that object with the\n   * existing defaults.\n   *\n   * @param {Object} settings an object containing the settings to override\n   * @deprecated\n   * @static\n   * @example\n   * SplitType.defaults = { \"position\": \"absolute\" }\n   */\n\n\n  static set defaults(options) {\n    _defaults = extend(_defaults, parseSettings(options));\n  }\n  /**\n   * Sets the default settings for all SplitType instances.\n   * The provided object will be merged with the existing defaults objects.\n   *\n   * @param {Object} settings an object containing the settings to override\n   * @returns {Object} the new default settings\n   * @public\n   * @static\n   * @example\n   * SplitType.setDefaults({ \"position\": \"absolute\" })\n   */\n\n\n  static setDefaults(options) {\n    _defaults = extend(_defaults, parseSettings(options));\n    return defaults;\n  }\n  /**\n   * Revert target elements to their original html content\n   * Has no effect on that\n   *\n   * @param {any} elements The target elements to revert. One of:\n   *  - {string} A css selector\n   *  - {HTMLElement} A single element\n   * -  {NodeList} A NodeList or collection\n   *  - {HTMLElement[]} An array of Elements\n   * -  {Array<HTMLElement|NodeList|HTMLElement[]>} A nested array of elements\n   * @static\n   */\n\n\n  static revert(elements) {\n    getTargetElements(elements).forEach(element => {\n      const {\n        isSplit,\n        html,\n        cssWidth,\n        cssHeight\n      } = get(element);\n\n      if (isSplit) {\n        element.innerHTML = html;\n        element.style.width = cssWidth || '';\n        element.style.height = cssHeight || '';\n        remove(element);\n      }\n    });\n  }\n  /**\n   * Creates a new SplitType instance\n   * This static method provides a way to create a `SplitType` instance without\n   * using the `new` keyword.\n   *\n   * @param {any} target The target elements to split. One of:\n   *  - {string} A css selector\n   *  - {HTMLElement} A single element\n   * -  {NodeList} A NodeList or collection\n   *  - {HTMLElement[]} An array of Elements\n   * -  {Array<HTMLElement|NodeList|HTMLElement[]>} A nested array of elements\n   * @param {Object} [options] Settings for the SplitType instance\n   * @return {SplitType} the SplitType instance\n   * @static\n   */\n\n\n  static create(target, options) {\n    return new SplitType(target, options);\n  }\n  /**\n   * Creates a new `SplitType` instance\n   *\n   * @param {any} elements The target elements to split. One of:\n   *  - {string} A css selector\n   *  - {HTMLElement} A single element\n   * -  {NodeList} A NodeList or collection\n   *  - {HTMLElement[]} An array of Elements\n   * -  {Array<HTMLElement|NodeList|HTMLElement[]>} A nested array of elements\n   * @param {Object} [options] Settings for the SplitType instance\n   */\n\n\n  constructor(elements, options) {\n    this.isSplit = false;\n    this.settings = extend(_defaults, parseSettings(options));\n    this.elements = getTargetElements(elements); // Start the split process\n\n    this.split();\n  }\n  /**\n   * Splits the text in all target elements. This method is called\n   * automatically when a new SplitType instance is created. It can also be\n   * called manually to re-split text with new options.\n   * @param {Object} options\n   * @public\n   */\n\n\n  split(options) {\n    // Revert target elements (if they are already split)\n    // Note: revert was already called once in the constructor. However, we\n    // need to call it again here so text is reverted when the user manually\n    // calls the `split` method to re-split text.\n    this.revert(); // Store the original html content of each target element\n\n    this.elements.forEach(element => {\n      set(element, 'html', element.innerHTML);\n    }); // Create arrays to hold the split lines, words, and characters\n\n    this.lines = [];\n    this.words = [];\n    this.chars = []; // cache vertical scroll position before splitting\n\n    const scrollPos = [window.pageXOffset, window.pageYOffset]; // If new options were passed into the `split()` method, update settings\n\n    if (options !== undefined) {\n      this.settings = extend(this.settings, parseSettings(options));\n    }\n\n    const types = parseTypes(this.settings.types); // If the `types` option is set to an empty array, text will not be split.\n    // @example new SplitType('#target', { types: [] })\n\n    if (types.none) {\n      return;\n    } // Split text in each target element\n\n\n    this.elements.forEach(element => {\n      // Add the split text nodes from this element to the arrays of all split\n      // text nodes for this instance.\n      set(element, 'isRoot', true);\n      const {\n        words,\n        chars\n      } = split(element, this.settings);\n      this.words = [...this.words, ...words];\n      this.chars = [...this.chars, ...chars];\n    });\n    this.elements.forEach(element => {\n      if (types.lines || this.settings.absolute) {\n        const lines = repositionAfterSplit(element, this.settings, scrollPos);\n        this.lines = [...this.lines, ...lines];\n      }\n    }); // Set isSplit to true for the SplitType instance\n\n    this.isSplit = true; // Set scroll position to cached value.\n\n    window.scrollTo(scrollPos[0], scrollPos[1]); // Clean up stored data\n\n    cleanup();\n  }\n  /**\n   * Reverts target element(s) back to their original html content\n   * Deletes all stored data associated with the target elements\n   * Resets the properties on the splitType instance\n   *\n   * @public\n   */\n\n\n  revert() {\n    if (this.isSplit) {\n      // Reset instance properties if necessary\n      this.lines = null;\n      this.words = null;\n      this.chars = null;\n      this.isSplit = false;\n    }\n\n    SplitType.revert(this.elements);\n  }\n\n}\n\nexport { SplitType as default };\n","function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\n/*!\n * Splide.js\n * Version  : 4.1.4\n * License  : MIT\n * Copyright: 2022 Naotoshi Fujita\n */\nvar MEDIA_PREFERS_REDUCED_MOTION = \"(prefers-reduced-motion: reduce)\";\nvar CREATED = 1;\nvar MOUNTED = 2;\nvar IDLE = 3;\nvar MOVING = 4;\nvar SCROLLING = 5;\nvar DRAGGING = 6;\nvar DESTROYED = 7;\nvar STATES = {\n  CREATED: CREATED,\n  MOUNTED: MOUNTED,\n  IDLE: IDLE,\n  MOVING: MOVING,\n  SCROLLING: SCROLLING,\n  DRAGGING: DRAGGING,\n  DESTROYED: DESTROYED\n};\n\nfunction empty(array) {\n  array.length = 0;\n}\n\nfunction slice(arrayLike, start, end) {\n  return Array.prototype.slice.call(arrayLike, start, end);\n}\n\nfunction apply(func) {\n  return func.bind.apply(func, [null].concat(slice(arguments, 1)));\n}\n\nvar nextTick = setTimeout;\n\nvar noop = function noop() {};\n\nfunction raf(func) {\n  return requestAnimationFrame(func);\n}\n\nfunction typeOf(type, subject) {\n  return typeof subject === type;\n}\n\nfunction isObject(subject) {\n  return !isNull(subject) && typeOf(\"object\", subject);\n}\n\nvar isArray = Array.isArray;\nvar isFunction = apply(typeOf, \"function\");\nvar isString = apply(typeOf, \"string\");\nvar isUndefined = apply(typeOf, \"undefined\");\n\nfunction isNull(subject) {\n  return subject === null;\n}\n\nfunction isHTMLElement(subject) {\n  try {\n    return subject instanceof (subject.ownerDocument.defaultView || window).HTMLElement;\n  } catch (e) {\n    return false;\n  }\n}\n\nfunction toArray(value) {\n  return isArray(value) ? value : [value];\n}\n\nfunction forEach(values, iteratee) {\n  toArray(values).forEach(iteratee);\n}\n\nfunction includes(array, value) {\n  return array.indexOf(value) > -1;\n}\n\nfunction push(array, items) {\n  array.push.apply(array, toArray(items));\n  return array;\n}\n\nfunction toggleClass(elm, classes, add) {\n  if (elm) {\n    forEach(classes, function (name) {\n      if (name) {\n        elm.classList[add ? \"add\" : \"remove\"](name);\n      }\n    });\n  }\n}\n\nfunction addClass(elm, classes) {\n  toggleClass(elm, isString(classes) ? classes.split(\" \") : classes, true);\n}\n\nfunction append(parent, children) {\n  forEach(children, parent.appendChild.bind(parent));\n}\n\nfunction before(nodes, ref) {\n  forEach(nodes, function (node) {\n    var parent = (ref || node).parentNode;\n\n    if (parent) {\n      parent.insertBefore(node, ref);\n    }\n  });\n}\n\nfunction matches(elm, selector) {\n  return isHTMLElement(elm) && (elm[\"msMatchesSelector\"] || elm.matches).call(elm, selector);\n}\n\nfunction children(parent, selector) {\n  var children2 = parent ? slice(parent.children) : [];\n  return selector ? children2.filter(function (child) {\n    return matches(child, selector);\n  }) : children2;\n}\n\nfunction child(parent, selector) {\n  return selector ? children(parent, selector)[0] : parent.firstElementChild;\n}\n\nvar ownKeys = Object.keys;\n\nfunction forOwn(object, iteratee, right) {\n  if (object) {\n    (right ? ownKeys(object).reverse() : ownKeys(object)).forEach(function (key) {\n      key !== \"__proto__\" && iteratee(object[key], key);\n    });\n  }\n\n  return object;\n}\n\nfunction assign(object) {\n  slice(arguments, 1).forEach(function (source) {\n    forOwn(source, function (value, key) {\n      object[key] = source[key];\n    });\n  });\n  return object;\n}\n\nfunction merge(object) {\n  slice(arguments, 1).forEach(function (source) {\n    forOwn(source, function (value, key) {\n      if (isArray(value)) {\n        object[key] = value.slice();\n      } else if (isObject(value)) {\n        object[key] = merge({}, isObject(object[key]) ? object[key] : {}, value);\n      } else {\n        object[key] = value;\n      }\n    });\n  });\n  return object;\n}\n\nfunction omit(object, keys) {\n  forEach(keys || ownKeys(object), function (key) {\n    delete object[key];\n  });\n}\n\nfunction removeAttribute(elms, attrs) {\n  forEach(elms, function (elm) {\n    forEach(attrs, function (attr) {\n      elm && elm.removeAttribute(attr);\n    });\n  });\n}\n\nfunction setAttribute(elms, attrs, value) {\n  if (isObject(attrs)) {\n    forOwn(attrs, function (value2, name) {\n      setAttribute(elms, name, value2);\n    });\n  } else {\n    forEach(elms, function (elm) {\n      isNull(value) || value === \"\" ? removeAttribute(elm, attrs) : elm.setAttribute(attrs, String(value));\n    });\n  }\n}\n\nfunction create(tag, attrs, parent) {\n  var elm = document.createElement(tag);\n\n  if (attrs) {\n    isString(attrs) ? addClass(elm, attrs) : setAttribute(elm, attrs);\n  }\n\n  parent && append(parent, elm);\n  return elm;\n}\n\nfunction style(elm, prop, value) {\n  if (isUndefined(value)) {\n    return getComputedStyle(elm)[prop];\n  }\n\n  if (!isNull(value)) {\n    elm.style[prop] = \"\" + value;\n  }\n}\n\nfunction display(elm, display2) {\n  style(elm, \"display\", display2);\n}\n\nfunction focus(elm) {\n  elm[\"setActive\"] && elm[\"setActive\"]() || elm.focus({\n    preventScroll: true\n  });\n}\n\nfunction getAttribute(elm, attr) {\n  return elm.getAttribute(attr);\n}\n\nfunction hasClass(elm, className) {\n  return elm && elm.classList.contains(className);\n}\n\nfunction rect(target) {\n  return target.getBoundingClientRect();\n}\n\nfunction remove(nodes) {\n  forEach(nodes, function (node) {\n    if (node && node.parentNode) {\n      node.parentNode.removeChild(node);\n    }\n  });\n}\n\nfunction parseHtml(html) {\n  return child(new DOMParser().parseFromString(html, \"text/html\").body);\n}\n\nfunction prevent(e, stopPropagation) {\n  e.preventDefault();\n\n  if (stopPropagation) {\n    e.stopPropagation();\n    e.stopImmediatePropagation();\n  }\n}\n\nfunction query(parent, selector) {\n  return parent && parent.querySelector(selector);\n}\n\nfunction queryAll(parent, selector) {\n  return selector ? slice(parent.querySelectorAll(selector)) : [];\n}\n\nfunction removeClass(elm, classes) {\n  toggleClass(elm, classes, false);\n}\n\nfunction timeOf(e) {\n  return e.timeStamp;\n}\n\nfunction unit(value) {\n  return isString(value) ? value : value ? value + \"px\" : \"\";\n}\n\nvar PROJECT_CODE = \"splide\";\nvar DATA_ATTRIBUTE = \"data-\" + PROJECT_CODE;\n\nfunction assert(condition, message) {\n  if (!condition) {\n    throw new Error(\"[\" + PROJECT_CODE + \"] \" + (message || \"\"));\n  }\n}\n\nvar min = Math.min,\n    max = Math.max,\n    floor = Math.floor,\n    ceil = Math.ceil,\n    abs = Math.abs;\n\nfunction approximatelyEqual(x, y, epsilon) {\n  return abs(x - y) < epsilon;\n}\n\nfunction between(number, x, y, exclusive) {\n  var minimum = min(x, y);\n  var maximum = max(x, y);\n  return exclusive ? minimum < number && number < maximum : minimum <= number && number <= maximum;\n}\n\nfunction clamp(number, x, y) {\n  var minimum = min(x, y);\n  var maximum = max(x, y);\n  return min(max(minimum, number), maximum);\n}\n\nfunction sign(x) {\n  return +(x > 0) - +(x < 0);\n}\n\nfunction camelToKebab(string) {\n  return string.replace(/([a-z0-9])([A-Z])/g, \"$1-$2\").toLowerCase();\n}\n\nfunction format(string, replacements) {\n  forEach(replacements, function (replacement) {\n    string = string.replace(\"%s\", \"\" + replacement);\n  });\n  return string;\n}\n\nfunction pad(number) {\n  return number < 10 ? \"0\" + number : \"\" + number;\n}\n\nvar ids = {};\n\nfunction uniqueId(prefix) {\n  return \"\" + prefix + pad(ids[prefix] = (ids[prefix] || 0) + 1);\n}\n\nfunction EventBinder() {\n  var listeners = [];\n\n  function bind(targets, events, callback, options) {\n    forEachEvent(targets, events, function (target, event, namespace) {\n      var isEventTarget = (\"addEventListener\" in target);\n      var remover = isEventTarget ? target.removeEventListener.bind(target, event, callback, options) : target[\"removeListener\"].bind(target, callback);\n      isEventTarget ? target.addEventListener(event, callback, options) : target[\"addListener\"](callback);\n      listeners.push([target, event, namespace, callback, remover]);\n    });\n  }\n\n  function unbind(targets, events, callback) {\n    forEachEvent(targets, events, function (target, event, namespace) {\n      listeners = listeners.filter(function (listener) {\n        if (listener[0] === target && listener[1] === event && listener[2] === namespace && (!callback || listener[3] === callback)) {\n          listener[4]();\n          return false;\n        }\n\n        return true;\n      });\n    });\n  }\n\n  function dispatch(target, type, detail) {\n    var e;\n    var bubbles = true;\n\n    if (typeof CustomEvent === \"function\") {\n      e = new CustomEvent(type, {\n        bubbles: bubbles,\n        detail: detail\n      });\n    } else {\n      e = document.createEvent(\"CustomEvent\");\n      e.initCustomEvent(type, bubbles, false, detail);\n    }\n\n    target.dispatchEvent(e);\n    return e;\n  }\n\n  function forEachEvent(targets, events, iteratee) {\n    forEach(targets, function (target) {\n      target && forEach(events, function (events2) {\n        events2.split(\" \").forEach(function (eventNS) {\n          var fragment = eventNS.split(\".\");\n          iteratee(target, fragment[0], fragment[1]);\n        });\n      });\n    });\n  }\n\n  function destroy() {\n    listeners.forEach(function (data) {\n      data[4]();\n    });\n    empty(listeners);\n  }\n\n  return {\n    bind: bind,\n    unbind: unbind,\n    dispatch: dispatch,\n    destroy: destroy\n  };\n}\n\nvar EVENT_MOUNTED = \"mounted\";\nvar EVENT_READY = \"ready\";\nvar EVENT_MOVE = \"move\";\nvar EVENT_MOVED = \"moved\";\nvar EVENT_CLICK = \"click\";\nvar EVENT_ACTIVE = \"active\";\nvar EVENT_INACTIVE = \"inactive\";\nvar EVENT_VISIBLE = \"visible\";\nvar EVENT_HIDDEN = \"hidden\";\nvar EVENT_REFRESH = \"refresh\";\nvar EVENT_UPDATED = \"updated\";\nvar EVENT_RESIZE = \"resize\";\nvar EVENT_RESIZED = \"resized\";\nvar EVENT_DRAG = \"drag\";\nvar EVENT_DRAGGING = \"dragging\";\nvar EVENT_DRAGGED = \"dragged\";\nvar EVENT_SCROLL = \"scroll\";\nvar EVENT_SCROLLED = \"scrolled\";\nvar EVENT_OVERFLOW = \"overflow\";\nvar EVENT_DESTROY = \"destroy\";\nvar EVENT_ARROWS_MOUNTED = \"arrows:mounted\";\nvar EVENT_ARROWS_UPDATED = \"arrows:updated\";\nvar EVENT_PAGINATION_MOUNTED = \"pagination:mounted\";\nvar EVENT_PAGINATION_UPDATED = \"pagination:updated\";\nvar EVENT_NAVIGATION_MOUNTED = \"navigation:mounted\";\nvar EVENT_AUTOPLAY_PLAY = \"autoplay:play\";\nvar EVENT_AUTOPLAY_PLAYING = \"autoplay:playing\";\nvar EVENT_AUTOPLAY_PAUSE = \"autoplay:pause\";\nvar EVENT_LAZYLOAD_LOADED = \"lazyload:loaded\";\nvar EVENT_SLIDE_KEYDOWN = \"sk\";\nvar EVENT_SHIFTED = \"sh\";\nvar EVENT_END_INDEX_CHANGED = \"ei\";\n\nfunction EventInterface(Splide2) {\n  var bus = Splide2 ? Splide2.event.bus : document.createDocumentFragment();\n  var binder = EventBinder();\n\n  function on(events, callback) {\n    binder.bind(bus, toArray(events).join(\" \"), function (e) {\n      callback.apply(callback, isArray(e.detail) ? e.detail : []);\n    });\n  }\n\n  function emit(event) {\n    binder.dispatch(bus, event, slice(arguments, 1));\n  }\n\n  if (Splide2) {\n    Splide2.event.on(EVENT_DESTROY, binder.destroy);\n  }\n\n  return assign(binder, {\n    bus: bus,\n    on: on,\n    off: apply(binder.unbind, bus),\n    emit: emit\n  });\n}\n\nfunction RequestInterval(interval, onInterval, onUpdate, limit) {\n  var now = Date.now;\n  var startTime;\n  var rate = 0;\n  var id;\n  var paused = true;\n  var count = 0;\n\n  function update() {\n    if (!paused) {\n      rate = interval ? min((now() - startTime) / interval, 1) : 1;\n      onUpdate && onUpdate(rate);\n\n      if (rate >= 1) {\n        onInterval();\n        startTime = now();\n\n        if (limit && ++count >= limit) {\n          return pause();\n        }\n      }\n\n      id = raf(update);\n    }\n  }\n\n  function start(resume) {\n    resume || cancel();\n    startTime = now() - (resume ? rate * interval : 0);\n    paused = false;\n    id = raf(update);\n  }\n\n  function pause() {\n    paused = true;\n  }\n\n  function rewind() {\n    startTime = now();\n    rate = 0;\n\n    if (onUpdate) {\n      onUpdate(rate);\n    }\n  }\n\n  function cancel() {\n    id && cancelAnimationFrame(id);\n    rate = 0;\n    id = 0;\n    paused = true;\n  }\n\n  function set(time) {\n    interval = time;\n  }\n\n  function isPaused() {\n    return paused;\n  }\n\n  return {\n    start: start,\n    rewind: rewind,\n    pause: pause,\n    cancel: cancel,\n    set: set,\n    isPaused: isPaused\n  };\n}\n\nfunction State(initialState) {\n  var state = initialState;\n\n  function set(value) {\n    state = value;\n  }\n\n  function is(states) {\n    return includes(toArray(states), state);\n  }\n\n  return {\n    set: set,\n    is: is\n  };\n}\n\nfunction Throttle(func, duration) {\n  var interval = RequestInterval(duration || 0, func, null, 1);\n  return function () {\n    interval.isPaused() && interval.start();\n  };\n}\n\nfunction Media(Splide2, Components2, options) {\n  var state = Splide2.state;\n  var breakpoints = options.breakpoints || {};\n  var reducedMotion = options.reducedMotion || {};\n  var binder = EventBinder();\n  var queries = [];\n\n  function setup() {\n    var isMin = options.mediaQuery === \"min\";\n    ownKeys(breakpoints).sort(function (n, m) {\n      return isMin ? +n - +m : +m - +n;\n    }).forEach(function (key) {\n      register(breakpoints[key], \"(\" + (isMin ? \"min\" : \"max\") + \"-width:\" + key + \"px)\");\n    });\n    register(reducedMotion, MEDIA_PREFERS_REDUCED_MOTION);\n    update();\n  }\n\n  function destroy(completely) {\n    if (completely) {\n      binder.destroy();\n    }\n  }\n\n  function register(options2, query) {\n    var queryList = matchMedia(query);\n    binder.bind(queryList, \"change\", update);\n    queries.push([options2, queryList]);\n  }\n\n  function update() {\n    var destroyed = state.is(DESTROYED);\n    var direction = options.direction;\n    var merged = queries.reduce(function (merged2, entry) {\n      return merge(merged2, entry[1].matches ? entry[0] : {});\n    }, {});\n    omit(options);\n    set(merged);\n\n    if (options.destroy) {\n      Splide2.destroy(options.destroy === \"completely\");\n    } else if (destroyed) {\n      destroy(true);\n      Splide2.mount();\n    } else {\n      direction !== options.direction && Splide2.refresh();\n    }\n  }\n\n  function reduce(enable) {\n    if (matchMedia(MEDIA_PREFERS_REDUCED_MOTION).matches) {\n      enable ? merge(options, reducedMotion) : omit(options, ownKeys(reducedMotion));\n    }\n  }\n\n  function set(opts, base, notify) {\n    merge(options, opts);\n    base && merge(Object.getPrototypeOf(options), opts);\n\n    if (notify || !state.is(CREATED)) {\n      Splide2.emit(EVENT_UPDATED, options);\n    }\n  }\n\n  return {\n    setup: setup,\n    destroy: destroy,\n    reduce: reduce,\n    set: set\n  };\n}\n\nvar ARROW = \"Arrow\";\nvar ARROW_LEFT = ARROW + \"Left\";\nvar ARROW_RIGHT = ARROW + \"Right\";\nvar ARROW_UP = ARROW + \"Up\";\nvar ARROW_DOWN = ARROW + \"Down\";\nvar LTR = \"ltr\";\nvar RTL = \"rtl\";\nvar TTB = \"ttb\";\nvar ORIENTATION_MAP = {\n  width: [\"height\"],\n  left: [\"top\", \"right\"],\n  right: [\"bottom\", \"left\"],\n  x: [\"y\"],\n  X: [\"Y\"],\n  Y: [\"X\"],\n  ArrowLeft: [ARROW_UP, ARROW_RIGHT],\n  ArrowRight: [ARROW_DOWN, ARROW_LEFT]\n};\n\nfunction Direction(Splide2, Components2, options) {\n  function resolve(prop, axisOnly, direction) {\n    direction = direction || options.direction;\n    var index = direction === RTL && !axisOnly ? 1 : direction === TTB ? 0 : -1;\n    return ORIENTATION_MAP[prop] && ORIENTATION_MAP[prop][index] || prop.replace(/width|left|right/i, function (match, offset) {\n      var replacement = ORIENTATION_MAP[match.toLowerCase()][index] || match;\n      return offset > 0 ? replacement.charAt(0).toUpperCase() + replacement.slice(1) : replacement;\n    });\n  }\n\n  function orient(value) {\n    return value * (options.direction === RTL ? 1 : -1);\n  }\n\n  return {\n    resolve: resolve,\n    orient: orient\n  };\n}\n\nvar ROLE = \"role\";\nvar TAB_INDEX = \"tabindex\";\nvar DISABLED = \"disabled\";\nvar ARIA_PREFIX = \"aria-\";\nvar ARIA_CONTROLS = ARIA_PREFIX + \"controls\";\nvar ARIA_CURRENT = ARIA_PREFIX + \"current\";\nvar ARIA_SELECTED = ARIA_PREFIX + \"selected\";\nvar ARIA_LABEL = ARIA_PREFIX + \"label\";\nvar ARIA_LABELLEDBY = ARIA_PREFIX + \"labelledby\";\nvar ARIA_HIDDEN = ARIA_PREFIX + \"hidden\";\nvar ARIA_ORIENTATION = ARIA_PREFIX + \"orientation\";\nvar ARIA_ROLEDESCRIPTION = ARIA_PREFIX + \"roledescription\";\nvar ARIA_LIVE = ARIA_PREFIX + \"live\";\nvar ARIA_BUSY = ARIA_PREFIX + \"busy\";\nvar ARIA_ATOMIC = ARIA_PREFIX + \"atomic\";\nvar ALL_ATTRIBUTES = [ROLE, TAB_INDEX, DISABLED, ARIA_CONTROLS, ARIA_CURRENT, ARIA_LABEL, ARIA_LABELLEDBY, ARIA_HIDDEN, ARIA_ORIENTATION, ARIA_ROLEDESCRIPTION];\nvar CLASS_PREFIX = PROJECT_CODE + \"__\";\nvar STATUS_CLASS_PREFIX = \"is-\";\nvar CLASS_ROOT = PROJECT_CODE;\nvar CLASS_TRACK = CLASS_PREFIX + \"track\";\nvar CLASS_LIST = CLASS_PREFIX + \"list\";\nvar CLASS_SLIDE = CLASS_PREFIX + \"slide\";\nvar CLASS_CLONE = CLASS_SLIDE + \"--clone\";\nvar CLASS_CONTAINER = CLASS_SLIDE + \"__container\";\nvar CLASS_ARROWS = CLASS_PREFIX + \"arrows\";\nvar CLASS_ARROW = CLASS_PREFIX + \"arrow\";\nvar CLASS_ARROW_PREV = CLASS_ARROW + \"--prev\";\nvar CLASS_ARROW_NEXT = CLASS_ARROW + \"--next\";\nvar CLASS_PAGINATION = CLASS_PREFIX + \"pagination\";\nvar CLASS_PAGINATION_PAGE = CLASS_PAGINATION + \"__page\";\nvar CLASS_PROGRESS = CLASS_PREFIX + \"progress\";\nvar CLASS_PROGRESS_BAR = CLASS_PROGRESS + \"__bar\";\nvar CLASS_TOGGLE = CLASS_PREFIX + \"toggle\";\nvar CLASS_TOGGLE_PLAY = CLASS_TOGGLE + \"__play\";\nvar CLASS_TOGGLE_PAUSE = CLASS_TOGGLE + \"__pause\";\nvar CLASS_SPINNER = CLASS_PREFIX + \"spinner\";\nvar CLASS_SR = CLASS_PREFIX + \"sr\";\nvar CLASS_INITIALIZED = STATUS_CLASS_PREFIX + \"initialized\";\nvar CLASS_ACTIVE = STATUS_CLASS_PREFIX + \"active\";\nvar CLASS_PREV = STATUS_CLASS_PREFIX + \"prev\";\nvar CLASS_NEXT = STATUS_CLASS_PREFIX + \"next\";\nvar CLASS_VISIBLE = STATUS_CLASS_PREFIX + \"visible\";\nvar CLASS_LOADING = STATUS_CLASS_PREFIX + \"loading\";\nvar CLASS_FOCUS_IN = STATUS_CLASS_PREFIX + \"focus-in\";\nvar CLASS_OVERFLOW = STATUS_CLASS_PREFIX + \"overflow\";\nvar STATUS_CLASSES = [CLASS_ACTIVE, CLASS_VISIBLE, CLASS_PREV, CLASS_NEXT, CLASS_LOADING, CLASS_FOCUS_IN, CLASS_OVERFLOW];\nvar CLASSES = {\n  slide: CLASS_SLIDE,\n  clone: CLASS_CLONE,\n  arrows: CLASS_ARROWS,\n  arrow: CLASS_ARROW,\n  prev: CLASS_ARROW_PREV,\n  next: CLASS_ARROW_NEXT,\n  pagination: CLASS_PAGINATION,\n  page: CLASS_PAGINATION_PAGE,\n  spinner: CLASS_SPINNER\n};\n\nfunction closest(from, selector) {\n  if (isFunction(from.closest)) {\n    return from.closest(selector);\n  }\n\n  var elm = from;\n\n  while (elm && elm.nodeType === 1) {\n    if (matches(elm, selector)) {\n      break;\n    }\n\n    elm = elm.parentElement;\n  }\n\n  return elm;\n}\n\nvar FRICTION = 5;\nvar LOG_INTERVAL = 200;\nvar POINTER_DOWN_EVENTS = \"touchstart mousedown\";\nvar POINTER_MOVE_EVENTS = \"touchmove mousemove\";\nvar POINTER_UP_EVENTS = \"touchend touchcancel mouseup click\";\n\nfunction Elements(Splide2, Components2, options) {\n  var _EventInterface = EventInterface(Splide2),\n      on = _EventInterface.on,\n      bind = _EventInterface.bind;\n\n  var root = Splide2.root;\n  var i18n = options.i18n;\n  var elements = {};\n  var slides = [];\n  var rootClasses = [];\n  var trackClasses = [];\n  var track;\n  var list;\n  var isUsingKey;\n\n  function setup() {\n    collect();\n    init();\n    update();\n  }\n\n  function mount() {\n    on(EVENT_REFRESH, destroy);\n    on(EVENT_REFRESH, setup);\n    on(EVENT_UPDATED, update);\n    bind(document, POINTER_DOWN_EVENTS + \" keydown\", function (e) {\n      isUsingKey = e.type === \"keydown\";\n    }, {\n      capture: true\n    });\n    bind(root, \"focusin\", function () {\n      toggleClass(root, CLASS_FOCUS_IN, !!isUsingKey);\n    });\n  }\n\n  function destroy(completely) {\n    var attrs = ALL_ATTRIBUTES.concat(\"style\");\n    empty(slides);\n    removeClass(root, rootClasses);\n    removeClass(track, trackClasses);\n    removeAttribute([track, list], attrs);\n    removeAttribute(root, completely ? attrs : [\"style\", ARIA_ROLEDESCRIPTION]);\n  }\n\n  function update() {\n    removeClass(root, rootClasses);\n    removeClass(track, trackClasses);\n    rootClasses = getClasses(CLASS_ROOT);\n    trackClasses = getClasses(CLASS_TRACK);\n    addClass(root, rootClasses);\n    addClass(track, trackClasses);\n    setAttribute(root, ARIA_LABEL, options.label);\n    setAttribute(root, ARIA_LABELLEDBY, options.labelledby);\n  }\n\n  function collect() {\n    track = find(\".\" + CLASS_TRACK);\n    list = child(track, \".\" + CLASS_LIST);\n    assert(track && list, \"A track/list element is missing.\");\n    push(slides, children(list, \".\" + CLASS_SLIDE + \":not(.\" + CLASS_CLONE + \")\"));\n    forOwn({\n      arrows: CLASS_ARROWS,\n      pagination: CLASS_PAGINATION,\n      prev: CLASS_ARROW_PREV,\n      next: CLASS_ARROW_NEXT,\n      bar: CLASS_PROGRESS_BAR,\n      toggle: CLASS_TOGGLE\n    }, function (className, key) {\n      elements[key] = find(\".\" + className);\n    });\n    assign(elements, {\n      root: root,\n      track: track,\n      list: list,\n      slides: slides\n    });\n  }\n\n  function init() {\n    var id = root.id || uniqueId(PROJECT_CODE);\n    var role = options.role;\n    root.id = id;\n    track.id = track.id || id + \"-track\";\n    list.id = list.id || id + \"-list\";\n\n    if (!getAttribute(root, ROLE) && root.tagName !== \"SECTION\" && role) {\n      setAttribute(root, ROLE, role);\n    }\n\n    setAttribute(root, ARIA_ROLEDESCRIPTION, i18n.carousel);\n    setAttribute(list, ROLE, \"presentation\");\n  }\n\n  function find(selector) {\n    var elm = query(root, selector);\n    return elm && closest(elm, \".\" + CLASS_ROOT) === root ? elm : void 0;\n  }\n\n  function getClasses(base) {\n    return [base + \"--\" + options.type, base + \"--\" + options.direction, options.drag && base + \"--draggable\", options.isNavigation && base + \"--nav\", base === CLASS_ROOT && CLASS_ACTIVE];\n  }\n\n  return assign(elements, {\n    setup: setup,\n    mount: mount,\n    destroy: destroy\n  });\n}\n\nvar SLIDE = \"slide\";\nvar LOOP = \"loop\";\nvar FADE = \"fade\";\n\nfunction Slide$1(Splide2, index, slideIndex, slide) {\n  var event = EventInterface(Splide2);\n  var on = event.on,\n      emit = event.emit,\n      bind = event.bind;\n  var Components = Splide2.Components,\n      root = Splide2.root,\n      options = Splide2.options;\n  var isNavigation = options.isNavigation,\n      updateOnMove = options.updateOnMove,\n      i18n = options.i18n,\n      pagination = options.pagination,\n      slideFocus = options.slideFocus;\n  var resolve = Components.Direction.resolve;\n  var styles = getAttribute(slide, \"style\");\n  var label = getAttribute(slide, ARIA_LABEL);\n  var isClone = slideIndex > -1;\n  var container = child(slide, \".\" + CLASS_CONTAINER);\n  var destroyed;\n\n  function mount() {\n    if (!isClone) {\n      slide.id = root.id + \"-slide\" + pad(index + 1);\n      setAttribute(slide, ROLE, pagination ? \"tabpanel\" : \"group\");\n      setAttribute(slide, ARIA_ROLEDESCRIPTION, i18n.slide);\n      setAttribute(slide, ARIA_LABEL, label || format(i18n.slideLabel, [index + 1, Splide2.length]));\n    }\n\n    listen();\n  }\n\n  function listen() {\n    bind(slide, \"click\", apply(emit, EVENT_CLICK, self));\n    bind(slide, \"keydown\", apply(emit, EVENT_SLIDE_KEYDOWN, self));\n    on([EVENT_MOVED, EVENT_SHIFTED, EVENT_SCROLLED], update);\n    on(EVENT_NAVIGATION_MOUNTED, initNavigation);\n\n    if (updateOnMove) {\n      on(EVENT_MOVE, onMove);\n    }\n  }\n\n  function destroy() {\n    destroyed = true;\n    event.destroy();\n    removeClass(slide, STATUS_CLASSES);\n    removeAttribute(slide, ALL_ATTRIBUTES);\n    setAttribute(slide, \"style\", styles);\n    setAttribute(slide, ARIA_LABEL, label || \"\");\n  }\n\n  function initNavigation() {\n    var controls = Splide2.splides.map(function (target) {\n      var Slide2 = target.splide.Components.Slides.getAt(index);\n      return Slide2 ? Slide2.slide.id : \"\";\n    }).join(\" \");\n    setAttribute(slide, ARIA_LABEL, format(i18n.slideX, (isClone ? slideIndex : index) + 1));\n    setAttribute(slide, ARIA_CONTROLS, controls);\n    setAttribute(slide, ROLE, slideFocus ? \"button\" : \"\");\n    slideFocus && removeAttribute(slide, ARIA_ROLEDESCRIPTION);\n  }\n\n  function onMove() {\n    if (!destroyed) {\n      update();\n    }\n  }\n\n  function update() {\n    if (!destroyed) {\n      var curr = Splide2.index;\n      updateActivity();\n      updateVisibility();\n      toggleClass(slide, CLASS_PREV, index === curr - 1);\n      toggleClass(slide, CLASS_NEXT, index === curr + 1);\n    }\n  }\n\n  function updateActivity() {\n    var active = isActive();\n\n    if (active !== hasClass(slide, CLASS_ACTIVE)) {\n      toggleClass(slide, CLASS_ACTIVE, active);\n      setAttribute(slide, ARIA_CURRENT, isNavigation && active || \"\");\n      emit(active ? EVENT_ACTIVE : EVENT_INACTIVE, self);\n    }\n  }\n\n  function updateVisibility() {\n    var visible = isVisible();\n    var hidden = !visible && (!isActive() || isClone);\n\n    if (!Splide2.state.is([MOVING, SCROLLING])) {\n      setAttribute(slide, ARIA_HIDDEN, hidden || \"\");\n    }\n\n    setAttribute(queryAll(slide, options.focusableNodes || \"\"), TAB_INDEX, hidden ? -1 : \"\");\n\n    if (slideFocus) {\n      setAttribute(slide, TAB_INDEX, hidden ? -1 : 0);\n    }\n\n    if (visible !== hasClass(slide, CLASS_VISIBLE)) {\n      toggleClass(slide, CLASS_VISIBLE, visible);\n      emit(visible ? EVENT_VISIBLE : EVENT_HIDDEN, self);\n    }\n\n    if (!visible && document.activeElement === slide) {\n      var Slide2 = Components.Slides.getAt(Splide2.index);\n      Slide2 && focus(Slide2.slide);\n    }\n  }\n\n  function style$1(prop, value, useContainer) {\n    style(useContainer && container || slide, prop, value);\n  }\n\n  function isActive() {\n    var curr = Splide2.index;\n    return curr === index || options.cloneStatus && curr === slideIndex;\n  }\n\n  function isVisible() {\n    if (Splide2.is(FADE)) {\n      return isActive();\n    }\n\n    var trackRect = rect(Components.Elements.track);\n    var slideRect = rect(slide);\n    var left = resolve(\"left\", true);\n    var right = resolve(\"right\", true);\n    return floor(trackRect[left]) <= ceil(slideRect[left]) && floor(slideRect[right]) <= ceil(trackRect[right]);\n  }\n\n  function isWithin(from, distance) {\n    var diff = abs(from - index);\n\n    if (!isClone && (options.rewind || Splide2.is(LOOP))) {\n      diff = min(diff, Splide2.length - diff);\n    }\n\n    return diff <= distance;\n  }\n\n  var self = {\n    index: index,\n    slideIndex: slideIndex,\n    slide: slide,\n    container: container,\n    isClone: isClone,\n    mount: mount,\n    destroy: destroy,\n    update: update,\n    style: style$1,\n    isWithin: isWithin\n  };\n  return self;\n}\n\nfunction Slides(Splide2, Components2, options) {\n  var _EventInterface2 = EventInterface(Splide2),\n      on = _EventInterface2.on,\n      emit = _EventInterface2.emit,\n      bind = _EventInterface2.bind;\n\n  var _Components2$Elements = Components2.Elements,\n      slides = _Components2$Elements.slides,\n      list = _Components2$Elements.list;\n  var Slides2 = [];\n\n  function mount() {\n    init();\n    on(EVENT_REFRESH, destroy);\n    on(EVENT_REFRESH, init);\n  }\n\n  function init() {\n    slides.forEach(function (slide, index) {\n      register(slide, index, -1);\n    });\n  }\n\n  function destroy() {\n    forEach$1(function (Slide2) {\n      Slide2.destroy();\n    });\n    empty(Slides2);\n  }\n\n  function update() {\n    forEach$1(function (Slide2) {\n      Slide2.update();\n    });\n  }\n\n  function register(slide, index, slideIndex) {\n    var object = Slide$1(Splide2, index, slideIndex, slide);\n    object.mount();\n    Slides2.push(object);\n    Slides2.sort(function (Slide1, Slide2) {\n      return Slide1.index - Slide2.index;\n    });\n  }\n\n  function get(excludeClones) {\n    return excludeClones ? filter(function (Slide2) {\n      return !Slide2.isClone;\n    }) : Slides2;\n  }\n\n  function getIn(page) {\n    var Controller = Components2.Controller;\n    var index = Controller.toIndex(page);\n    var max = Controller.hasFocus() ? 1 : options.perPage;\n    return filter(function (Slide2) {\n      return between(Slide2.index, index, index + max - 1);\n    });\n  }\n\n  function getAt(index) {\n    return filter(index)[0];\n  }\n\n  function add(items, index) {\n    forEach(items, function (slide) {\n      if (isString(slide)) {\n        slide = parseHtml(slide);\n      }\n\n      if (isHTMLElement(slide)) {\n        var ref = slides[index];\n        ref ? before(slide, ref) : append(list, slide);\n        addClass(slide, options.classes.slide);\n        observeImages(slide, apply(emit, EVENT_RESIZE));\n      }\n    });\n    emit(EVENT_REFRESH);\n  }\n\n  function remove$1(matcher) {\n    remove(filter(matcher).map(function (Slide2) {\n      return Slide2.slide;\n    }));\n    emit(EVENT_REFRESH);\n  }\n\n  function forEach$1(iteratee, excludeClones) {\n    get(excludeClones).forEach(iteratee);\n  }\n\n  function filter(matcher) {\n    return Slides2.filter(isFunction(matcher) ? matcher : function (Slide2) {\n      return isString(matcher) ? matches(Slide2.slide, matcher) : includes(toArray(matcher), Slide2.index);\n    });\n  }\n\n  function style(prop, value, useContainer) {\n    forEach$1(function (Slide2) {\n      Slide2.style(prop, value, useContainer);\n    });\n  }\n\n  function observeImages(elm, callback) {\n    var images = queryAll(elm, \"img\");\n    var length = images.length;\n\n    if (length) {\n      images.forEach(function (img) {\n        bind(img, \"load error\", function () {\n          if (! --length) {\n            callback();\n          }\n        });\n      });\n    } else {\n      callback();\n    }\n  }\n\n  function getLength(excludeClones) {\n    return excludeClones ? slides.length : Slides2.length;\n  }\n\n  function isEnough() {\n    return Slides2.length > options.perPage;\n  }\n\n  return {\n    mount: mount,\n    destroy: destroy,\n    update: update,\n    register: register,\n    get: get,\n    getIn: getIn,\n    getAt: getAt,\n    add: add,\n    remove: remove$1,\n    forEach: forEach$1,\n    filter: filter,\n    style: style,\n    getLength: getLength,\n    isEnough: isEnough\n  };\n}\n\nfunction Layout(Splide2, Components2, options) {\n  var _EventInterface3 = EventInterface(Splide2),\n      on = _EventInterface3.on,\n      bind = _EventInterface3.bind,\n      emit = _EventInterface3.emit;\n\n  var Slides = Components2.Slides;\n  var resolve = Components2.Direction.resolve;\n  var _Components2$Elements2 = Components2.Elements,\n      root = _Components2$Elements2.root,\n      track = _Components2$Elements2.track,\n      list = _Components2$Elements2.list;\n  var getAt = Slides.getAt,\n      styleSlides = Slides.style;\n  var vertical;\n  var rootRect;\n  var overflow;\n\n  function mount() {\n    init();\n    bind(window, \"resize load\", Throttle(apply(emit, EVENT_RESIZE)));\n    on([EVENT_UPDATED, EVENT_REFRESH], init);\n    on(EVENT_RESIZE, resize);\n  }\n\n  function init() {\n    vertical = options.direction === TTB;\n    style(root, \"maxWidth\", unit(options.width));\n    style(track, resolve(\"paddingLeft\"), cssPadding(false));\n    style(track, resolve(\"paddingRight\"), cssPadding(true));\n    resize(true);\n  }\n\n  function resize(force) {\n    var newRect = rect(root);\n\n    if (force || rootRect.width !== newRect.width || rootRect.height !== newRect.height) {\n      style(track, \"height\", cssTrackHeight());\n      styleSlides(resolve(\"marginRight\"), unit(options.gap));\n      styleSlides(\"width\", cssSlideWidth());\n      styleSlides(\"height\", cssSlideHeight(), true);\n      rootRect = newRect;\n      emit(EVENT_RESIZED);\n\n      if (overflow !== (overflow = isOverflow())) {\n        toggleClass(root, CLASS_OVERFLOW, overflow);\n        emit(EVENT_OVERFLOW, overflow);\n      }\n    }\n  }\n\n  function cssPadding(right) {\n    var padding = options.padding;\n    var prop = resolve(right ? \"right\" : \"left\");\n    return padding && unit(padding[prop] || (isObject(padding) ? 0 : padding)) || \"0px\";\n  }\n\n  function cssTrackHeight() {\n    var height = \"\";\n\n    if (vertical) {\n      height = cssHeight();\n      assert(height, \"height or heightRatio is missing.\");\n      height = \"calc(\" + height + \" - \" + cssPadding(false) + \" - \" + cssPadding(true) + \")\";\n    }\n\n    return height;\n  }\n\n  function cssHeight() {\n    return unit(options.height || rect(list).width * options.heightRatio);\n  }\n\n  function cssSlideWidth() {\n    return options.autoWidth ? null : unit(options.fixedWidth) || (vertical ? \"\" : cssSlideSize());\n  }\n\n  function cssSlideHeight() {\n    return unit(options.fixedHeight) || (vertical ? options.autoHeight ? null : cssSlideSize() : cssHeight());\n  }\n\n  function cssSlideSize() {\n    var gap = unit(options.gap);\n    return \"calc((100%\" + (gap && \" + \" + gap) + \")/\" + (options.perPage || 1) + (gap && \" - \" + gap) + \")\";\n  }\n\n  function listSize() {\n    return rect(list)[resolve(\"width\")];\n  }\n\n  function slideSize(index, withoutGap) {\n    var Slide = getAt(index || 0);\n    return Slide ? rect(Slide.slide)[resolve(\"width\")] + (withoutGap ? 0 : getGap()) : 0;\n  }\n\n  function totalSize(index, withoutGap) {\n    var Slide = getAt(index);\n\n    if (Slide) {\n      var right = rect(Slide.slide)[resolve(\"right\")];\n      var left = rect(list)[resolve(\"left\")];\n      return abs(right - left) + (withoutGap ? 0 : getGap());\n    }\n\n    return 0;\n  }\n\n  function sliderSize(withoutGap) {\n    return totalSize(Splide2.length - 1) - totalSize(0) + slideSize(0, withoutGap);\n  }\n\n  function getGap() {\n    var Slide = getAt(0);\n    return Slide && parseFloat(style(Slide.slide, resolve(\"marginRight\"))) || 0;\n  }\n\n  function getPadding(right) {\n    return parseFloat(style(track, resolve(\"padding\" + (right ? \"Right\" : \"Left\")))) || 0;\n  }\n\n  function isOverflow() {\n    return Splide2.is(FADE) || sliderSize(true) > listSize();\n  }\n\n  return {\n    mount: mount,\n    resize: resize,\n    listSize: listSize,\n    slideSize: slideSize,\n    sliderSize: sliderSize,\n    totalSize: totalSize,\n    getPadding: getPadding,\n    isOverflow: isOverflow\n  };\n}\n\nvar MULTIPLIER = 2;\n\nfunction Clones(Splide2, Components2, options) {\n  var event = EventInterface(Splide2);\n  var on = event.on;\n  var Elements = Components2.Elements,\n      Slides = Components2.Slides;\n  var resolve = Components2.Direction.resolve;\n  var clones = [];\n  var cloneCount;\n\n  function mount() {\n    on(EVENT_REFRESH, remount);\n    on([EVENT_UPDATED, EVENT_RESIZE], observe);\n\n    if (cloneCount = computeCloneCount()) {\n      generate(cloneCount);\n      Components2.Layout.resize(true);\n    }\n  }\n\n  function remount() {\n    destroy();\n    mount();\n  }\n\n  function destroy() {\n    remove(clones);\n    empty(clones);\n    event.destroy();\n  }\n\n  function observe() {\n    var count = computeCloneCount();\n\n    if (cloneCount !== count) {\n      if (cloneCount < count || !count) {\n        event.emit(EVENT_REFRESH);\n      }\n    }\n  }\n\n  function generate(count) {\n    var slides = Slides.get().slice();\n    var length = slides.length;\n\n    if (length) {\n      while (slides.length < count) {\n        push(slides, slides);\n      }\n\n      push(slides.slice(-count), slides.slice(0, count)).forEach(function (Slide, index) {\n        var isHead = index < count;\n        var clone = cloneDeep(Slide.slide, index);\n        isHead ? before(clone, slides[0].slide) : append(Elements.list, clone);\n        push(clones, clone);\n        Slides.register(clone, index - count + (isHead ? 0 : length), Slide.index);\n      });\n    }\n  }\n\n  function cloneDeep(elm, index) {\n    var clone = elm.cloneNode(true);\n    addClass(clone, options.classes.clone);\n    clone.id = Splide2.root.id + \"-clone\" + pad(index + 1);\n    return clone;\n  }\n\n  function computeCloneCount() {\n    var clones2 = options.clones;\n\n    if (!Splide2.is(LOOP)) {\n      clones2 = 0;\n    } else if (isUndefined(clones2)) {\n      var fixedSize = options[resolve(\"fixedWidth\")] && Components2.Layout.slideSize(0);\n      var fixedCount = fixedSize && ceil(rect(Elements.track)[resolve(\"width\")] / fixedSize);\n      clones2 = fixedCount || options[resolve(\"autoWidth\")] && Splide2.length || options.perPage * MULTIPLIER;\n    }\n\n    return clones2;\n  }\n\n  return {\n    mount: mount,\n    destroy: destroy\n  };\n}\n\nfunction Move(Splide2, Components2, options) {\n  var _EventInterface4 = EventInterface(Splide2),\n      on = _EventInterface4.on,\n      emit = _EventInterface4.emit;\n\n  var set = Splide2.state.set;\n  var _Components2$Layout = Components2.Layout,\n      slideSize = _Components2$Layout.slideSize,\n      getPadding = _Components2$Layout.getPadding,\n      totalSize = _Components2$Layout.totalSize,\n      listSize = _Components2$Layout.listSize,\n      sliderSize = _Components2$Layout.sliderSize;\n  var _Components2$Directio = Components2.Direction,\n      resolve = _Components2$Directio.resolve,\n      orient = _Components2$Directio.orient;\n  var _Components2$Elements3 = Components2.Elements,\n      list = _Components2$Elements3.list,\n      track = _Components2$Elements3.track;\n  var Transition;\n\n  function mount() {\n    Transition = Components2.Transition;\n    on([EVENT_MOUNTED, EVENT_RESIZED, EVENT_UPDATED, EVENT_REFRESH], reposition);\n  }\n\n  function reposition() {\n    if (!Components2.Controller.isBusy()) {\n      Components2.Scroll.cancel();\n      jump(Splide2.index);\n      Components2.Slides.update();\n    }\n  }\n\n  function move(dest, index, prev, callback) {\n    if (dest !== index && canShift(dest > prev)) {\n      cancel();\n      translate(shift(getPosition(), dest > prev), true);\n    }\n\n    set(MOVING);\n    emit(EVENT_MOVE, index, prev, dest);\n    Transition.start(index, function () {\n      set(IDLE);\n      emit(EVENT_MOVED, index, prev, dest);\n      callback && callback();\n    });\n  }\n\n  function jump(index) {\n    translate(toPosition(index, true));\n  }\n\n  function translate(position, preventLoop) {\n    if (!Splide2.is(FADE)) {\n      var destination = preventLoop ? position : loop(position);\n      style(list, \"transform\", \"translate\" + resolve(\"X\") + \"(\" + destination + \"px)\");\n      position !== destination && emit(EVENT_SHIFTED);\n    }\n  }\n\n  function loop(position) {\n    if (Splide2.is(LOOP)) {\n      var index = toIndex(position);\n      var exceededMax = index > Components2.Controller.getEnd();\n      var exceededMin = index < 0;\n\n      if (exceededMin || exceededMax) {\n        position = shift(position, exceededMax);\n      }\n    }\n\n    return position;\n  }\n\n  function shift(position, backwards) {\n    var excess = position - getLimit(backwards);\n    var size = sliderSize();\n    position -= orient(size * (ceil(abs(excess) / size) || 1)) * (backwards ? 1 : -1);\n    return position;\n  }\n\n  function cancel() {\n    translate(getPosition(), true);\n    Transition.cancel();\n  }\n\n  function toIndex(position) {\n    var Slides = Components2.Slides.get();\n    var index = 0;\n    var minDistance = Infinity;\n\n    for (var i = 0; i < Slides.length; i++) {\n      var slideIndex = Slides[i].index;\n      var distance = abs(toPosition(slideIndex, true) - position);\n\n      if (distance <= minDistance) {\n        minDistance = distance;\n        index = slideIndex;\n      } else {\n        break;\n      }\n    }\n\n    return index;\n  }\n\n  function toPosition(index, trimming) {\n    var position = orient(totalSize(index - 1) - offset(index));\n    return trimming ? trim(position) : position;\n  }\n\n  function getPosition() {\n    var left = resolve(\"left\");\n    return rect(list)[left] - rect(track)[left] + orient(getPadding(false));\n  }\n\n  function trim(position) {\n    if (options.trimSpace && Splide2.is(SLIDE)) {\n      position = clamp(position, 0, orient(sliderSize(true) - listSize()));\n    }\n\n    return position;\n  }\n\n  function offset(index) {\n    var focus = options.focus;\n    return focus === \"center\" ? (listSize() - slideSize(index, true)) / 2 : +focus * slideSize(index) || 0;\n  }\n\n  function getLimit(max) {\n    return toPosition(max ? Components2.Controller.getEnd() : 0, !!options.trimSpace);\n  }\n\n  function canShift(backwards) {\n    var shifted = orient(shift(getPosition(), backwards));\n    return backwards ? shifted >= 0 : shifted <= list[resolve(\"scrollWidth\")] - rect(track)[resolve(\"width\")];\n  }\n\n  function exceededLimit(max, position) {\n    position = isUndefined(position) ? getPosition() : position;\n    var exceededMin = max !== true && orient(position) < orient(getLimit(false));\n    var exceededMax = max !== false && orient(position) > orient(getLimit(true));\n    return exceededMin || exceededMax;\n  }\n\n  return {\n    mount: mount,\n    move: move,\n    jump: jump,\n    translate: translate,\n    shift: shift,\n    cancel: cancel,\n    toIndex: toIndex,\n    toPosition: toPosition,\n    getPosition: getPosition,\n    getLimit: getLimit,\n    exceededLimit: exceededLimit,\n    reposition: reposition\n  };\n}\n\nfunction Controller(Splide2, Components2, options) {\n  var _EventInterface5 = EventInterface(Splide2),\n      on = _EventInterface5.on,\n      emit = _EventInterface5.emit;\n\n  var Move = Components2.Move;\n  var getPosition = Move.getPosition,\n      getLimit = Move.getLimit,\n      toPosition = Move.toPosition;\n  var _Components2$Slides = Components2.Slides,\n      isEnough = _Components2$Slides.isEnough,\n      getLength = _Components2$Slides.getLength;\n  var omitEnd = options.omitEnd;\n  var isLoop = Splide2.is(LOOP);\n  var isSlide = Splide2.is(SLIDE);\n  var getNext = apply(getAdjacent, false);\n  var getPrev = apply(getAdjacent, true);\n  var currIndex = options.start || 0;\n  var endIndex;\n  var prevIndex = currIndex;\n  var slideCount;\n  var perMove;\n  var perPage;\n\n  function mount() {\n    init();\n    on([EVENT_UPDATED, EVENT_REFRESH, EVENT_END_INDEX_CHANGED], init);\n    on(EVENT_RESIZED, onResized);\n  }\n\n  function init() {\n    slideCount = getLength(true);\n    perMove = options.perMove;\n    perPage = options.perPage;\n    endIndex = getEnd();\n    var index = clamp(currIndex, 0, omitEnd ? endIndex : slideCount - 1);\n\n    if (index !== currIndex) {\n      currIndex = index;\n      Move.reposition();\n    }\n  }\n\n  function onResized() {\n    if (endIndex !== getEnd()) {\n      emit(EVENT_END_INDEX_CHANGED);\n    }\n  }\n\n  function go(control, allowSameIndex, callback) {\n    if (!isBusy()) {\n      var dest = parse(control);\n      var index = loop(dest);\n\n      if (index > -1 && (allowSameIndex || index !== currIndex)) {\n        setIndex(index);\n        Move.move(dest, index, prevIndex, callback);\n      }\n    }\n  }\n\n  function scroll(destination, duration, snap, callback) {\n    Components2.Scroll.scroll(destination, duration, snap, function () {\n      var index = loop(Move.toIndex(getPosition()));\n      setIndex(omitEnd ? min(index, endIndex) : index);\n      callback && callback();\n    });\n  }\n\n  function parse(control) {\n    var index = currIndex;\n\n    if (isString(control)) {\n      var _ref = control.match(/([+\\-<>])(\\d+)?/) || [],\n          indicator = _ref[1],\n          number = _ref[2];\n\n      if (indicator === \"+\" || indicator === \"-\") {\n        index = computeDestIndex(currIndex + +(\"\" + indicator + (+number || 1)), currIndex);\n      } else if (indicator === \">\") {\n        index = number ? toIndex(+number) : getNext(true);\n      } else if (indicator === \"<\") {\n        index = getPrev(true);\n      }\n    } else {\n      index = isLoop ? control : clamp(control, 0, endIndex);\n    }\n\n    return index;\n  }\n\n  function getAdjacent(prev, destination) {\n    var number = perMove || (hasFocus() ? 1 : perPage);\n    var dest = computeDestIndex(currIndex + number * (prev ? -1 : 1), currIndex, !(perMove || hasFocus()));\n\n    if (dest === -1 && isSlide) {\n      if (!approximatelyEqual(getPosition(), getLimit(!prev), 1)) {\n        return prev ? 0 : endIndex;\n      }\n    }\n\n    return destination ? dest : loop(dest);\n  }\n\n  function computeDestIndex(dest, from, snapPage) {\n    if (isEnough() || hasFocus()) {\n      var index = computeMovableDestIndex(dest);\n\n      if (index !== dest) {\n        from = dest;\n        dest = index;\n        snapPage = false;\n      }\n\n      if (dest < 0 || dest > endIndex) {\n        if (!perMove && (between(0, dest, from, true) || between(endIndex, from, dest, true))) {\n          dest = toIndex(toPage(dest));\n        } else {\n          if (isLoop) {\n            dest = snapPage ? dest < 0 ? -(slideCount % perPage || perPage) : slideCount : dest;\n          } else if (options.rewind) {\n            dest = dest < 0 ? endIndex : 0;\n          } else {\n            dest = -1;\n          }\n        }\n      } else {\n        if (snapPage && dest !== from) {\n          dest = toIndex(toPage(from) + (dest < from ? -1 : 1));\n        }\n      }\n    } else {\n      dest = -1;\n    }\n\n    return dest;\n  }\n\n  function computeMovableDestIndex(dest) {\n    if (isSlide && options.trimSpace === \"move\" && dest !== currIndex) {\n      var position = getPosition();\n\n      while (position === toPosition(dest, true) && between(dest, 0, Splide2.length - 1, !options.rewind)) {\n        dest < currIndex ? --dest : ++dest;\n      }\n    }\n\n    return dest;\n  }\n\n  function loop(index) {\n    return isLoop ? (index + slideCount) % slideCount || 0 : index;\n  }\n\n  function getEnd() {\n    var end = slideCount - (hasFocus() || isLoop && perMove ? 1 : perPage);\n\n    while (omitEnd && end-- > 0) {\n      if (toPosition(slideCount - 1, true) !== toPosition(end, true)) {\n        end++;\n        break;\n      }\n    }\n\n    return clamp(end, 0, slideCount - 1);\n  }\n\n  function toIndex(page) {\n    return clamp(hasFocus() ? page : perPage * page, 0, endIndex);\n  }\n\n  function toPage(index) {\n    return hasFocus() ? min(index, endIndex) : floor((index >= endIndex ? slideCount - 1 : index) / perPage);\n  }\n\n  function toDest(destination) {\n    var closest = Move.toIndex(destination);\n    return isSlide ? clamp(closest, 0, endIndex) : closest;\n  }\n\n  function setIndex(index) {\n    if (index !== currIndex) {\n      prevIndex = currIndex;\n      currIndex = index;\n    }\n  }\n\n  function getIndex(prev) {\n    return prev ? prevIndex : currIndex;\n  }\n\n  function hasFocus() {\n    return !isUndefined(options.focus) || options.isNavigation;\n  }\n\n  function isBusy() {\n    return Splide2.state.is([MOVING, SCROLLING]) && !!options.waitForTransition;\n  }\n\n  return {\n    mount: mount,\n    go: go,\n    scroll: scroll,\n    getNext: getNext,\n    getPrev: getPrev,\n    getAdjacent: getAdjacent,\n    getEnd: getEnd,\n    setIndex: setIndex,\n    getIndex: getIndex,\n    toIndex: toIndex,\n    toPage: toPage,\n    toDest: toDest,\n    hasFocus: hasFocus,\n    isBusy: isBusy\n  };\n}\n\nvar XML_NAME_SPACE = \"http://www.w3.org/2000/svg\";\nvar 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\";\nvar SIZE = 40;\n\nfunction Arrows(Splide2, Components2, options) {\n  var event = EventInterface(Splide2);\n  var on = event.on,\n      bind = event.bind,\n      emit = event.emit;\n  var classes = options.classes,\n      i18n = options.i18n;\n  var Elements = Components2.Elements,\n      Controller = Components2.Controller;\n  var placeholder = Elements.arrows,\n      track = Elements.track;\n  var wrapper = placeholder;\n  var prev = Elements.prev;\n  var next = Elements.next;\n  var created;\n  var wrapperClasses;\n  var arrows = {};\n\n  function mount() {\n    init();\n    on(EVENT_UPDATED, remount);\n  }\n\n  function remount() {\n    destroy();\n    mount();\n  }\n\n  function init() {\n    var enabled = options.arrows;\n\n    if (enabled && !(prev && next)) {\n      createArrows();\n    }\n\n    if (prev && next) {\n      assign(arrows, {\n        prev: prev,\n        next: next\n      });\n      display(wrapper, enabled ? \"\" : \"none\");\n      addClass(wrapper, wrapperClasses = CLASS_ARROWS + \"--\" + options.direction);\n\n      if (enabled) {\n        listen();\n        update();\n        setAttribute([prev, next], ARIA_CONTROLS, track.id);\n        emit(EVENT_ARROWS_MOUNTED, prev, next);\n      }\n    }\n  }\n\n  function destroy() {\n    event.destroy();\n    removeClass(wrapper, wrapperClasses);\n\n    if (created) {\n      remove(placeholder ? [prev, next] : wrapper);\n      prev = next = null;\n    } else {\n      removeAttribute([prev, next], ALL_ATTRIBUTES);\n    }\n  }\n\n  function listen() {\n    on([EVENT_MOUNTED, EVENT_MOVED, EVENT_REFRESH, EVENT_SCROLLED, EVENT_END_INDEX_CHANGED], update);\n    bind(next, \"click\", apply(go, \">\"));\n    bind(prev, \"click\", apply(go, \"<\"));\n  }\n\n  function go(control) {\n    Controller.go(control, true);\n  }\n\n  function createArrows() {\n    wrapper = placeholder || create(\"div\", classes.arrows);\n    prev = createArrow(true);\n    next = createArrow(false);\n    created = true;\n    append(wrapper, [prev, next]);\n    !placeholder && before(wrapper, track);\n  }\n\n  function createArrow(prev2) {\n    var arrow = \"<button class=\\\"\" + classes.arrow + \" \" + (prev2 ? classes.prev : classes.next) + \"\\\" type=\\\"button\\\"><svg xmlns=\\\"\" + XML_NAME_SPACE + \"\\\" viewBox=\\\"0 0 \" + SIZE + \" \" + SIZE + \"\\\" width=\\\"\" + SIZE + \"\\\" height=\\\"\" + SIZE + \"\\\" focusable=\\\"false\\\"><path d=\\\"\" + (options.arrowPath || PATH) + \"\\\" />\";\n    return parseHtml(arrow);\n  }\n\n  function update() {\n    if (prev && next) {\n      var index = Splide2.index;\n      var prevIndex = Controller.getPrev();\n      var nextIndex = Controller.getNext();\n      var prevLabel = prevIndex > -1 && index < prevIndex ? i18n.last : i18n.prev;\n      var nextLabel = nextIndex > -1 && index > nextIndex ? i18n.first : i18n.next;\n      prev.disabled = prevIndex < 0;\n      next.disabled = nextIndex < 0;\n      setAttribute(prev, ARIA_LABEL, prevLabel);\n      setAttribute(next, ARIA_LABEL, nextLabel);\n      emit(EVENT_ARROWS_UPDATED, prev, next, prevIndex, nextIndex);\n    }\n  }\n\n  return {\n    arrows: arrows,\n    mount: mount,\n    destroy: destroy,\n    update: update\n  };\n}\n\nvar INTERVAL_DATA_ATTRIBUTE = DATA_ATTRIBUTE + \"-interval\";\n\nfunction Autoplay(Splide2, Components2, options) {\n  var _EventInterface6 = EventInterface(Splide2),\n      on = _EventInterface6.on,\n      bind = _EventInterface6.bind,\n      emit = _EventInterface6.emit;\n\n  var interval = RequestInterval(options.interval, Splide2.go.bind(Splide2, \">\"), onAnimationFrame);\n  var isPaused = interval.isPaused;\n  var Elements = Components2.Elements,\n      _Components2$Elements4 = Components2.Elements,\n      root = _Components2$Elements4.root,\n      toggle = _Components2$Elements4.toggle;\n  var autoplay = options.autoplay;\n  var hovered;\n  var focused;\n  var stopped = autoplay === \"pause\";\n\n  function mount() {\n    if (autoplay) {\n      listen();\n      toggle && setAttribute(toggle, ARIA_CONTROLS, Elements.track.id);\n      stopped || play();\n      update();\n    }\n  }\n\n  function listen() {\n    if (options.pauseOnHover) {\n      bind(root, \"mouseenter mouseleave\", function (e) {\n        hovered = e.type === \"mouseenter\";\n        autoToggle();\n      });\n    }\n\n    if (options.pauseOnFocus) {\n      bind(root, \"focusin focusout\", function (e) {\n        focused = e.type === \"focusin\";\n        autoToggle();\n      });\n    }\n\n    if (toggle) {\n      bind(toggle, \"click\", function () {\n        stopped ? play() : pause(true);\n      });\n    }\n\n    on([EVENT_MOVE, EVENT_SCROLL, EVENT_REFRESH], interval.rewind);\n    on(EVENT_MOVE, onMove);\n  }\n\n  function play() {\n    if (isPaused() && Components2.Slides.isEnough()) {\n      interval.start(!options.resetProgress);\n      focused = hovered = stopped = false;\n      update();\n      emit(EVENT_AUTOPLAY_PLAY);\n    }\n  }\n\n  function pause(stop) {\n    if (stop === void 0) {\n      stop = true;\n    }\n\n    stopped = !!stop;\n    update();\n\n    if (!isPaused()) {\n      interval.pause();\n      emit(EVENT_AUTOPLAY_PAUSE);\n    }\n  }\n\n  function autoToggle() {\n    if (!stopped) {\n      hovered || focused ? pause(false) : play();\n    }\n  }\n\n  function update() {\n    if (toggle) {\n      toggleClass(toggle, CLASS_ACTIVE, !stopped);\n      setAttribute(toggle, ARIA_LABEL, options.i18n[stopped ? \"play\" : \"pause\"]);\n    }\n  }\n\n  function onAnimationFrame(rate) {\n    var bar = Elements.bar;\n    bar && style(bar, \"width\", rate * 100 + \"%\");\n    emit(EVENT_AUTOPLAY_PLAYING, rate);\n  }\n\n  function onMove(index) {\n    var Slide = Components2.Slides.getAt(index);\n    interval.set(Slide && +getAttribute(Slide.slide, INTERVAL_DATA_ATTRIBUTE) || options.interval);\n  }\n\n  return {\n    mount: mount,\n    destroy: interval.cancel,\n    play: play,\n    pause: pause,\n    isPaused: isPaused\n  };\n}\n\nfunction Cover(Splide2, Components2, options) {\n  var _EventInterface7 = EventInterface(Splide2),\n      on = _EventInterface7.on;\n\n  function mount() {\n    if (options.cover) {\n      on(EVENT_LAZYLOAD_LOADED, apply(toggle, true));\n      on([EVENT_MOUNTED, EVENT_UPDATED, EVENT_REFRESH], apply(cover, true));\n    }\n  }\n\n  function cover(cover2) {\n    Components2.Slides.forEach(function (Slide) {\n      var img = child(Slide.container || Slide.slide, \"img\");\n\n      if (img && img.src) {\n        toggle(cover2, img, Slide);\n      }\n    });\n  }\n\n  function toggle(cover2, img, Slide) {\n    Slide.style(\"background\", cover2 ? \"center/cover no-repeat url(\\\"\" + img.src + \"\\\")\" : \"\", true);\n    display(img, cover2 ? \"none\" : \"\");\n  }\n\n  return {\n    mount: mount,\n    destroy: apply(cover, false)\n  };\n}\n\nvar BOUNCE_DIFF_THRESHOLD = 10;\nvar BOUNCE_DURATION = 600;\nvar FRICTION_FACTOR = 0.6;\nvar BASE_VELOCITY = 1.5;\nvar MIN_DURATION = 800;\n\nfunction Scroll(Splide2, Components2, options) {\n  var _EventInterface8 = EventInterface(Splide2),\n      on = _EventInterface8.on,\n      emit = _EventInterface8.emit;\n\n  var set = Splide2.state.set;\n  var Move = Components2.Move;\n  var getPosition = Move.getPosition,\n      getLimit = Move.getLimit,\n      exceededLimit = Move.exceededLimit,\n      translate = Move.translate;\n  var isSlide = Splide2.is(SLIDE);\n  var interval;\n  var callback;\n  var friction = 1;\n\n  function mount() {\n    on(EVENT_MOVE, clear);\n    on([EVENT_UPDATED, EVENT_REFRESH], cancel);\n  }\n\n  function scroll(destination, duration, snap, onScrolled, noConstrain) {\n    var from = getPosition();\n    clear();\n\n    if (snap && (!isSlide || !exceededLimit())) {\n      var size = Components2.Layout.sliderSize();\n      var offset = sign(destination) * size * floor(abs(destination) / size) || 0;\n      destination = Move.toPosition(Components2.Controller.toDest(destination % size)) + offset;\n    }\n\n    var noDistance = approximatelyEqual(from, destination, 1);\n    friction = 1;\n    duration = noDistance ? 0 : duration || max(abs(destination - from) / BASE_VELOCITY, MIN_DURATION);\n    callback = onScrolled;\n    interval = RequestInterval(duration, onEnd, apply(update, from, destination, noConstrain), 1);\n    set(SCROLLING);\n    emit(EVENT_SCROLL);\n    interval.start();\n  }\n\n  function onEnd() {\n    set(IDLE);\n    callback && callback();\n    emit(EVENT_SCROLLED);\n  }\n\n  function update(from, to, noConstrain, rate) {\n    var position = getPosition();\n    var target = from + (to - from) * easing(rate);\n    var diff = (target - position) * friction;\n    translate(position + diff);\n\n    if (isSlide && !noConstrain && exceededLimit()) {\n      friction *= FRICTION_FACTOR;\n\n      if (abs(diff) < BOUNCE_DIFF_THRESHOLD) {\n        scroll(getLimit(exceededLimit(true)), BOUNCE_DURATION, false, callback, true);\n      }\n    }\n  }\n\n  function clear() {\n    if (interval) {\n      interval.cancel();\n    }\n  }\n\n  function cancel() {\n    if (interval && !interval.isPaused()) {\n      clear();\n      onEnd();\n    }\n  }\n\n  function easing(t) {\n    var easingFunc = options.easingFunc;\n    return easingFunc ? easingFunc(t) : 1 - Math.pow(1 - t, 4);\n  }\n\n  return {\n    mount: mount,\n    destroy: clear,\n    scroll: scroll,\n    cancel: cancel\n  };\n}\n\nvar SCROLL_LISTENER_OPTIONS = {\n  passive: false,\n  capture: true\n};\n\nfunction Drag(Splide2, Components2, options) {\n  var _EventInterface9 = EventInterface(Splide2),\n      on = _EventInterface9.on,\n      emit = _EventInterface9.emit,\n      bind = _EventInterface9.bind,\n      unbind = _EventInterface9.unbind;\n\n  var state = Splide2.state;\n  var Move = Components2.Move,\n      Scroll = Components2.Scroll,\n      Controller = Components2.Controller,\n      track = Components2.Elements.track,\n      reduce = Components2.Media.reduce;\n  var _Components2$Directio2 = Components2.Direction,\n      resolve = _Components2$Directio2.resolve,\n      orient = _Components2$Directio2.orient;\n  var getPosition = Move.getPosition,\n      exceededLimit = Move.exceededLimit;\n  var basePosition;\n  var baseEvent;\n  var prevBaseEvent;\n  var isFree;\n  var dragging;\n  var exceeded = false;\n  var clickPrevented;\n  var disabled;\n  var target;\n\n  function mount() {\n    bind(track, POINTER_MOVE_EVENTS, noop, SCROLL_LISTENER_OPTIONS);\n    bind(track, POINTER_UP_EVENTS, noop, SCROLL_LISTENER_OPTIONS);\n    bind(track, POINTER_DOWN_EVENTS, onPointerDown, SCROLL_LISTENER_OPTIONS);\n    bind(track, \"click\", onClick, {\n      capture: true\n    });\n    bind(track, \"dragstart\", prevent);\n    on([EVENT_MOUNTED, EVENT_UPDATED], init);\n  }\n\n  function init() {\n    var drag = options.drag;\n    disable(!drag);\n    isFree = drag === \"free\";\n  }\n\n  function onPointerDown(e) {\n    clickPrevented = false;\n\n    if (!disabled) {\n      var isTouch = isTouchEvent(e);\n\n      if (isDraggable(e.target) && (isTouch || !e.button)) {\n        if (!Controller.isBusy()) {\n          target = isTouch ? track : window;\n          dragging = state.is([MOVING, SCROLLING]);\n          prevBaseEvent = null;\n          bind(target, POINTER_MOVE_EVENTS, onPointerMove, SCROLL_LISTENER_OPTIONS);\n          bind(target, POINTER_UP_EVENTS, onPointerUp, SCROLL_LISTENER_OPTIONS);\n          Move.cancel();\n          Scroll.cancel();\n          save(e);\n        } else {\n          prevent(e, true);\n        }\n      }\n    }\n  }\n\n  function onPointerMove(e) {\n    if (!state.is(DRAGGING)) {\n      state.set(DRAGGING);\n      emit(EVENT_DRAG);\n    }\n\n    if (e.cancelable) {\n      if (dragging) {\n        Move.translate(basePosition + constrain(diffCoord(e)));\n        var expired = diffTime(e) > LOG_INTERVAL;\n        var hasExceeded = exceeded !== (exceeded = exceededLimit());\n\n        if (expired || hasExceeded) {\n          save(e);\n        }\n\n        clickPrevented = true;\n        emit(EVENT_DRAGGING);\n        prevent(e);\n      } else if (isSliderDirection(e)) {\n        dragging = shouldStart(e);\n        prevent(e);\n      }\n    }\n  }\n\n  function onPointerUp(e) {\n    if (state.is(DRAGGING)) {\n      state.set(IDLE);\n      emit(EVENT_DRAGGED);\n    }\n\n    if (dragging) {\n      move(e);\n      prevent(e);\n    }\n\n    unbind(target, POINTER_MOVE_EVENTS, onPointerMove);\n    unbind(target, POINTER_UP_EVENTS, onPointerUp);\n    dragging = false;\n  }\n\n  function onClick(e) {\n    if (!disabled && clickPrevented) {\n      prevent(e, true);\n    }\n  }\n\n  function save(e) {\n    prevBaseEvent = baseEvent;\n    baseEvent = e;\n    basePosition = getPosition();\n  }\n\n  function move(e) {\n    var velocity = computeVelocity(e);\n    var destination = computeDestination(velocity);\n    var rewind = options.rewind && options.rewindByDrag;\n    reduce(false);\n\n    if (isFree) {\n      Controller.scroll(destination, 0, options.snap);\n    } else if (Splide2.is(FADE)) {\n      Controller.go(orient(sign(velocity)) < 0 ? rewind ? \"<\" : \"-\" : rewind ? \">\" : \"+\");\n    } else if (Splide2.is(SLIDE) && exceeded && rewind) {\n      Controller.go(exceededLimit(true) ? \">\" : \"<\");\n    } else {\n      Controller.go(Controller.toDest(destination), true);\n    }\n\n    reduce(true);\n  }\n\n  function shouldStart(e) {\n    var thresholds = options.dragMinThreshold;\n    var isObj = isObject(thresholds);\n    var mouse = isObj && thresholds.mouse || 0;\n    var touch = (isObj ? thresholds.touch : +thresholds) || 10;\n    return abs(diffCoord(e)) > (isTouchEvent(e) ? touch : mouse);\n  }\n\n  function isSliderDirection(e) {\n    return abs(diffCoord(e)) > abs(diffCoord(e, true));\n  }\n\n  function computeVelocity(e) {\n    if (Splide2.is(LOOP) || !exceeded) {\n      var time = diffTime(e);\n\n      if (time && time < LOG_INTERVAL) {\n        return diffCoord(e) / time;\n      }\n    }\n\n    return 0;\n  }\n\n  function computeDestination(velocity) {\n    return getPosition() + sign(velocity) * min(abs(velocity) * (options.flickPower || 600), isFree ? Infinity : Components2.Layout.listSize() * (options.flickMaxPages || 1));\n  }\n\n  function diffCoord(e, orthogonal) {\n    return coordOf(e, orthogonal) - coordOf(getBaseEvent(e), orthogonal);\n  }\n\n  function diffTime(e) {\n    return timeOf(e) - timeOf(getBaseEvent(e));\n  }\n\n  function getBaseEvent(e) {\n    return baseEvent === e && prevBaseEvent || baseEvent;\n  }\n\n  function coordOf(e, orthogonal) {\n    return (isTouchEvent(e) ? e.changedTouches[0] : e)[\"page\" + resolve(orthogonal ? \"Y\" : \"X\")];\n  }\n\n  function constrain(diff) {\n    return diff / (exceeded && Splide2.is(SLIDE) ? FRICTION : 1);\n  }\n\n  function isDraggable(target2) {\n    var noDrag = options.noDrag;\n    return !matches(target2, \".\" + CLASS_PAGINATION_PAGE + \", .\" + CLASS_ARROW) && (!noDrag || !matches(target2, noDrag));\n  }\n\n  function isTouchEvent(e) {\n    return typeof TouchEvent !== \"undefined\" && e instanceof TouchEvent;\n  }\n\n  function isDragging() {\n    return dragging;\n  }\n\n  function disable(value) {\n    disabled = value;\n  }\n\n  return {\n    mount: mount,\n    disable: disable,\n    isDragging: isDragging\n  };\n}\n\nvar NORMALIZATION_MAP = {\n  Spacebar: \" \",\n  Right: ARROW_RIGHT,\n  Left: ARROW_LEFT,\n  Up: ARROW_UP,\n  Down: ARROW_DOWN\n};\n\nfunction normalizeKey(key) {\n  key = isString(key) ? key : key.key;\n  return NORMALIZATION_MAP[key] || key;\n}\n\nvar KEYBOARD_EVENT = \"keydown\";\n\nfunction Keyboard(Splide2, Components2, options) {\n  var _EventInterface10 = EventInterface(Splide2),\n      on = _EventInterface10.on,\n      bind = _EventInterface10.bind,\n      unbind = _EventInterface10.unbind;\n\n  var root = Splide2.root;\n  var resolve = Components2.Direction.resolve;\n  var target;\n  var disabled;\n\n  function mount() {\n    init();\n    on(EVENT_UPDATED, destroy);\n    on(EVENT_UPDATED, init);\n    on(EVENT_MOVE, onMove);\n  }\n\n  function init() {\n    var keyboard = options.keyboard;\n\n    if (keyboard) {\n      target = keyboard === \"global\" ? window : root;\n      bind(target, KEYBOARD_EVENT, onKeydown);\n    }\n  }\n\n  function destroy() {\n    unbind(target, KEYBOARD_EVENT);\n  }\n\n  function disable(value) {\n    disabled = value;\n  }\n\n  function onMove() {\n    var _disabled = disabled;\n    disabled = true;\n    nextTick(function () {\n      disabled = _disabled;\n    });\n  }\n\n  function onKeydown(e) {\n    if (!disabled) {\n      var key = normalizeKey(e);\n\n      if (key === resolve(ARROW_LEFT)) {\n        Splide2.go(\"<\");\n      } else if (key === resolve(ARROW_RIGHT)) {\n        Splide2.go(\">\");\n      }\n    }\n  }\n\n  return {\n    mount: mount,\n    destroy: destroy,\n    disable: disable\n  };\n}\n\nvar SRC_DATA_ATTRIBUTE = DATA_ATTRIBUTE + \"-lazy\";\nvar SRCSET_DATA_ATTRIBUTE = SRC_DATA_ATTRIBUTE + \"-srcset\";\nvar IMAGE_SELECTOR = \"[\" + SRC_DATA_ATTRIBUTE + \"], [\" + SRCSET_DATA_ATTRIBUTE + \"]\";\n\nfunction LazyLoad(Splide2, Components2, options) {\n  var _EventInterface11 = EventInterface(Splide2),\n      on = _EventInterface11.on,\n      off = _EventInterface11.off,\n      bind = _EventInterface11.bind,\n      emit = _EventInterface11.emit;\n\n  var isSequential = options.lazyLoad === \"sequential\";\n  var events = [EVENT_MOVED, EVENT_SCROLLED];\n  var entries = [];\n\n  function mount() {\n    if (options.lazyLoad) {\n      init();\n      on(EVENT_REFRESH, init);\n    }\n  }\n\n  function init() {\n    empty(entries);\n    register();\n\n    if (isSequential) {\n      loadNext();\n    } else {\n      off(events);\n      on(events, check);\n      check();\n    }\n  }\n\n  function register() {\n    Components2.Slides.forEach(function (Slide) {\n      queryAll(Slide.slide, IMAGE_SELECTOR).forEach(function (img) {\n        var src = getAttribute(img, SRC_DATA_ATTRIBUTE);\n        var srcset = getAttribute(img, SRCSET_DATA_ATTRIBUTE);\n\n        if (src !== img.src || srcset !== img.srcset) {\n          var className = options.classes.spinner;\n          var parent = img.parentElement;\n          var spinner = child(parent, \".\" + className) || create(\"span\", className, parent);\n          entries.push([img, Slide, spinner]);\n          img.src || display(img, \"none\");\n        }\n      });\n    });\n  }\n\n  function check() {\n    entries = entries.filter(function (data) {\n      var distance = options.perPage * ((options.preloadPages || 1) + 1) - 1;\n      return data[1].isWithin(Splide2.index, distance) ? load(data) : true;\n    });\n    entries.length || off(events);\n  }\n\n  function load(data) {\n    var img = data[0];\n    addClass(data[1].slide, CLASS_LOADING);\n    bind(img, \"load error\", apply(onLoad, data));\n    setAttribute(img, \"src\", getAttribute(img, SRC_DATA_ATTRIBUTE));\n    setAttribute(img, \"srcset\", getAttribute(img, SRCSET_DATA_ATTRIBUTE));\n    removeAttribute(img, SRC_DATA_ATTRIBUTE);\n    removeAttribute(img, SRCSET_DATA_ATTRIBUTE);\n  }\n\n  function onLoad(data, e) {\n    var img = data[0],\n        Slide = data[1];\n    removeClass(Slide.slide, CLASS_LOADING);\n\n    if (e.type !== \"error\") {\n      remove(data[2]);\n      display(img, \"\");\n      emit(EVENT_LAZYLOAD_LOADED, img, Slide);\n      emit(EVENT_RESIZE);\n    }\n\n    isSequential && loadNext();\n  }\n\n  function loadNext() {\n    entries.length && load(entries.shift());\n  }\n\n  return {\n    mount: mount,\n    destroy: apply(empty, entries),\n    check: check\n  };\n}\n\nfunction Pagination(Splide2, Components2, options) {\n  var event = EventInterface(Splide2);\n  var on = event.on,\n      emit = event.emit,\n      bind = event.bind;\n  var Slides = Components2.Slides,\n      Elements = Components2.Elements,\n      Controller = Components2.Controller;\n  var hasFocus = Controller.hasFocus,\n      getIndex = Controller.getIndex,\n      go = Controller.go;\n  var resolve = Components2.Direction.resolve;\n  var placeholder = Elements.pagination;\n  var items = [];\n  var list;\n  var paginationClasses;\n\n  function mount() {\n    destroy();\n    on([EVENT_UPDATED, EVENT_REFRESH, EVENT_END_INDEX_CHANGED], mount);\n    var enabled = options.pagination;\n    placeholder && display(placeholder, enabled ? \"\" : \"none\");\n\n    if (enabled) {\n      on([EVENT_MOVE, EVENT_SCROLL, EVENT_SCROLLED], update);\n      createPagination();\n      update();\n      emit(EVENT_PAGINATION_MOUNTED, {\n        list: list,\n        items: items\n      }, getAt(Splide2.index));\n    }\n  }\n\n  function destroy() {\n    if (list) {\n      remove(placeholder ? slice(list.children) : list);\n      removeClass(list, paginationClasses);\n      empty(items);\n      list = null;\n    }\n\n    event.destroy();\n  }\n\n  function createPagination() {\n    var length = Splide2.length;\n    var classes = options.classes,\n        i18n = options.i18n,\n        perPage = options.perPage;\n    var max = hasFocus() ? Controller.getEnd() + 1 : ceil(length / perPage);\n    list = placeholder || create(\"ul\", classes.pagination, Elements.track.parentElement);\n    addClass(list, paginationClasses = CLASS_PAGINATION + \"--\" + getDirection());\n    setAttribute(list, ROLE, \"tablist\");\n    setAttribute(list, ARIA_LABEL, i18n.select);\n    setAttribute(list, ARIA_ORIENTATION, getDirection() === TTB ? \"vertical\" : \"\");\n\n    for (var i = 0; i < max; i++) {\n      var li = create(\"li\", null, list);\n      var button = create(\"button\", {\n        class: classes.page,\n        type: \"button\"\n      }, li);\n      var controls = Slides.getIn(i).map(function (Slide) {\n        return Slide.slide.id;\n      });\n      var text = !hasFocus() && perPage > 1 ? i18n.pageX : i18n.slideX;\n      bind(button, \"click\", apply(onClick, i));\n\n      if (options.paginationKeyboard) {\n        bind(button, \"keydown\", apply(onKeydown, i));\n      }\n\n      setAttribute(li, ROLE, \"presentation\");\n      setAttribute(button, ROLE, \"tab\");\n      setAttribute(button, ARIA_CONTROLS, controls.join(\" \"));\n      setAttribute(button, ARIA_LABEL, format(text, i + 1));\n      setAttribute(button, TAB_INDEX, -1);\n      items.push({\n        li: li,\n        button: button,\n        page: i\n      });\n    }\n  }\n\n  function onClick(page) {\n    go(\">\" + page, true);\n  }\n\n  function onKeydown(page, e) {\n    var length = items.length;\n    var key = normalizeKey(e);\n    var dir = getDirection();\n    var nextPage = -1;\n\n    if (key === resolve(ARROW_RIGHT, false, dir)) {\n      nextPage = ++page % length;\n    } else if (key === resolve(ARROW_LEFT, false, dir)) {\n      nextPage = (--page + length) % length;\n    } else if (key === \"Home\") {\n      nextPage = 0;\n    } else if (key === \"End\") {\n      nextPage = length - 1;\n    }\n\n    var item = items[nextPage];\n\n    if (item) {\n      focus(item.button);\n      go(\">\" + nextPage);\n      prevent(e, true);\n    }\n  }\n\n  function getDirection() {\n    return options.paginationDirection || options.direction;\n  }\n\n  function getAt(index) {\n    return items[Controller.toPage(index)];\n  }\n\n  function update() {\n    var prev = getAt(getIndex(true));\n    var curr = getAt(getIndex());\n\n    if (prev) {\n      var button = prev.button;\n      removeClass(button, CLASS_ACTIVE);\n      removeAttribute(button, ARIA_SELECTED);\n      setAttribute(button, TAB_INDEX, -1);\n    }\n\n    if (curr) {\n      var _button = curr.button;\n      addClass(_button, CLASS_ACTIVE);\n      setAttribute(_button, ARIA_SELECTED, true);\n      setAttribute(_button, TAB_INDEX, \"\");\n    }\n\n    emit(EVENT_PAGINATION_UPDATED, {\n      list: list,\n      items: items\n    }, prev, curr);\n  }\n\n  return {\n    items: items,\n    mount: mount,\n    destroy: destroy,\n    getAt: getAt,\n    update: update\n  };\n}\n\nvar TRIGGER_KEYS = [\" \", \"Enter\"];\n\nfunction Sync(Splide2, Components2, options) {\n  var isNavigation = options.isNavigation,\n      slideFocus = options.slideFocus;\n  var events = [];\n\n  function mount() {\n    Splide2.splides.forEach(function (target) {\n      if (!target.isParent) {\n        sync(Splide2, target.splide);\n        sync(target.splide, Splide2);\n      }\n    });\n\n    if (isNavigation) {\n      navigate();\n    }\n  }\n\n  function destroy() {\n    events.forEach(function (event) {\n      event.destroy();\n    });\n    empty(events);\n  }\n\n  function remount() {\n    destroy();\n    mount();\n  }\n\n  function sync(splide, target) {\n    var event = EventInterface(splide);\n    event.on(EVENT_MOVE, function (index, prev, dest) {\n      target.go(target.is(LOOP) ? dest : index);\n    });\n    events.push(event);\n  }\n\n  function navigate() {\n    var event = EventInterface(Splide2);\n    var on = event.on;\n    on(EVENT_CLICK, onClick);\n    on(EVENT_SLIDE_KEYDOWN, onKeydown);\n    on([EVENT_MOUNTED, EVENT_UPDATED], update);\n    events.push(event);\n    event.emit(EVENT_NAVIGATION_MOUNTED, Splide2.splides);\n  }\n\n  function update() {\n    setAttribute(Components2.Elements.list, ARIA_ORIENTATION, options.direction === TTB ? \"vertical\" : \"\");\n  }\n\n  function onClick(Slide) {\n    Splide2.go(Slide.index);\n  }\n\n  function onKeydown(Slide, e) {\n    if (includes(TRIGGER_KEYS, normalizeKey(e))) {\n      onClick(Slide);\n      prevent(e);\n    }\n  }\n\n  return {\n    setup: apply(Components2.Media.set, {\n      slideFocus: isUndefined(slideFocus) ? isNavigation : slideFocus\n    }, true),\n    mount: mount,\n    destroy: destroy,\n    remount: remount\n  };\n}\n\nfunction Wheel(Splide2, Components2, options) {\n  var _EventInterface12 = EventInterface(Splide2),\n      bind = _EventInterface12.bind;\n\n  var lastTime = 0;\n\n  function mount() {\n    if (options.wheel) {\n      bind(Components2.Elements.track, \"wheel\", onWheel, SCROLL_LISTENER_OPTIONS);\n    }\n  }\n\n  function onWheel(e) {\n    if (e.cancelable) {\n      var deltaY = e.deltaY;\n      var backwards = deltaY < 0;\n      var timeStamp = timeOf(e);\n\n      var _min = options.wheelMinThreshold || 0;\n\n      var sleep = options.wheelSleep || 0;\n\n      if (abs(deltaY) > _min && timeStamp - lastTime > sleep) {\n        Splide2.go(backwards ? \"<\" : \">\");\n        lastTime = timeStamp;\n      }\n\n      shouldPrevent(backwards) && prevent(e);\n    }\n  }\n\n  function shouldPrevent(backwards) {\n    return !options.releaseWheel || Splide2.state.is(MOVING) || Components2.Controller.getAdjacent(backwards) !== -1;\n  }\n\n  return {\n    mount: mount\n  };\n}\n\nvar SR_REMOVAL_DELAY = 90;\n\nfunction Live(Splide2, Components2, options) {\n  var _EventInterface13 = EventInterface(Splide2),\n      on = _EventInterface13.on;\n\n  var track = Components2.Elements.track;\n  var enabled = options.live && !options.isNavigation;\n  var sr = create(\"span\", CLASS_SR);\n  var interval = RequestInterval(SR_REMOVAL_DELAY, apply(toggle, false));\n\n  function mount() {\n    if (enabled) {\n      disable(!Components2.Autoplay.isPaused());\n      setAttribute(track, ARIA_ATOMIC, true);\n      sr.textContent = \"\\u2026\";\n      on(EVENT_AUTOPLAY_PLAY, apply(disable, true));\n      on(EVENT_AUTOPLAY_PAUSE, apply(disable, false));\n      on([EVENT_MOVED, EVENT_SCROLLED], apply(toggle, true));\n    }\n  }\n\n  function toggle(active) {\n    setAttribute(track, ARIA_BUSY, active);\n\n    if (active) {\n      append(track, sr);\n      interval.start();\n    } else {\n      remove(sr);\n      interval.cancel();\n    }\n  }\n\n  function destroy() {\n    removeAttribute(track, [ARIA_LIVE, ARIA_ATOMIC, ARIA_BUSY]);\n    remove(sr);\n  }\n\n  function disable(disabled) {\n    if (enabled) {\n      setAttribute(track, ARIA_LIVE, disabled ? \"off\" : \"polite\");\n    }\n  }\n\n  return {\n    mount: mount,\n    disable: disable,\n    destroy: destroy\n  };\n}\n\nvar ComponentConstructors = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  Media: Media,\n  Direction: Direction,\n  Elements: Elements,\n  Slides: Slides,\n  Layout: Layout,\n  Clones: Clones,\n  Move: Move,\n  Controller: Controller,\n  Arrows: Arrows,\n  Autoplay: Autoplay,\n  Cover: Cover,\n  Scroll: Scroll,\n  Drag: Drag,\n  Keyboard: Keyboard,\n  LazyLoad: LazyLoad,\n  Pagination: Pagination,\n  Sync: Sync,\n  Wheel: Wheel,\n  Live: Live\n});\nvar 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  carousel: \"carousel\",\n  slide: \"slide\",\n  select: \"Select a slide to show\",\n  slideLabel: \"%s of %s\"\n};\nvar DEFAULTS = {\n  type: \"slide\",\n  role: \"region\",\n  speed: 400,\n  perPage: 1,\n  cloneStatus: true,\n  arrows: true,\n  pagination: true,\n  paginationKeyboard: true,\n  interval: 5e3,\n  pauseOnHover: true,\n  pauseOnFocus: true,\n  resetProgress: true,\n  easing: \"cubic-bezier(0.25, 1, 0.5, 1)\",\n  drag: true,\n  direction: \"ltr\",\n  trimSpace: true,\n  focusableNodes: \"a, button, textarea, input, select, iframe\",\n  live: true,\n  classes: CLASSES,\n  i18n: I18N,\n  reducedMotion: {\n    speed: 0,\n    rewindSpeed: 0,\n    autoplay: \"pause\"\n  }\n};\n\nfunction Fade(Splide2, Components2, options) {\n  var Slides = Components2.Slides;\n\n  function mount() {\n    EventInterface(Splide2).on([EVENT_MOUNTED, EVENT_REFRESH], init);\n  }\n\n  function init() {\n    Slides.forEach(function (Slide) {\n      Slide.style(\"transform\", \"translateX(-\" + 100 * Slide.index + \"%)\");\n    });\n  }\n\n  function start(index, done) {\n    Slides.style(\"transition\", \"opacity \" + options.speed + \"ms \" + options.easing);\n    nextTick(done);\n  }\n\n  return {\n    mount: mount,\n    start: start,\n    cancel: noop\n  };\n}\n\nfunction Slide(Splide2, Components2, options) {\n  var Move = Components2.Move,\n      Controller = Components2.Controller,\n      Scroll = Components2.Scroll;\n  var list = Components2.Elements.list;\n  var transition = apply(style, list, \"transition\");\n  var endCallback;\n\n  function mount() {\n    EventInterface(Splide2).bind(list, \"transitionend\", function (e) {\n      if (e.target === list && endCallback) {\n        cancel();\n        endCallback();\n      }\n    });\n  }\n\n  function start(index, done) {\n    var destination = Move.toPosition(index, true);\n    var position = Move.getPosition();\n    var speed = getSpeed(index);\n\n    if (abs(destination - position) >= 1 && speed >= 1) {\n      if (options.useScroll) {\n        Scroll.scroll(destination, speed, false, done);\n      } else {\n        transition(\"transform \" + speed + \"ms \" + options.easing);\n        Move.translate(destination, true);\n        endCallback = done;\n      }\n    } else {\n      Move.jump(index);\n      done();\n    }\n  }\n\n  function cancel() {\n    transition(\"\");\n    Scroll.cancel();\n  }\n\n  function getSpeed(index) {\n    var rewindSpeed = options.rewindSpeed;\n\n    if (Splide2.is(SLIDE) && rewindSpeed) {\n      var prev = Controller.getIndex(true);\n      var end = Controller.getEnd();\n\n      if (prev === 0 && index >= end || prev >= end && index === 0) {\n        return rewindSpeed;\n      }\n    }\n\n    return options.speed;\n  }\n\n  return {\n    mount: mount,\n    start: start,\n    cancel: cancel\n  };\n}\n\nvar _Splide = /*#__PURE__*/function () {\n  function _Splide(target, options) {\n    this.event = EventInterface();\n    this.Components = {};\n    this.state = State(CREATED);\n    this.splides = [];\n    this._o = {};\n    this._E = {};\n    var root = isString(target) ? query(document, target) : target;\n    assert(root, root + \" is invalid.\");\n    this.root = root;\n    options = merge({\n      label: getAttribute(root, ARIA_LABEL) || \"\",\n      labelledby: getAttribute(root, ARIA_LABELLEDBY) || \"\"\n    }, DEFAULTS, _Splide.defaults, options || {});\n\n    try {\n      merge(options, JSON.parse(getAttribute(root, DATA_ATTRIBUTE)));\n    } catch (e) {\n      assert(false, \"Invalid JSON\");\n    }\n\n    this._o = Object.create(merge({}, options));\n  }\n\n  var _proto = _Splide.prototype;\n\n  _proto.mount = function mount(Extensions, Transition) {\n    var _this = this;\n\n    var state = this.state,\n        Components2 = this.Components;\n    assert(state.is([CREATED, DESTROYED]), \"Already mounted!\");\n    state.set(CREATED);\n    this._C = Components2;\n    this._T = Transition || this._T || (this.is(FADE) ? Fade : Slide);\n    this._E = Extensions || this._E;\n    var Constructors = assign({}, ComponentConstructors, this._E, {\n      Transition: this._T\n    });\n    forOwn(Constructors, function (Component, key) {\n      var component = Component(_this, Components2, _this._o);\n      Components2[key] = component;\n      component.setup && component.setup();\n    });\n    forOwn(Components2, function (component) {\n      component.mount && component.mount();\n    });\n    this.emit(EVENT_MOUNTED);\n    addClass(this.root, CLASS_INITIALIZED);\n    state.set(IDLE);\n    this.emit(EVENT_READY);\n    return this;\n  };\n\n  _proto.sync = function sync(splide) {\n    this.splides.push({\n      splide: splide\n    });\n    splide.splides.push({\n      splide: this,\n      isParent: true\n    });\n\n    if (this.state.is(IDLE)) {\n      this._C.Sync.remount();\n\n      splide.Components.Sync.remount();\n    }\n\n    return this;\n  };\n\n  _proto.go = function go(control) {\n    this._C.Controller.go(control);\n\n    return this;\n  };\n\n  _proto.on = function on(events, callback) {\n    this.event.on(events, callback);\n    return this;\n  };\n\n  _proto.off = function off(events) {\n    this.event.off(events);\n    return this;\n  };\n\n  _proto.emit = function emit(event) {\n    var _this$event;\n\n    (_this$event = this.event).emit.apply(_this$event, [event].concat(slice(arguments, 1)));\n\n    return this;\n  };\n\n  _proto.add = function add(slides, index) {\n    this._C.Slides.add(slides, index);\n\n    return this;\n  };\n\n  _proto.remove = function remove(matcher) {\n    this._C.Slides.remove(matcher);\n\n    return this;\n  };\n\n  _proto.is = function is(type) {\n    return this._o.type === type;\n  };\n\n  _proto.refresh = function refresh() {\n    this.emit(EVENT_REFRESH);\n    return this;\n  };\n\n  _proto.destroy = function destroy(completely) {\n    if (completely === void 0) {\n      completely = true;\n    }\n\n    var event = this.event,\n        state = this.state;\n\n    if (state.is(CREATED)) {\n      EventInterface(this).on(EVENT_READY, this.destroy.bind(this, completely));\n    } else {\n      forOwn(this._C, function (component) {\n        component.destroy && component.destroy(completely);\n      }, true);\n      event.emit(EVENT_DESTROY);\n      event.destroy();\n      completely && empty(this.splides);\n      state.set(DESTROYED);\n    }\n\n    return this;\n  };\n\n  _createClass(_Splide, [{\n    key: \"options\",\n    get: function get() {\n      return this._o;\n    },\n    set: function set(options) {\n      this._C.Media.set(options, true, true);\n    }\n  }, {\n    key: \"length\",\n    get: function get() {\n      return this._C.Slides.getLength(true);\n    }\n  }, {\n    key: \"index\",\n    get: function get() {\n      return this._C.Controller.getIndex();\n    }\n  }]);\n\n  return _Splide;\n}();\n\nvar Splide = _Splide;\nSplide.defaults = {};\nSplide.STATES = STATES;\nvar CLASS_RENDERED = \"is-rendered\";\nvar RENDERER_DEFAULT_CONFIG = {\n  listTag: \"ul\",\n  slideTag: \"li\"\n};\n\nvar Style = /*#__PURE__*/function () {\n  function Style(id, options) {\n    this.styles = {};\n    this.id = id;\n    this.options = options;\n  }\n\n  var _proto2 = Style.prototype;\n\n  _proto2.rule = function rule(selector, prop, value, breakpoint) {\n    breakpoint = breakpoint || \"default\";\n    var selectors = this.styles[breakpoint] = this.styles[breakpoint] || {};\n    var styles = selectors[selector] = selectors[selector] || {};\n    styles[prop] = value;\n  };\n\n  _proto2.build = function build() {\n    var _this2 = this;\n\n    var css = \"\";\n\n    if (this.styles.default) {\n      css += this.buildSelectors(this.styles.default);\n    }\n\n    Object.keys(this.styles).sort(function (n, m) {\n      return _this2.options.mediaQuery === \"min\" ? +n - +m : +m - +n;\n    }).forEach(function (breakpoint) {\n      if (breakpoint !== \"default\") {\n        css += \"@media screen and (max-width: \" + breakpoint + \"px) {\";\n        css += _this2.buildSelectors(_this2.styles[breakpoint]);\n        css += \"}\";\n      }\n    });\n    return css;\n  };\n\n  _proto2.buildSelectors = function buildSelectors(selectors) {\n    var _this3 = this;\n\n    var css = \"\";\n    forOwn(selectors, function (styles, selector) {\n      selector = (\"#\" + _this3.id + \" \" + selector).trim();\n      css += selector + \" {\";\n      forOwn(styles, function (value, prop) {\n        if (value || value === 0) {\n          css += prop + \": \" + value + \";\";\n        }\n      });\n      css += \"}\";\n    });\n    return css;\n  };\n\n  return Style;\n}();\n\nvar SplideRenderer = /*#__PURE__*/function () {\n  function SplideRenderer(contents, options, config, defaults) {\n    this.slides = [];\n    this.options = {};\n    this.breakpoints = [];\n    merge(DEFAULTS, defaults || {});\n    merge(merge(this.options, DEFAULTS), options || {});\n    this.contents = contents;\n    this.config = assign({}, RENDERER_DEFAULT_CONFIG, config || {});\n    this.id = this.config.id || uniqueId(\"splide\");\n    this.Style = new Style(this.id, this.options);\n    this.Direction = Direction(null, null, this.options);\n    assert(this.contents.length, \"Provide at least 1 content.\");\n    this.init();\n  }\n\n  SplideRenderer.clean = function clean(splide) {\n    var _EventInterface14 = EventInterface(splide),\n        on = _EventInterface14.on;\n\n    var root = splide.root;\n    var clones = queryAll(root, \".\" + CLASS_CLONE);\n    on(EVENT_MOUNTED, function () {\n      remove(child(root, \"style\"));\n    });\n    remove(clones);\n  };\n\n  var _proto3 = SplideRenderer.prototype;\n\n  _proto3.init = function init() {\n    this.parseBreakpoints();\n    this.initSlides();\n    this.registerRootStyles();\n    this.registerTrackStyles();\n    this.registerSlideStyles();\n    this.registerListStyles();\n  };\n\n  _proto3.initSlides = function initSlides() {\n    var _this4 = this;\n\n    push(this.slides, this.contents.map(function (content, index) {\n      content = isString(content) ? {\n        html: content\n      } : content;\n      content.styles = content.styles || {};\n      content.attrs = content.attrs || {};\n\n      _this4.cover(content);\n\n      var classes = _this4.options.classes.slide + \" \" + (index === 0 ? CLASS_ACTIVE : \"\");\n      assign(content.attrs, {\n        class: (classes + \" \" + (content.attrs.class || \"\")).trim(),\n        style: _this4.buildStyles(content.styles)\n      });\n      return content;\n    }));\n\n    if (this.isLoop()) {\n      this.generateClones(this.slides);\n    }\n  };\n\n  _proto3.registerRootStyles = function registerRootStyles() {\n    var _this5 = this;\n\n    this.breakpoints.forEach(function (_ref2) {\n      var width = _ref2[0],\n          options = _ref2[1];\n\n      _this5.Style.rule(\" \", \"max-width\", unit(options.width), width);\n    });\n  };\n\n  _proto3.registerTrackStyles = function registerTrackStyles() {\n    var _this6 = this;\n\n    var Style2 = this.Style;\n    var selector = \".\" + CLASS_TRACK;\n    this.breakpoints.forEach(function (_ref3) {\n      var width = _ref3[0],\n          options = _ref3[1];\n      Style2.rule(selector, _this6.resolve(\"paddingLeft\"), _this6.cssPadding(options, false), width);\n      Style2.rule(selector, _this6.resolve(\"paddingRight\"), _this6.cssPadding(options, true), width);\n      Style2.rule(selector, \"height\", _this6.cssTrackHeight(options), width);\n    });\n  };\n\n  _proto3.registerListStyles = function registerListStyles() {\n    var _this7 = this;\n\n    var Style2 = this.Style;\n    var selector = \".\" + CLASS_LIST;\n    this.breakpoints.forEach(function (_ref4) {\n      var width = _ref4[0],\n          options = _ref4[1];\n      Style2.rule(selector, \"transform\", _this7.buildTranslate(options), width);\n\n      if (!_this7.cssSlideHeight(options)) {\n        Style2.rule(selector, \"aspect-ratio\", _this7.cssAspectRatio(options), width);\n      }\n    });\n  };\n\n  _proto3.registerSlideStyles = function registerSlideStyles() {\n    var _this8 = this;\n\n    var Style2 = this.Style;\n    var selector = \".\" + CLASS_SLIDE;\n    this.breakpoints.forEach(function (_ref5) {\n      var width = _ref5[0],\n          options = _ref5[1];\n      Style2.rule(selector, \"width\", _this8.cssSlideWidth(options), width);\n      Style2.rule(selector, \"height\", _this8.cssSlideHeight(options) || \"100%\", width);\n      Style2.rule(selector, _this8.resolve(\"marginRight\"), unit(options.gap) || \"0px\", width);\n      Style2.rule(selector + \" > img\", \"display\", options.cover ? \"none\" : \"inline\", width);\n    });\n  };\n\n  _proto3.buildTranslate = function buildTranslate(options) {\n    var _this$Direction = this.Direction,\n        resolve = _this$Direction.resolve,\n        orient = _this$Direction.orient;\n    var values = [];\n    values.push(this.cssOffsetClones(options));\n    values.push(this.cssOffsetGaps(options));\n\n    if (this.isCenter(options)) {\n      values.push(this.buildCssValue(orient(-50), \"%\"));\n      values.push.apply(values, this.cssOffsetCenter(options));\n    }\n\n    return values.filter(Boolean).map(function (value) {\n      return \"translate\" + resolve(\"X\") + \"(\" + value + \")\";\n    }).join(\" \");\n  };\n\n  _proto3.cssOffsetClones = function cssOffsetClones(options) {\n    var _this$Direction2 = this.Direction,\n        resolve = _this$Direction2.resolve,\n        orient = _this$Direction2.orient;\n    var cloneCount = this.getCloneCount();\n\n    if (this.isFixedWidth(options)) {\n      var _this$parseCssValue = this.parseCssValue(options[resolve(\"fixedWidth\")]),\n          value = _this$parseCssValue.value,\n          unit2 = _this$parseCssValue.unit;\n\n      return this.buildCssValue(orient(value) * cloneCount, unit2);\n    }\n\n    var percent = 100 * cloneCount / options.perPage;\n    return orient(percent) + \"%\";\n  };\n\n  _proto3.cssOffsetCenter = function cssOffsetCenter(options) {\n    var _this$Direction3 = this.Direction,\n        resolve = _this$Direction3.resolve,\n        orient = _this$Direction3.orient;\n\n    if (this.isFixedWidth(options)) {\n      var _this$parseCssValue2 = this.parseCssValue(options[resolve(\"fixedWidth\")]),\n          value = _this$parseCssValue2.value,\n          unit2 = _this$parseCssValue2.unit;\n\n      return [this.buildCssValue(orient(value / 2), unit2)];\n    }\n\n    var values = [];\n    var perPage = options.perPage,\n        gap = options.gap;\n    values.push(orient(50 / perPage) + \"%\");\n\n    if (gap) {\n      var _this$parseCssValue3 = this.parseCssValue(gap),\n          _value = _this$parseCssValue3.value,\n          _unit = _this$parseCssValue3.unit;\n\n      var gapOffset = (_value / perPage - _value) / 2;\n      values.push(this.buildCssValue(orient(gapOffset), _unit));\n    }\n\n    return values;\n  };\n\n  _proto3.cssOffsetGaps = function cssOffsetGaps(options) {\n    var cloneCount = this.getCloneCount();\n\n    if (cloneCount && options.gap) {\n      var orient = this.Direction.orient;\n\n      var _this$parseCssValue4 = this.parseCssValue(options.gap),\n          value = _this$parseCssValue4.value,\n          unit2 = _this$parseCssValue4.unit;\n\n      if (this.isFixedWidth(options)) {\n        return this.buildCssValue(orient(value * cloneCount), unit2);\n      }\n\n      var perPage = options.perPage;\n      var gaps = cloneCount / perPage;\n      return this.buildCssValue(orient(gaps * value), unit2);\n    }\n\n    return \"\";\n  };\n\n  _proto3.resolve = function resolve(prop) {\n    return camelToKebab(this.Direction.resolve(prop));\n  };\n\n  _proto3.cssPadding = function cssPadding(options, right) {\n    var padding = options.padding;\n    var prop = this.Direction.resolve(right ? \"right\" : \"left\", true);\n    return padding && unit(padding[prop] || (isObject(padding) ? 0 : padding)) || \"0px\";\n  };\n\n  _proto3.cssTrackHeight = function cssTrackHeight(options) {\n    var height = \"\";\n\n    if (this.isVertical()) {\n      height = this.cssHeight(options);\n      assert(height, '\"height\" is missing.');\n      height = \"calc(\" + height + \" - \" + this.cssPadding(options, false) + \" - \" + this.cssPadding(options, true) + \")\";\n    }\n\n    return height;\n  };\n\n  _proto3.cssHeight = function cssHeight(options) {\n    return unit(options.height);\n  };\n\n  _proto3.cssSlideWidth = function cssSlideWidth(options) {\n    return options.autoWidth ? \"\" : unit(options.fixedWidth) || (this.isVertical() ? \"\" : this.cssSlideSize(options));\n  };\n\n  _proto3.cssSlideHeight = function cssSlideHeight(options) {\n    return unit(options.fixedHeight) || (this.isVertical() ? options.autoHeight ? \"\" : this.cssSlideSize(options) : this.cssHeight(options));\n  };\n\n  _proto3.cssSlideSize = function cssSlideSize(options) {\n    var gap = unit(options.gap);\n    return \"calc((100%\" + (gap && \" + \" + gap) + \")/\" + (options.perPage || 1) + (gap && \" - \" + gap) + \")\";\n  };\n\n  _proto3.cssAspectRatio = function cssAspectRatio(options) {\n    var heightRatio = options.heightRatio;\n    return heightRatio ? \"\" + 1 / heightRatio : \"\";\n  };\n\n  _proto3.buildCssValue = function buildCssValue(value, unit2) {\n    return \"\" + value + unit2;\n  };\n\n  _proto3.parseCssValue = function parseCssValue(value) {\n    if (isString(value)) {\n      var number = parseFloat(value) || 0;\n      var unit2 = value.replace(/\\d*(\\.\\d*)?/, \"\") || \"px\";\n      return {\n        value: number,\n        unit: unit2\n      };\n    }\n\n    return {\n      value: value,\n      unit: \"px\"\n    };\n  };\n\n  _proto3.parseBreakpoints = function parseBreakpoints() {\n    var _this9 = this;\n\n    var breakpoints = this.options.breakpoints;\n    this.breakpoints.push([\"default\", this.options]);\n\n    if (breakpoints) {\n      forOwn(breakpoints, function (options, width) {\n        _this9.breakpoints.push([width, merge(merge({}, _this9.options), options)]);\n      });\n    }\n  };\n\n  _proto3.isFixedWidth = function isFixedWidth(options) {\n    return !!options[this.Direction.resolve(\"fixedWidth\")];\n  };\n\n  _proto3.isLoop = function isLoop() {\n    return this.options.type === LOOP;\n  };\n\n  _proto3.isCenter = function isCenter(options) {\n    if (options.focus === \"center\") {\n      if (this.isLoop()) {\n        return true;\n      }\n\n      if (this.options.type === SLIDE) {\n        return !this.options.trimSpace;\n      }\n    }\n\n    return false;\n  };\n\n  _proto3.isVertical = function isVertical() {\n    return this.options.direction === TTB;\n  };\n\n  _proto3.buildClasses = function buildClasses() {\n    var options = this.options;\n    return [CLASS_ROOT, CLASS_ROOT + \"--\" + options.type, CLASS_ROOT + \"--\" + options.direction, options.drag && CLASS_ROOT + \"--draggable\", options.isNavigation && CLASS_ROOT + \"--nav\", CLASS_ACTIVE, !this.config.hidden && CLASS_RENDERED].filter(Boolean).join(\" \");\n  };\n\n  _proto3.buildAttrs = function buildAttrs(attrs) {\n    var attr = \"\";\n    forOwn(attrs, function (value, key) {\n      attr += value ? \" \" + camelToKebab(key) + \"=\\\"\" + value + \"\\\"\" : \"\";\n    });\n    return attr.trim();\n  };\n\n  _proto3.buildStyles = function buildStyles(styles) {\n    var style = \"\";\n    forOwn(styles, function (value, key) {\n      style += \" \" + camelToKebab(key) + \":\" + value + \";\";\n    });\n    return style.trim();\n  };\n\n  _proto3.renderSlides = function renderSlides() {\n    var _this10 = this;\n\n    var tag = this.config.slideTag;\n    return this.slides.map(function (content) {\n      return \"<\" + tag + \" \" + _this10.buildAttrs(content.attrs) + \">\" + (content.html || \"\") + \"</\" + tag + \">\";\n    }).join(\"\");\n  };\n\n  _proto3.cover = function cover(content) {\n    var styles = content.styles,\n        _content$html = content.html,\n        html = _content$html === void 0 ? \"\" : _content$html;\n\n    if (this.options.cover && !this.options.lazyLoad) {\n      var src = html.match(/<img.*?src\\s*=\\s*(['\"])(.+?)\\1.*?>/);\n\n      if (src && src[2]) {\n        styles.background = \"center/cover no-repeat url('\" + src[2] + \"')\";\n      }\n    }\n  };\n\n  _proto3.generateClones = function generateClones(contents) {\n    var classes = this.options.classes;\n    var count = this.getCloneCount();\n    var slides = contents.slice();\n\n    while (slides.length < count) {\n      push(slides, slides);\n    }\n\n    push(slides.slice(-count).reverse(), slides.slice(0, count)).forEach(function (content, index) {\n      var attrs = assign({}, content.attrs, {\n        class: content.attrs.class + \" \" + classes.clone\n      });\n      var clone = assign({}, content, {\n        attrs: attrs\n      });\n      index < count ? contents.unshift(clone) : contents.push(clone);\n    });\n  };\n\n  _proto3.getCloneCount = function getCloneCount() {\n    if (this.isLoop()) {\n      var options = this.options;\n\n      if (options.clones) {\n        return options.clones;\n      }\n\n      var perPage = max.apply(void 0, this.breakpoints.map(function (_ref6) {\n        var options2 = _ref6[1];\n        return options2.perPage;\n      }));\n      return perPage * ((options.flickMaxPages || 1) + 1);\n    }\n\n    return 0;\n  };\n\n  _proto3.renderArrows = function renderArrows() {\n    var html = \"\";\n    html += \"<div class=\\\"\" + this.options.classes.arrows + \"\\\">\";\n    html += this.renderArrow(true);\n    html += this.renderArrow(false);\n    html += \"</div>\";\n    return html;\n  };\n\n  _proto3.renderArrow = function renderArrow(prev) {\n    var _this$options = this.options,\n        classes = _this$options.classes,\n        i18n = _this$options.i18n;\n    var attrs = {\n      class: classes.arrow + \" \" + (prev ? classes.prev : classes.next),\n      type: \"button\",\n      ariaLabel: prev ? i18n.prev : i18n.next\n    };\n    return \"<button \" + this.buildAttrs(attrs) + \"><svg xmlns=\\\"\" + XML_NAME_SPACE + \"\\\" viewBox=\\\"0 0 \" + SIZE + \" \" + SIZE + \"\\\" width=\\\"\" + SIZE + \"\\\" height=\\\"\" + SIZE + \"\\\"><path d=\\\"\" + (this.options.arrowPath || PATH) + \"\\\" /></svg></button>\";\n  };\n\n  _proto3.html = function html() {\n    var _this$config = this.config,\n        rootClass = _this$config.rootClass,\n        listTag = _this$config.listTag,\n        arrows = _this$config.arrows,\n        beforeTrack = _this$config.beforeTrack,\n        afterTrack = _this$config.afterTrack,\n        slider = _this$config.slider,\n        beforeSlider = _this$config.beforeSlider,\n        afterSlider = _this$config.afterSlider;\n    var html = \"\";\n    html += \"<div id=\\\"\" + this.id + \"\\\" class=\\\"\" + this.buildClasses() + \" \" + (rootClass || \"\") + \"\\\">\";\n    html += \"<style>\" + this.Style.build() + \"</style>\";\n\n    if (slider) {\n      html += beforeSlider || \"\";\n      html += \"<div class=\\\"splide__slider\\\">\";\n    }\n\n    html += beforeTrack || \"\";\n\n    if (arrows) {\n      html += this.renderArrows();\n    }\n\n    html += \"<div class=\\\"splide__track\\\">\";\n    html += \"<\" + listTag + \" class=\\\"splide__list\\\">\";\n    html += this.renderSlides();\n    html += \"</\" + listTag + \">\";\n    html += \"</div>\";\n    html += afterTrack || \"\";\n\n    if (slider) {\n      html += \"</div>\";\n      html += afterSlider || \"\";\n    }\n\n    html += \"</div>\";\n    return html;\n  };\n\n  return SplideRenderer;\n}();\n\nexport { CLASSES, CLASS_ACTIVE, CLASS_ARROW, CLASS_ARROWS, CLASS_ARROW_NEXT, CLASS_ARROW_PREV, CLASS_CLONE, CLASS_CONTAINER, CLASS_FOCUS_IN, CLASS_INITIALIZED, CLASS_LIST, CLASS_LOADING, CLASS_NEXT, CLASS_OVERFLOW, CLASS_PAGINATION, CLASS_PAGINATION_PAGE, CLASS_PREV, CLASS_PROGRESS, CLASS_PROGRESS_BAR, CLASS_ROOT, CLASS_SLIDE, CLASS_SPINNER, CLASS_SR, CLASS_TOGGLE, CLASS_TOGGLE_PAUSE, CLASS_TOGGLE_PLAY, CLASS_TRACK, CLASS_VISIBLE, DEFAULTS, EVENT_ACTIVE, EVENT_ARROWS_MOUNTED, EVENT_ARROWS_UPDATED, EVENT_AUTOPLAY_PAUSE, EVENT_AUTOPLAY_PLAY, EVENT_AUTOPLAY_PLAYING, EVENT_CLICK, EVENT_DESTROY, EVENT_DRAG, EVENT_DRAGGED, EVENT_DRAGGING, EVENT_END_INDEX_CHANGED, EVENT_HIDDEN, EVENT_INACTIVE, EVENT_LAZYLOAD_LOADED, EVENT_MOUNTED, EVENT_MOVE, EVENT_MOVED, EVENT_NAVIGATION_MOUNTED, EVENT_OVERFLOW, EVENT_PAGINATION_MOUNTED, EVENT_PAGINATION_UPDATED, EVENT_READY, EVENT_REFRESH, EVENT_RESIZE, EVENT_RESIZED, EVENT_SCROLL, EVENT_SCROLLED, EVENT_SHIFTED, EVENT_SLIDE_KEYDOWN, EVENT_UPDATED, EVENT_VISIBLE, EventBinder, EventInterface, FADE, LOOP, LTR, RTL, RequestInterval, SLIDE, STATUS_CLASSES, Splide, SplideRenderer, State, TTB, Throttle, Splide as default };\n","import Splide from \"@splidejs/splide\";\n\nfunction init() {\n  const splides = document.querySelectorAll(\".splide\");\n\n  splides.forEach((splideElement) => {\n    const splide = new Splide(splideElement, {\n      // Add any necessary options here\n    });\n\n    splide.mount();\n\n    setupArrowListeners(splideElement);\n    setupSlideListeners(splideElement);\n    setupMoveListener(splide, splideElement);\n    initializeFirstSlide(splideElement);\n  });\n\n  setupNoRightSideWrapper();\n}\n\nfunction setupArrowListeners(splideElement) {\n  [\"next\", \"prev\"].forEach((direction) => {\n    splideElement\n      .querySelector(`.splide__arrow--${direction}`)\n      .addEventListener(\"click\", () =>\n        handleArrowClick(splideElement, direction)\n      );\n  });\n}\n\nfunction handleArrowClick(splideElement, direction) {\n  const targetSlide = splideElement.querySelector(\n    `.splide__slide.is-${direction}`\n  );\n  if (targetSlide) {\n    updateVisibleSlide(splideElement, targetSlide);\n  }\n}\n\nfunction updateVisibleSlide(splideElement, newVisibleSlide) {\n  const currentSlide = splideElement.querySelector(\".splide__slide.is-active\");\n  if (currentSlide) {\n    currentSlide.classList.remove(\"is-visible\");\n  }\n  newVisibleSlide.classList.add(\"is-visible\");\n}\n\nfunction setupSlideListeners(splideElement) {\n  splideElement.querySelectorAll(\".splide__slide\").forEach((slide) => {\n    slide.addEventListener(\"click\", () => {\n      if (!slide.querySelector(\".no-right-side\")) {\n        const leftSlider = slide.querySelector(\n          \".testimonial-slider__slider-left\"\n        );\n        if (leftSlider) {\n          leftSlider.classList.toggle(\"closed\");\n        }\n      }\n    });\n  });\n}\n\nfunction setupMoveListener(splide, splideElement) {\n  splide.on(\"move\", () => {\n    splideElement.querySelectorAll(\".splide__slide\").forEach((slide) => {\n      if (!slide.querySelector(\".no-right-side\")) {\n        const leftSlider = slide.querySelector(\n          \".testimonial-slider__slider-left\"\n        );\n        if (leftSlider) {\n          leftSlider.classList.add(\"closed\");\n        }\n      }\n    });\n  });\n}\n\nfunction initializeFirstSlide(splideElement) {\n  const firstSlide = splideElement.querySelector(\".splide__slide\");\n  if (firstSlide) {\n    firstSlide.classList.add(\"is-visible\");\n  }\n}\n\nfunction setupNoRightSideWrapper() {\n  jQuery(\".testimonial-slider\").each(function () {\n    if (jQuery(this).find(\".no-right-side\").length) {\n      jQuery(this).addClass(\"no-right-side-wrapper\");\n    }\n  });\n}\n\nexport default init;\n","function init() {\n\n    const $ = jQuery;\n\n    function addReversal(parent) {\n      let reversed = $(parent).find('.has-media-on-the-right').length;\n      if (reversed == 1) {\n        $(parent).addClass('reversed-media');\n      }\n    }\n\n    // if media-text is reversed, (media on right), add class to parent for css to take hold\n    $('.media-text-v1, .media-text-v2, .media-text-v3').each(function() {\n      addReversal($(this));\n    });\n    \n}\n\nexport { init as default }; ","function init() {\n\n    // search icon\n    jQuery('#desSearchIcon').on('click', function() {\n    \n        jQuery('#headerSearchForm').slideToggle(390);\n        jQuery('header').toggleClass('search-open');\n\n    });\n\n    // mobile menu - collapse sub menus\n    jQuery(document).on(\"click\", \"#mega-menu-wrap-max_mega_menu_1 #mega-menu-max_mega_menu_1 li.mega-menu-megamenu > ul.mega-sub-menu > li.mega-menu-row .mega-menu-column > ul.mega-sub-menu > li.mega-menu-item.mega-menu-item-has-children:not('.children-expanded') a\" , function(e) {\n\n        if (jQuery(\"#navWrapper .mega-menu-toggle\").css(\"display\") != \"none\") { // only do this on mobile\n\n            e.preventDefault();\n            jQuery(this).closest('li').addClass('children-expanded');\n            jQuery(this).next('.mega-sub-menu').slideDown(260);\n        }\n        \n        \n    })\n    \n}\n\nexport {init as default};","function init() {\n\n    const $ = jQuery;\n\n    if ( $('.home-hero-wrapper').length ) {\n\n      // calculate height of header then set min-height of hero section\n      var headerHeight = $('header').outerHeight();\n      if ( $('.admin-bar').length ) {\n        headerHeight = headerHeight + $('#wpadminbar').outerHeight();\n      }\n      $('.home-hero-wrapper > .wp-block-columns').css('min-height', 'calc(100vh - ' + headerHeight + 'px)');\n\n      // make buttons same width (per client request)\n      let buttonWidth = 0;\n      $('.home-hero-wrapper .wp-block-button a').each(function() {\n        if ( $(this).width() > buttonWidth ) {\n          buttonWidth = $(this).width();\n        }\n      });\n      $('.home-hero-wrapper .wp-block-button a').width(buttonWidth);\n\n    }\n    \n}\n\nexport { init as default }; ","import accordionScript from \"./template-parts/blocks/accordion\";\nimport global from \"./global\";\nimport homeHero from \"./template-parts/patterns/home-hero\";\nimport homeVideo from \"./template-parts/patterns/home-video\";\nimport mediaText from \"./template-parts/blocks/media-text\";\nimport rtb from \"./template-parts/patterns/rtb\";\nimport textLines from \"./animations\";\nimport testimonialSlider from \"./template-parts/blocks/testimonial-slider\";\n\n/** Call */\nglobal();\nhomeHero();\nhomeVideo();\nmediaText();\nrtb();\ntestimonialSlider();\naccordionScript();\ntextLines(); // needs to be called after anything else that needs text split for animation purposes\n","import { disableBodyScroll, enableBodyScroll, clearAllBodyScrollLocks } from '../../../../node_modules/body-scroll-lock';\n\nfunction init() {\n\n    const $ = jQuery;\n\n    if ( $('.home-video-wrapper').length ) {\n\n      // insert play buttons\n      $('.home-video-wrapper > .wp-block-group').prepend('<div class=\"play-button play-button__large\"><div class=\"play-button__large-inner\"><i class=\"fa-solid fa-play\"></i></div></div>');\n      var smallCta = $('.home-video-wrapper > .wp-block-group').children().last();\n      var smallCtaText = smallCta.text();\n      smallCta.html('<span class=\"play-button\">' + smallCtaText + '</span>');\n      $('.home-video-wrapper > .wp-block-group').children().last().append('<div class=\"play-button play-button__small\"><i class=\"fa-solid fa-play\"></i></div>');\n\n      // insert modal close\n      $('.home-video-wrapper > .wp-block-embed').prepend('<div class=\"home-video-modal-close\"><i class=\"fa fa-times fa-2x\"></i>CLOSE</div>');\n\n      // set variable for scroll lock purposes when modal is open\n      const targetElement = document.querySelector('.home-video-wrapper > .wp-block-embed');\n\n      // on click of play button(s) - show modal and autoplay video; apply scroll lock to body\n      $('.home-video-wrapper .play-button').on('click', function() { \n        var video = $(this).closest('.home-video-wrapper').find('iframe');\n        var videoSrc = video.attr('src');\n        const substring = 'autoplay';\n        if ( videoSrc.includes(substring)) {\n          var newSrc = videoSrc.replace(/.$/,\"1\"); \n          video.attr('src', newSrc);\n        }\n        else {\n          video.attr('src', videoSrc + '&autoplay=1');\n        }\n        \n        $(this).closest('.home-video-wrapper').addClass('des-modal-open');\n        $(this).closest('.home-video-wrapper').find('.wp-block-embed').show();\n\n        disableBodyScroll(targetElement);\n      });\n\n      // exit modal and stop playing video; remove scroll lock from body\n      $('.home-video-wrapper .home-video-modal-close').on('click', function() {\n        var wrapper = $(this).closest('.home-video-wrapper');\n        wrapper.find('.wp-block-embed').hide();\n        var video = wrapper.find('iframe');\n        var videoSrc = video.attr('src');\n        var newSrc = videoSrc.replace(/.$/,\"0\");\n        video.attr('src', ' '); // video does not stop when simply changing src to same video src\n        video.attr('src', newSrc); // changing back to original source with autoplay=0\n\n        $(this).closest('.home-video-wrapper').removeClass('des-modal-open');\n\n        enableBodyScroll(targetElement);\n        \n        return false;\n      })\n    }\n    \n}\n\nexport { init as default }; ","function init() {\n\n    const $ = jQuery;\n\n    if ( $('.des-rtb-columns').length ) {        \n        // making the entire rtb column clickable, using the href found in the first anchor tag\n        $('.des-rtb-columns .wp-block-column').each(function() {\n\n            const columnLink = $(this).find('a').first().attr('href');\n\n            if (columnLink) {\n            \n                $(this).addClass('clickable');\n                $(this).attr('onClick', 'window.location.assign(\"' + columnLink + '\");');\n\n            }\n\n        });\n\n    }\n    \n}\n\nexport { init as default }; ","function init() {\n\n    const $ = jQuery;\n\n    $('.acc-toggle').click(function(e) {\n        e.preventDefault();\n    \n      let $this = $(this);\n    \n      if ($this.parent().parent().find('.acc-inner').hasClass('show')) {\n        $this.parent().parent().find('.acc-inner').removeClass('show');\n        $this.parent().parent().find('.acc-inner').slideUp(350);\n      } else {\n          //$this.parent().parent().parent().find('li .acc-inner').removeClass('show');\n          //$this.parent().parent().parent().find('li .acc-inner').slideUp(350);\n          $this.parent().parent().find('.acc-inner').toggleClass('show');\n          $this.parent().parent().find('.acc-inner').slideToggle(350);\n      }\n\n      $this.find('.acc-circle-plus, .acc-circle-plus-two').toggleClass('acc-opened');\n    });\n\n    // expand/collapse all button\n    $('.accordion-wizard').on('click', function() {\n      var accordion = $(this).closest('.accordion-wrapper');\n\n      if ( $(this).hasClass('acc-expanded')) {\n        accordion.find('.acc-inner').removeClass('show').slideUp(350);\n        accordion.find('.acc-circle-plus, .acc-circle-plus-two').removeClass('acc-opened');\n        $(this).text('Expand All').removeClass('acc-expanded');\n      }\n      else {\n        accordion.find('.acc-inner').addClass('show').slideDown(350);\n        accordion.find('.acc-circle-plus, .acc-circle-plus-two').addClass('acc-opened');\n        $(this).addClass('acc-expanded').text('Collapse All');\n      }\n\n    });\n}\n\nexport { init as default }; ","import {\n  animate,\n  glide,\n  scroll,\n  spring,\n  stagger,\n  inView,\n} from \"../../node_modules/motion\";\nimport SplitType from \"../../node_modules/split-type\";\n\nfunction init() {\n  // list of elements to be split - these also need to be specified in the animations.scss\n  const toBeSplit = [\n    \".shadoodled\", // class that can be added anywhere\n  ];\n  toBeSplit.forEach(doingTheSplits);\n\n  function doingTheSplits(value, index, array) {\n    jQuery(value).each(function () {\n      if (\n        !jQuery(this).hasClass(\"split-text\") &&\n        !jQuery(this).hasClass(\"no-split\")\n      ) {\n        const text = new SplitType(jQuery(this), { types: \"words\" });\n        jQuery(this).addClass(\"split-text\");\n      }\n    });\n  }\n\n  function revealYourselfText(element) {\n    var startPt = 0;\n    if (\n      element.parents().hasClass(\"home-hero-wrapper\") ||\n      element.parents().hasClass(\"interior-hero-wrapper\")\n    ) {\n      startPt = 0.78; // delaying start a bit on home hero text\n    }\n\n    inView(element, ({ target }) => {\n      const offset = 0.03;\n      const numberWords = element.find(\".word\").length;\n\n      animate(\n        element.find(\".word\"),\n        {\n          opacity: [null, \"1\"],\n          transform: [null, \"none\"],\n        },\n        {\n          duration: numberWords * offset,\n          delay: stagger(offset, { start: startPt }),\n          easing: [0.25, 0.1, 0.25, 1],\n          transform: {\n            duration: 0.78,\n          },\n        },\n        {\n          margin: \"390px\",\n        }\n      );\n    });\n  }\n\n  // when element is scrolled into view\n  jQuery(\".split-text\").each(function () {\n    revealYourselfText(jQuery(this));\n  });\n\n  // LP info cards animation\n  document\n    .querySelectorAll(\".lp-info-cards .wp-block-column\")\n    .forEach((section) => {\n      const copyBox = section.querySelector(\".wp-block-group\");\n      scroll(animate(copyBox, { y: [0, -78] }), {\n        target: copyBox,\n        offset: [\"start end\", \"start start\"],\n      });\n    });\n\n  // if window is resized, resplit the text\n  // const resizeObserver = new ResizeObserver(\n  //     debounce(([entry]) => {\n  //         text.split()\n  //     }, 500)\n  // )\n  // resizeObserver.observe(containerElement)\n\n  // marquee heading animation (as of 8-7-23 the client does not want the scrolling marquee headings)\n  // jQuery('.stats-wrapper > .wp-block-heading, .resource-cards-row > .wp-block-heading').each(function() {\n\n  //     const headingWidth = jQuery(this).width();\n  //     const windowWidth = jQuery(window).width();\n\n  //     var repeated = windowWidth / headingWidth;\n  //     repeated = Math.ceil(repeated); // number of times heading needs repeated to be wide enough for marquee\n\n  //     const headingText = '&nbsp;&nbsp;' + jQuery(this).text() + '&nbsp;&nbsp;';\n\n  //     jQuery(this).append('&nbsp;&nbsp;').prepend('&nbsp;&nbsp;');\n\n  //     for (var i = 0; i < repeated; i++) { // repeat the heading text\n  //         jQuery(this).append(headingText);\n  //     }\n\n  //     // setting variables for marquee heading scroll distance\n  //     var headingTop = jQuery(this).offset();\n  //     headingTop = headingTop.top;\n\n  //     const windowHeight = jQuery(window).height();\n\n  //     const startingPoint = headingTop - windowHeight;\n  //     const endingPoint = startingPoint + windowHeight + jQuery(this).outerHeight();\n\n  //     const range = endingPoint - startingPoint;\n\n  //     const journey = 0.52 * windowWidth;\n  //     const perY = journey / range;\n\n  //     // on scroll of window\n  //     scroll(( { y }) => {\n\n  //         if ( y.current > startingPoint && y.current < endingPoint ) {\n  //             var move = (y.current - startingPoint) * perY;\n  //             animate(jQuery(this), { transform: 'translateX(-' + move + 'px)' }, { easing: glide({decay: 0.5, power: 20, velocity: 260}) })\n  //         }\n  //     }\n  //     );\n\n  // });\n\n  // sides reveal animation\n  document.querySelectorAll(\"main\").forEach((section) => {\n    const preFooter = section.querySelector(\".des-prefooter\");\n    const homeVideo = section.querySelector(\".home-video-wrapper\");\n    sideDishes(preFooter);\n    sideDishes(homeVideo);\n  });\n\n  function sideDishes(component) {\n    if (component) {\n      scroll(animate(component, { clipPath: [null, \"inset(0 0 round 0)\"] }), {\n        target: component,\n        offset: [\"start end\", \"start start\"],\n      });\n    }\n  }\n\n  // media and text v1/v3 image movement\n  document\n    .querySelectorAll(\n      \".media-text-v1 > .wp-block-columns, .media-text-v3 .wp-block-media-text\"\n    )\n    .forEach((section) => {\n      const mnkyImg = section.querySelector(\".wp-block-media-text__media\");\n      scroll(animate(mnkyImg, { y: [20 + \"%\", 0] }), {\n        target: mnkyImg,\n        offset: [\"start end\", \"start start\"],\n      });\n    });\n  // media and text v2 - large image movement\n  document\n    .querySelectorAll(\".media-text-v2 > .wp-block-columns\")\n    .forEach((section) => {\n      const mnkyImg = section.querySelector(\n        \".wp-block-column:first-of-type .wp-block-image\"\n      );\n      scroll(animate(mnkyImg, { y: [0, \"-\" + 52 + \"px\"] }), {\n        target: mnkyImg,\n        offset: [\"start end\", \"start start\"],\n      });\n    });\n  // media and text v2 - small image movement\n  document\n    .querySelectorAll(\".media-text-v2 > .wp-block-columns\")\n    .forEach((section) => {\n      const mnkyImg = section.querySelector(\n        \".wp-block-column:last-of-type figure\"\n      );\n      scroll(animate(mnkyImg, { y: [0, 26 + \"px\"] }), {\n        target: mnkyImg,\n        offset: [\"start end\", \"start start\"],\n      });\n    });\n\n  // resource cards diagonal animation\n  if (jQuery(\".resource-cards-row\").length) {\n    const prevSection = jQuery(\".resource-cards-row\").prev();\n    prevSection.css({ position: \"relative\", \"z-index\": 5 }); // prev section needs higher z-index\n\n    jQuery(\".resource-cards-inner-wrapper\")\n      .wrapInner('<div class=\"another-wrapper\"></div>')\n      .wrapInner('<div class=\"yet-another-wrapper\"></div>')\n      .wrapInner(\n        '<div class=\"rotated-div\" style=\"position:absolute;top:0;bottom:0;right:0;left:0;transform:rotate(10deg);\"></div>'\n      );\n\n    const spaceHolder = document.querySelector(\".resource-cards-outer-wrapper\");\n    const horizontal = document.querySelector(\".yet-another-wrapper\");\n\n    const windowH = window.innerHeight;\n    const windowW = window.innerWidth;\n\n    const anotherWrapperRealDimensions = document\n      .querySelector(\".another-wrapper\")\n      .getBoundingClientRect();\n\n    const minMovement =\n      anotherWrapperRealDimensions.width + windowW + windowH - 91;\n\n    spaceHolder.style.height = minMovement + \"px\";\n    spaceHolder.style.setProperty(\n      \"margin-top\",\n      \"-\" + (anotherWrapperRealDimensions.height / 1.03 - windowH + 65) + \"px\",\n      \"important\"\n    );\n\n    const sticky = document.querySelector(\".resource-cards-inner-wrapper\");\n\n    window.addEventListener(\"scroll\", () => {\n      horizontal.style.transform = `translateX(${sticky.offsetTop}px)`;\n\n      const totalMove = minMovement - windowH;\n      const opacityZone = 0.19 * windowW;\n\n      if (sticky.offsetTop >= totalMove - (opacityZone + 200)) {\n        var opacityLevel =\n          (totalMove - 60 - sticky.offsetTop) / (opacityZone + 200);\n      } else {\n        var opacityLevel = sticky.offsetTop / opacityZone;\n      }\n\n      jQuery(\".another-wrapper\").css(\"opacity\", opacityLevel);\n    });\n\n    window.addEventListener(\"resize\", () => {\n      spaceHolder.style.height =\n        anotherWrapperRealDimensions.width +\n        window.innerWidth +\n        window.innerHeight -\n        65 +\n        \"px\";\n    });\n  }\n\n  // single post - move share bar to fixed sidebar when scrolled away from hero\n  if (jQuery(\".single-post\").length) {\n    jQuery(\".ss-wrapper\").addClass(\"hero-share-bar\");\n    inView(\".single-post-hero > .wp-block-group\", (info) => {\n      jQuery(\".ss-wrapper\").removeClass(\"hero-share-bar\");\n\n      return (leaveInfo) => jQuery(\".ss-wrapper\").addClass(\"hero-share-bar\");\n    });\n    document.querySelectorAll(\".single-post\").forEach((section) => {\n      const latestPosts = section.querySelector(\".des-latest-posts\");\n      const socialBar = section.querySelector(\".ss-wrapper\");\n      const windowH = window.innerHeight;\n      const mStart = window.innerHeight / 2 - 132;\n      const movement = -(windowH - mStart);\n      const yOff = 1 - mStart / window.innerHeight;\n\n      scroll(animate(socialBar, { y: [null, movement + \"px\"] }), {\n        target: latestPosts,\n        offset: [\"start \" + yOff, \"start start\"],\n      });\n    });\n  }\n}\n\nexport { init as default };\n"],"sourceRoot":""}