{"version":3,"file":"/dist/js/splide.js","mappings":"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","sources":["webpack://college-designs/./node_modules/@splidejs/splide/dist/js/splide.esm.js","webpack://college-designs/./src/js/splide.js"],"sourcesContent":["/*!\n * Splide.js\n * Version  : 3.2.1\n * License  : MIT\n * Copyright: 2021 Naotoshi Fujita\n */\nconst PROJECT_CODE = \"splide\";\nconst DATA_ATTRIBUTE = `data-${PROJECT_CODE}`;\n\nconst CREATED = 1;\nconst MOUNTED = 2;\nconst IDLE = 3;\nconst MOVING = 4;\nconst DESTROYED = 5;\nconst STATES = {\n  CREATED,\n  MOUNTED,\n  IDLE,\n  MOVING,\n  DESTROYED\n};\n\nconst DEFAULT_EVENT_PRIORITY = 10;\nconst DEFAULT_USER_EVENT_PRIORITY = 20;\n\nfunction empty(array) {\n  array.length = 0;\n}\n\nfunction isObject(subject) {\n  return !isNull(subject) && typeof subject === \"object\";\n}\nfunction isArray(subject) {\n  return Array.isArray(subject);\n}\nfunction isFunction(subject) {\n  return typeof subject === \"function\";\n}\nfunction isString(subject) {\n  return typeof subject === \"string\";\n}\nfunction isUndefined(subject) {\n  return typeof subject === \"undefined\";\n}\nfunction isNull(subject) {\n  return subject === null;\n}\nfunction isHTMLElement(subject) {\n  return subject instanceof HTMLElement;\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(...toArray(items));\n  return array;\n}\n\nconst arrayProto = Array.prototype;\n\nfunction slice(arrayLike, start, end) {\n  return arrayProto.slice.call(arrayLike, start, end);\n}\n\nfunction find(arrayLike, predicate) {\n  return slice(arrayLike).filter(predicate)[0];\n}\n\nfunction toggleClass(elm, classes, add) {\n  if (elm) {\n    forEach(classes, (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, (node) => {\n    const parent = ref.parentNode;\n    if (parent) {\n      parent.insertBefore(node, ref);\n    }\n  });\n}\n\nfunction matches(elm, selector) {\n  return (elm[\"msMatchesSelector\"] || elm.matches).call(elm, selector);\n}\n\nfunction children(parent, selector) {\n  return parent ? slice(parent.children).filter((child) => matches(child, selector)) : [];\n}\n\nfunction child(parent, selector) {\n  return selector ? children(parent, selector)[0] : parent.firstElementChild;\n}\n\nfunction forOwn(object, iteratee, right) {\n  if (object) {\n    let keys = Object.keys(object);\n    keys = right ? keys.reverse() : keys;\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i];\n      if (key !== \"__proto__\") {\n        if (iteratee(object[key], key) === false) {\n          break;\n        }\n      }\n    }\n  }\n  return object;\n}\n\nfunction assign(object) {\n  slice(arguments, 1).forEach((source) => {\n    forOwn(source, (value, key) => {\n      object[key] = source[key];\n    });\n  });\n  return object;\n}\n\nfunction merge(object, source) {\n  forOwn(source, (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  return object;\n}\n\nfunction removeAttribute(elm, attrs) {\n  if (elm) {\n    forEach(attrs, (attr) => {\n      elm.removeAttribute(attr);\n    });\n  }\n}\n\nfunction setAttribute(elm, attrs, value) {\n  if (isObject(attrs)) {\n    forOwn(attrs, (value2, name) => {\n      setAttribute(elm, name, value2);\n    });\n  } else {\n    isNull(value) ? removeAttribute(elm, attrs) : elm.setAttribute(attrs, String(value));\n  }\n}\n\nfunction create(tag, attrs, parent) {\n  const elm = document.createElement(tag);\n  if (attrs) {\n    isString(attrs) ? addClass(elm, attrs) : setAttribute(elm, attrs);\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  if (!isNull(value)) {\n    const { style: style2 } = elm;\n    value = `${value}`;\n    if (style2[prop] !== value) {\n      style2[prop] = value;\n    }\n  }\n}\n\nfunction display(elm, display2) {\n  style(elm, \"display\", display2);\n}\n\nfunction focus(elm) {\n  elm[\"setActive\"] && elm[\"setActive\"]() || elm.focus({ preventScroll: true });\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, (node) => {\n    if (node && node.parentNode) {\n      node.parentNode.removeChild(node);\n    }\n  });\n}\n\nfunction measure(parent, value) {\n  if (isString(value)) {\n    const div = create(\"div\", { style: `width: ${value}; position: absolute;` }, parent);\n    value = rect(div).width;\n    remove(div);\n  }\n  return value;\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  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 slice(parent.querySelectorAll(selector));\n}\n\nfunction removeClass(elm, classes) {\n  toggleClass(elm, classes, false);\n}\n\nfunction unit(value) {\n  return isString(value) ? value : value ? `${value}px` : \"\";\n}\n\nfunction assert(condition, message = \"\") {\n  if (!condition) {\n    throw new Error(`[${PROJECT_CODE}] ${message}`);\n  }\n}\n\nfunction nextTick(callback) {\n  setTimeout(callback);\n}\n\nconst noop = () => {\n};\n\nfunction raf(func) {\n  return requestAnimationFrame(func);\n}\n\nconst { min, max, floor, ceil, abs } = Math;\n\nfunction approximatelyEqual(x, y, epsilon) {\n  return abs(x - y) < epsilon;\n}\n\nfunction between(number, minOrMax, maxOrMin, exclusive) {\n  const minimum = min(minOrMax, maxOrMin);\n  const maximum = max(minOrMax, maxOrMin);\n  return exclusive ? minimum < number && number < maximum : minimum <= number && number <= maximum;\n}\n\nfunction clamp(number, x, y) {\n  const minimum = min(x, y);\n  const 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, (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\nconst ids = {};\nfunction uniqueId(prefix) {\n  return `${prefix}${pad(ids[prefix] = (ids[prefix] || 0) + 1)}`;\n}\n\nfunction EventBus() {\n  let handlers = {};\n  function on(events, callback, key, priority = DEFAULT_EVENT_PRIORITY) {\n    forEachEvent(events, (event, namespace) => {\n      handlers[event] = handlers[event] || [];\n      push(handlers[event], {\n        _event: event,\n        _callback: callback,\n        _namespace: namespace,\n        _priority: priority,\n        _key: key\n      }).sort((handler1, handler2) => handler1._priority - handler2._priority);\n    });\n  }\n  function off(events, key) {\n    forEachEvent(events, (event, namespace) => {\n      const eventHandlers = handlers[event];\n      handlers[event] = eventHandlers && eventHandlers.filter((handler) => {\n        return handler._key ? handler._key !== key : key || handler._namespace !== namespace;\n      });\n    });\n  }\n  function offBy(key) {\n    forOwn(handlers, (eventHandlers, event) => {\n      off(event, key);\n    });\n  }\n  function emit(event) {\n    (handlers[event] || []).forEach((handler) => {\n      handler._callback.apply(handler, slice(arguments, 1));\n    });\n  }\n  function destroy() {\n    handlers = {};\n  }\n  function forEachEvent(events, iteratee) {\n    toArray(events).join(\" \").split(\" \").forEach((eventNS) => {\n      const fragments = eventNS.split(\".\");\n      iteratee(fragments[0], fragments[1]);\n    });\n  }\n  return {\n    on,\n    off,\n    offBy,\n    emit,\n    destroy\n  };\n}\n\nconst EVENT_MOUNTED = \"mounted\";\nconst EVENT_READY = \"ready\";\nconst EVENT_MOVE = \"move\";\nconst EVENT_MOVED = \"moved\";\nconst EVENT_CLICK = \"click\";\nconst EVENT_ACTIVE = \"active\";\nconst EVENT_INACTIVE = \"inactive\";\nconst EVENT_VISIBLE = \"visible\";\nconst EVENT_HIDDEN = \"hidden\";\nconst EVENT_SLIDE_KEYDOWN = \"slide:keydown\";\nconst EVENT_REFRESH = \"refresh\";\nconst EVENT_UPDATED = \"updated\";\nconst EVENT_RESIZE = \"resize\";\nconst EVENT_RESIZED = \"resized\";\nconst EVENT_REPOSITIONED = \"repositioned\";\nconst EVENT_DRAG = \"drag\";\nconst EVENT_DRAGGING = \"dragging\";\nconst EVENT_DRAGGED = \"dragged\";\nconst EVENT_SCROLL = \"scroll\";\nconst EVENT_SCROLLED = \"scrolled\";\nconst EVENT_DESTROY = \"destroy\";\nconst EVENT_ARROWS_MOUNTED = \"arrows:mounted\";\nconst EVENT_ARROWS_UPDATED = \"arrows:updated\";\nconst EVENT_PAGINATION_MOUNTED = \"pagination:mounted\";\nconst EVENT_PAGINATION_UPDATED = \"pagination:updated\";\nconst EVENT_NAVIGATION_MOUNTED = \"navigation:mounted\";\nconst EVENT_AUTOPLAY_PLAY = \"autoplay:play\";\nconst EVENT_AUTOPLAY_PLAYING = \"autoplay:playing\";\nconst EVENT_AUTOPLAY_PAUSE = \"autoplay:pause\";\nconst EVENT_LAZYLOAD_LOADED = \"lazyload:loaded\";\n\nfunction EventInterface(Splide2) {\n  const { event } = Splide2;\n  const key = {};\n  let listeners = [];\n  function on(events, callback, priority) {\n    event.on(events, callback, key, priority);\n  }\n  function off(events) {\n    event.off(events, key);\n  }\n  function bind(targets, events, callback, options) {\n    forEachEvent(targets, events, (target, event2) => {\n      listeners.push([target, event2, callback, options]);\n      target.addEventListener(event2, callback, options);\n    });\n  }\n  function unbind(targets, events, callback) {\n    forEachEvent(targets, events, (target, event2) => {\n      listeners = listeners.filter((listener) => {\n        if (listener[0] === target && listener[1] === event2 && (!callback || listener[2] === callback)) {\n          target.removeEventListener(event2, listener[2], listener[3]);\n          return false;\n        }\n        return true;\n      });\n    });\n  }\n  function forEachEvent(targets, events, iteratee) {\n    forEach(targets, (target) => {\n      if (target) {\n        events.split(\" \").forEach(iteratee.bind(null, target));\n      }\n    });\n  }\n  function destroy() {\n    listeners = listeners.filter((data) => unbind(data[0], data[1]));\n    event.offBy(key);\n  }\n  event.on(EVENT_DESTROY, destroy, key);\n  return {\n    on,\n    off,\n    emit: event.emit,\n    bind,\n    unbind,\n    destroy\n  };\n}\n\nfunction RequestInterval(interval, onInterval, onUpdate, limit) {\n  const { now } = Date;\n  let startTime;\n  let rate = 0;\n  let id;\n  let paused = true;\n  let count = 0;\n  function update() {\n    if (!paused) {\n      const elapsed = now() - startTime;\n      if (elapsed >= interval) {\n        rate = 1;\n        startTime = now();\n      } else {\n        rate = elapsed / interval;\n      }\n      if (onUpdate) {\n        onUpdate(rate);\n      }\n      if (rate === 1) {\n        onInterval();\n        if (limit && ++count >= limit) {\n          return pause();\n        }\n      }\n      raf(update);\n    }\n  }\n  function start(resume) {\n    !resume && cancel();\n    startTime = now() - (resume ? rate * interval : 0);\n    paused = false;\n    raf(update);\n  }\n  function pause() {\n    paused = true;\n  }\n  function rewind() {\n    startTime = now();\n    rate = 0;\n    if (onUpdate) {\n      onUpdate(rate);\n    }\n  }\n  function cancel() {\n    cancelAnimationFrame(id);\n    rate = 0;\n    id = 0;\n    paused = true;\n  }\n  function isPaused() {\n    return paused;\n  }\n  return {\n    start,\n    rewind,\n    pause,\n    cancel,\n    isPaused\n  };\n}\n\nfunction State(initialState) {\n  let state = initialState;\n  function set(value) {\n    state = value;\n  }\n  function is(states) {\n    return includes(toArray(states), state);\n  }\n  return { set, is };\n}\n\nfunction Throttle(func, duration) {\n  let interval;\n  function throttled() {\n    if (!interval) {\n      interval = RequestInterval(duration || 0, () => {\n        func.apply(this, arguments);\n        interval = null;\n      }, null, 1);\n      interval.start();\n    }\n  }\n  return throttled;\n}\n\nfunction Options(Splide2, Components2, options) {\n  const throttledObserve = Throttle(observe);\n  let initialOptions;\n  let points;\n  let currPoint;\n  function setup() {\n    try {\n      merge(options, JSON.parse(getAttribute(Splide2.root, DATA_ATTRIBUTE)));\n    } catch (e) {\n      assert(false, e.message);\n    }\n    initialOptions = merge({}, options);\n    const { breakpoints } = options;\n    if (breakpoints) {\n      const isMin = options.mediaQuery === \"min\";\n      points = Object.keys(breakpoints).sort((n, m) => isMin ? +m - +n : +n - +m).map((point) => [\n        point,\n        matchMedia(`(${isMin ? \"min\" : \"max\"}-width:${point}px)`)\n      ]);\n      observe();\n    }\n  }\n  function mount() {\n    if (points) {\n      addEventListener(\"resize\", throttledObserve);\n    }\n  }\n  function destroy(completely) {\n    if (completely) {\n      removeEventListener(\"resize\", throttledObserve);\n    }\n  }\n  function observe() {\n    const item = find(points, (item2) => item2[1].matches) || [];\n    if (item[0] !== currPoint) {\n      onMatch(currPoint = item[0]);\n    }\n  }\n  function onMatch(point) {\n    const newOptions = options.breakpoints[point] || initialOptions;\n    if (newOptions.destroy) {\n      Splide2.options = initialOptions;\n      Splide2.destroy(newOptions.destroy === \"completely\");\n    } else {\n      if (Splide2.state.is(DESTROYED)) {\n        destroy(true);\n        Splide2.mount();\n      }\n      Splide2.options = newOptions;\n    }\n  }\n  return {\n    setup,\n    mount,\n    destroy\n  };\n}\n\nconst RTL = \"rtl\";\nconst TTB = \"ttb\";\n\nconst ORIENTATION_MAP = {\n  marginRight: [\"marginBottom\", \"marginLeft\"],\n  autoWidth: [\"autoHeight\"],\n  fixedWidth: [\"fixedHeight\"],\n  paddingLeft: [\"paddingTop\", \"paddingRight\"],\n  paddingRight: [\"paddingBottom\", \"paddingLeft\"],\n  width: [\"height\"],\n  left: [\"top\", \"right\"],\n  right: [\"bottom\", \"left\"],\n  x: [\"y\"],\n  X: [\"Y\"],\n  Y: [\"X\"],\n  ArrowLeft: [\"ArrowUp\", \"ArrowRight\"],\n  ArrowRight: [\"ArrowDown\", \"ArrowLeft\"]\n};\nfunction Direction(Splide2, Components2, options) {\n  function resolve(prop, axisOnly) {\n    const { direction } = options;\n    const index = direction === RTL && !axisOnly ? 1 : direction === TTB ? 0 : -1;\n    return ORIENTATION_MAP[prop][index] || prop;\n  }\n  function orient(value) {\n    return value * (options.direction === RTL ? 1 : -1);\n  }\n  return {\n    resolve,\n    orient\n  };\n}\n\nconst CLASS_ROOT = PROJECT_CODE;\nconst CLASS_SLIDER = `${PROJECT_CODE}__slider`;\nconst CLASS_TRACK = `${PROJECT_CODE}__track`;\nconst CLASS_LIST = `${PROJECT_CODE}__list`;\nconst CLASS_SLIDE = `${PROJECT_CODE}__slide`;\nconst CLASS_CLONE = `${CLASS_SLIDE}--clone`;\nconst CLASS_CONTAINER = `${CLASS_SLIDE}__container`;\nconst CLASS_ARROWS = `${PROJECT_CODE}__arrows`;\nconst CLASS_ARROW = `${PROJECT_CODE}__arrow`;\nconst CLASS_ARROW_PREV = `${CLASS_ARROW}--prev`;\nconst CLASS_ARROW_NEXT = `${CLASS_ARROW}--next`;\nconst CLASS_PAGINATION = `${PROJECT_CODE}__pagination`;\nconst CLASS_PAGINATION_PAGE = `${CLASS_PAGINATION}__page`;\nconst CLASS_PROGRESS = `${PROJECT_CODE}__progress`;\nconst CLASS_PROGRESS_BAR = `${CLASS_PROGRESS}__bar`;\nconst CLASS_AUTOPLAY = `${PROJECT_CODE}__autoplay`;\nconst CLASS_PLAY = `${PROJECT_CODE}__play`;\nconst CLASS_PAUSE = `${PROJECT_CODE}__pause`;\nconst CLASS_SPINNER = `${PROJECT_CODE}__spinner`;\nconst CLASS_INITIALIZED = \"is-initialized\";\nconst CLASS_ACTIVE = \"is-active\";\nconst CLASS_PREV = \"is-prev\";\nconst CLASS_NEXT = \"is-next\";\nconst CLASS_VISIBLE = \"is-visible\";\nconst CLASS_LOADING = \"is-loading\";\nconst STATUS_CLASSES = [CLASS_ACTIVE, CLASS_VISIBLE, CLASS_PREV, CLASS_NEXT, CLASS_LOADING];\nconst 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 Elements(Splide2, Components2, options) {\n  const { on } = EventInterface(Splide2);\n  const { root } = Splide2;\n  const elements = {};\n  const slides = [];\n  let classes;\n  let slider;\n  let track;\n  let list;\n  function setup() {\n    collect();\n    identify();\n    addClass(root, classes = getClasses());\n  }\n  function mount() {\n    on(EVENT_REFRESH, refresh, DEFAULT_EVENT_PRIORITY - 2);\n    on(EVENT_UPDATED, update);\n  }\n  function destroy() {\n    [root, track, list].forEach((elm) => {\n      removeAttribute(elm, \"style\");\n    });\n    empty(slides);\n    removeClass(root, classes);\n  }\n  function refresh() {\n    destroy();\n    setup();\n  }\n  function update() {\n    removeClass(root, classes);\n    addClass(root, classes = getClasses());\n  }\n  function collect() {\n    slider = child(root, `.${CLASS_SLIDER}`);\n    track = query(root, `.${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    const autoplay = find(`.${CLASS_AUTOPLAY}`);\n    const arrows = find(`.${CLASS_ARROWS}`);\n    assign(elements, {\n      root,\n      slider,\n      track,\n      list,\n      slides,\n      arrows,\n      autoplay,\n      prev: query(arrows, `.${CLASS_ARROW_PREV}`),\n      next: query(arrows, `.${CLASS_ARROW_NEXT}`),\n      bar: query(find(`.${CLASS_PROGRESS}`), `.${CLASS_PROGRESS_BAR}`),\n      play: query(autoplay, `.${CLASS_PLAY}`),\n      pause: query(autoplay, `.${CLASS_PAUSE}`)\n    });\n  }\n  function identify() {\n    const id = root.id || uniqueId(PROJECT_CODE);\n    root.id = id;\n    track.id = track.id || `${id}-track`;\n    list.id = list.id || `${id}-list`;\n  }\n  function find(selector) {\n    return child(root, selector) || child(slider, selector);\n  }\n  function getClasses() {\n    return [\n      `${CLASS_ROOT}--${options.type}`,\n      `${CLASS_ROOT}--${options.direction}`,\n      options.drag && `${CLASS_ROOT}--draggable`,\n      options.isNavigation && `${CLASS_ROOT}--nav`,\n      CLASS_ACTIVE\n    ];\n  }\n  return assign(elements, {\n    setup,\n    mount,\n    destroy\n  });\n}\n\nconst ROLE = \"role\";\nconst ARIA_CONTROLS = \"aria-controls\";\nconst ARIA_CURRENT = \"aria-current\";\nconst ARIA_LABEL = \"aria-label\";\nconst ARIA_HIDDEN = \"aria-hidden\";\nconst TAB_INDEX = \"tabindex\";\nconst DISABLED = \"disabled\";\nconst ARIA_ORIENTATION = \"aria-orientation\";\nconst ALL_ATTRIBUTES = [\n  ROLE,\n  ARIA_CONTROLS,\n  ARIA_CURRENT,\n  ARIA_LABEL,\n  ARIA_HIDDEN,\n  ARIA_ORIENTATION,\n  TAB_INDEX,\n  DISABLED\n];\n\nconst SLIDE = \"slide\";\nconst LOOP = \"loop\";\nconst FADE = \"fade\";\n\nfunction Slide$1(Splide2, index, slideIndex, slide) {\n  const { on, emit, bind, destroy: destroyEvents } = EventInterface(Splide2);\n  const { Components, root, options } = Splide2;\n  const { isNavigation, updateOnMove } = options;\n  const { resolve } = Components.Direction;\n  const styles = getAttribute(slide, \"style\");\n  const isClone = slideIndex > -1;\n  const container = child(slide, `.${CLASS_CONTAINER}`);\n  const focusableNodes = options.focusableNodes && queryAll(slide, options.focusableNodes);\n  let destroyed;\n  function mount() {\n    init();\n    bind(slide, \"click keydown\", (e) => {\n      emit(e.type === \"click\" ? EVENT_CLICK : EVENT_SLIDE_KEYDOWN, this, e);\n    });\n    on([EVENT_REFRESH, EVENT_REPOSITIONED, EVENT_MOVED, EVENT_SCROLLED], update.bind(this));\n    if (updateOnMove) {\n      on(EVENT_MOVE, onMove.bind(this));\n    }\n  }\n  function init() {\n    if (!isClone) {\n      slide.id = `${root.id}-slide${pad(index + 1)}`;\n    }\n    if (isNavigation) {\n      const idx = isClone ? slideIndex : index;\n      const label = format(options.i18n.slideX, idx + 1);\n      const controls = Splide2.splides.map((splide) => splide.root.id).join(\" \");\n      setAttribute(slide, ARIA_LABEL, label);\n      setAttribute(slide, ARIA_CONTROLS, controls);\n      setAttribute(slide, ROLE, \"menuitem\");\n    }\n  }\n  function destroy() {\n    destroyed = true;\n    destroyEvents();\n    removeClass(slide, STATUS_CLASSES);\n    removeAttribute(slide, ALL_ATTRIBUTES);\n    setAttribute(slide, \"style\", styles);\n  }\n  function onMove(next, prev, dest) {\n    if (!destroyed) {\n      update.call(this);\n      if (dest === index) {\n        updateActivity.call(this, true);\n      }\n    }\n  }\n  function update() {\n    if (!destroyed) {\n      const { index: currIndex } = Splide2;\n      updateActivity.call(this, isActive());\n      updateVisibility.call(this, isVisible());\n      toggleClass(slide, CLASS_PREV, index === currIndex - 1);\n      toggleClass(slide, CLASS_NEXT, index === currIndex + 1);\n    }\n  }\n  function updateActivity(active) {\n    if (active !== hasClass(slide, CLASS_ACTIVE)) {\n      toggleClass(slide, CLASS_ACTIVE, active);\n      if (isNavigation) {\n        setAttribute(slide, ARIA_CURRENT, active || null);\n      }\n      emit(active ? EVENT_ACTIVE : EVENT_INACTIVE, this);\n    }\n  }\n  function updateVisibility(visible) {\n    const ariaHidden = !visible && !isActive();\n    setAttribute(slide, ARIA_HIDDEN, ariaHidden || null);\n    setAttribute(slide, TAB_INDEX, !ariaHidden && options.slideFocus ? 0 : null);\n    if (focusableNodes) {\n      focusableNodes.forEach((node) => {\n        setAttribute(node, TAB_INDEX, ariaHidden ? -1 : null);\n      });\n    }\n    if (visible !== hasClass(slide, CLASS_VISIBLE)) {\n      toggleClass(slide, CLASS_VISIBLE, visible);\n      emit(visible ? EVENT_VISIBLE : EVENT_HIDDEN, this);\n    }\n  }\n  function style$1(prop, value, useContainer) {\n    style(useContainer && container || slide, prop, value);\n  }\n  function isActive() {\n    return Splide2.index === index;\n  }\n  function isVisible() {\n    if (Splide2.is(FADE)) {\n      return isActive();\n    }\n    const trackRect = rect(Components.Elements.track);\n    const slideRect = rect(slide);\n    const left = resolve(\"left\");\n    const right = resolve(\"right\");\n    return floor(trackRect[left]) <= ceil(slideRect[left]) && floor(slideRect[right]) <= ceil(trackRect[right]);\n  }\n  function isWithin(from, distance) {\n    let diff = abs(from - index);\n    if (!isClone && (options.rewind || Splide2.is(LOOP))) {\n      diff = min(diff, Splide2.length - diff);\n    }\n    return diff <= distance;\n  }\n  return {\n    index,\n    slideIndex,\n    slide,\n    container,\n    isClone,\n    mount,\n    destroy,\n    style: style$1,\n    isWithin\n  };\n}\n\nfunction Slides(Splide2, Components2, options) {\n  const { on, emit, bind } = EventInterface(Splide2);\n  const { slides, list } = Components2.Elements;\n  const Slides2 = [];\n  function mount() {\n    init();\n    on(EVENT_REFRESH, refresh);\n    on([EVENT_MOUNTED, EVENT_REFRESH], () => {\n      Slides2.sort((Slide1, Slide2) => Slide1.index - Slide2.index);\n    });\n  }\n  function init() {\n    slides.forEach((slide, index) => {\n      register(slide, index, -1);\n    });\n  }\n  function destroy() {\n    forEach$1((Slide2) => {\n      Slide2.destroy();\n    });\n    empty(Slides2);\n  }\n  function refresh() {\n    destroy();\n    init();\n  }\n  function register(slide, index, slideIndex) {\n    const object = Slide$1(Splide2, index, slideIndex, slide);\n    object.mount();\n    Slides2.push(object);\n  }\n  function get(excludeClones) {\n    return excludeClones ? filter((Slide2) => !Slide2.isClone) : Slides2;\n  }\n  function getIn(page) {\n    const { Controller } = Components2;\n    const index = Controller.toIndex(page);\n    const max = Controller.hasFocus() ? 1 : options.perPage;\n    return filter((Slide2) => between(Slide2.index, index, index + max - 1));\n  }\n  function getAt(index) {\n    return filter(index)[0];\n  }\n  function add(items, index) {\n    forEach(items, (slide) => {\n      if (isString(slide)) {\n        slide = parseHtml(slide);\n      }\n      if (isHTMLElement(slide)) {\n        const ref = slides[index];\n        ref ? before(slide, ref) : append(list, slide);\n        addClass(slide, options.classes.slide);\n        observeImages(slide, emit.bind(null, EVENT_RESIZE));\n      }\n    });\n    emit(EVENT_REFRESH);\n  }\n  function remove$1(matcher) {\n    remove(filter(matcher).map((Slide2) => Slide2.slide));\n    emit(EVENT_REFRESH);\n  }\n  function forEach$1(iteratee, excludeClones) {\n    get(excludeClones).forEach(iteratee);\n  }\n  function filter(matcher) {\n    return Slides2.filter(isFunction(matcher) ? matcher : (Slide2) => isString(matcher) ? matches(Slide2.slide, matcher) : includes(toArray(matcher), Slide2.index));\n  }\n  function style(prop, value, useContainer) {\n    forEach$1((Slide2) => {\n      Slide2.style(prop, value, useContainer);\n    });\n  }\n  function observeImages(elm, callback) {\n    const images = queryAll(elm, \"img\");\n    let { length } = images;\n    if (length) {\n      images.forEach((img) => {\n        bind(img, \"load error\", () => {\n          if (!--length) {\n            callback();\n          }\n        });\n      });\n    } else {\n      callback();\n    }\n  }\n  function getLength(excludeClones) {\n    return excludeClones ? slides.length : Slides2.length;\n  }\n  function isEnough() {\n    return Slides2.length > options.perPage;\n  }\n  return {\n    mount,\n    destroy,\n    register,\n    get,\n    getIn,\n    getAt,\n    add,\n    remove: remove$1,\n    forEach: forEach$1,\n    filter,\n    style,\n    getLength,\n    isEnough\n  };\n}\n\nfunction Layout(Splide2, Components2, options) {\n  const { on, bind, emit } = EventInterface(Splide2);\n  const { Slides } = Components2;\n  const { resolve } = Components2.Direction;\n  const { track, list } = Components2.Elements;\n  const { getAt } = Slides;\n  let vertical;\n  function mount() {\n    init();\n    bind(window, \"resize load\", Throttle(emit.bind(this, EVENT_RESIZE)));\n    on([EVENT_UPDATED, EVENT_REFRESH], init);\n    on(EVENT_RESIZE, resize);\n  }\n  function init() {\n    vertical = options.direction === TTB;\n    style(Splide2.root, \"maxWidth\", unit(options.width));\n    style(track, resolve(\"paddingLeft\"), cssPadding(false));\n    style(track, resolve(\"paddingRight\"), cssPadding(true));\n    resize();\n  }\n  function resize() {\n    style(track, \"height\", cssTrackHeight());\n    Slides.style(resolve(\"marginRight\"), unit(options.gap));\n    Slides.style(\"width\", cssSlideWidth() || null);\n    setSlidesHeight();\n    emit(EVENT_RESIZED);\n  }\n  function setSlidesHeight() {\n    Slides.style(\"height\", cssSlideHeight() || null, true);\n  }\n  function cssPadding(right) {\n    const { padding } = options;\n    const prop = resolve(right ? \"right\" : \"left\", true);\n    return padding && unit(padding[prop] || (isObject(padding) ? 0 : padding)) || \"0px\";\n  }\n  function cssTrackHeight() {\n    let height = \"\";\n    if (vertical) {\n      height = cssHeight();\n      assert(height, \"height or heightRatio is missing.\");\n      height = `calc(${height} - ${cssPadding(false)} - ${cssPadding(true)})`;\n    }\n    return height;\n  }\n  function cssHeight() {\n    return unit(options.height || rect(list).width * options.heightRatio);\n  }\n  function cssSlideWidth() {\n    return options.autoWidth ? \"\" : unit(options.fixedWidth) || (vertical ? \"\" : cssSlideSize());\n  }\n  function cssSlideHeight() {\n    return unit(options.fixedHeight) || (vertical ? options.autoHeight ? \"\" : cssSlideSize() : cssHeight());\n  }\n  function cssSlideSize() {\n    const gap = unit(options.gap);\n    return `calc((100%${gap && ` + ${gap}`})/${options.perPage || 1}${gap && ` - ${gap}`})`;\n  }\n  function listSize() {\n    return rect(list)[resolve(\"width\")];\n  }\n  function slideSize(index, withoutGap) {\n    const Slide = getAt(index || 0);\n    return Slide ? rect(Slide.slide)[resolve(\"width\")] + (withoutGap ? 0 : getGap()) : 0;\n  }\n  function totalSize(index, withoutGap) {\n    const Slide = getAt(index);\n    if (Slide) {\n      const right = rect(Slide.slide)[resolve(\"right\")];\n      const left = rect(list)[resolve(\"left\")];\n      return abs(right - left) + (withoutGap ? 0 : getGap());\n    }\n    return 0;\n  }\n  function sliderSize() {\n    return totalSize(Splide2.length - 1, true) - totalSize(-1, true);\n  }\n  function getGap() {\n    const Slide = getAt(0);\n    return Slide && parseFloat(style(Slide.slide, resolve(\"marginRight\"))) || 0;\n  }\n  function getPadding(right) {\n    return parseFloat(style(track, resolve(`padding${right ? \"Right\" : \"Left\"}`, true))) || 0;\n  }\n  return {\n    mount,\n    listSize,\n    slideSize,\n    sliderSize,\n    totalSize,\n    getPadding\n  };\n}\n\nfunction Clones(Splide2, Components2, options) {\n  const { on, emit } = EventInterface(Splide2);\n  const { Elements, Slides } = Components2;\n  const { resolve } = Components2.Direction;\n  const clones = [];\n  let cloneCount;\n  function mount() {\n    init();\n    on(EVENT_REFRESH, refresh);\n    on([EVENT_UPDATED, EVENT_RESIZE], observe);\n  }\n  function init() {\n    if (cloneCount = computeCloneCount()) {\n      generate(cloneCount);\n      emit(EVENT_RESIZE);\n    }\n  }\n  function destroy() {\n    remove(clones);\n    empty(clones);\n  }\n  function refresh() {\n    destroy();\n    init();\n  }\n  function observe() {\n    if (cloneCount < computeCloneCount()) {\n      emit(EVENT_REFRESH);\n    }\n  }\n  function generate(count) {\n    const slides = Slides.get().slice();\n    const { length } = slides;\n    if (length) {\n      while (slides.length < count) {\n        push(slides, slides);\n      }\n      push(slides.slice(-count), slides.slice(0, count)).forEach((Slide, index) => {\n        const isHead = index < count;\n        const 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  function cloneDeep(elm, index) {\n    const 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  function computeCloneCount() {\n    let { clones: clones2 } = options;\n    if (!Splide2.is(LOOP)) {\n      clones2 = 0;\n    } else if (!clones2) {\n      const fixedSize = measure(Elements.list, options[resolve(\"fixedWidth\")]);\n      const fixedCount = fixedSize && ceil(rect(Elements.track)[resolve(\"width\")] / fixedSize);\n      const baseCount = fixedCount || options[resolve(\"autoWidth\")] && Splide2.length || options.perPage;\n      clones2 = baseCount * (options.drag ? (options.flickMaxPages || 1) + 1 : 2);\n    }\n    return clones2;\n  }\n  return {\n    mount,\n    destroy\n  };\n}\n\nfunction Move(Splide2, Components2, options) {\n  const { on, emit } = EventInterface(Splide2);\n  const { slideSize, getPadding, totalSize, listSize, sliderSize } = Components2.Layout;\n  const { resolve, orient } = Components2.Direction;\n  const { list, track } = Components2.Elements;\n  let waiting;\n  function mount() {\n    on([EVENT_MOUNTED, EVENT_RESIZED, EVENT_UPDATED, EVENT_REFRESH], reposition);\n  }\n  function destroy() {\n    removeAttribute(list, \"style\");\n  }\n  function reposition() {\n    if (!isBusy() && !Components2.Drag.isDragging()) {\n      Components2.Scroll.cancel();\n      jump(Splide2.index);\n      emit(EVENT_REPOSITIONED);\n    }\n  }\n  function move(dest, index, prev, callback) {\n    if (!isBusy()) {\n      const { set } = Splide2.state;\n      const position = getPosition();\n      const looping = dest !== index;\n      waiting = looping || options.waitForTransition;\n      set(MOVING);\n      emit(EVENT_MOVE, index, prev, dest);\n      Components2.Transition.start(dest, () => {\n        looping && jump(index);\n        waiting = false;\n        set(IDLE);\n        emit(EVENT_MOVED, index, prev, dest);\n        if (options.trimSpace === \"move\" && dest !== prev && position === getPosition()) {\n          Components2.Controller.go(dest > prev ? \">\" : \"<\", false, callback);\n        } else {\n          callback && callback();\n        }\n      });\n    }\n  }\n  function jump(index) {\n    translate(toPosition(index, true));\n  }\n  function translate(position, preventLoop) {\n    if (!Splide2.is(FADE)) {\n      list.style.transform = `translate${resolve(\"X\")}(${preventLoop ? position : loop(position)}px)`;\n    }\n  }\n  function loop(position) {\n    if (!waiting && Splide2.is(LOOP)) {\n      const diff = orient(position - getPosition());\n      const exceededMin = exceededLimit(false, position) && diff < 0;\n      const exceededMax = exceededLimit(true, position) && diff > 0;\n      if (exceededMin || exceededMax) {\n        position = shift(position, exceededMax);\n      }\n    }\n    return position;\n  }\n  function shift(position, backwards) {\n    const excess = position - getLimit(backwards);\n    const size = sliderSize();\n    position -= sign(excess) * size * ceil(abs(excess) / size);\n    return position;\n  }\n  function cancel() {\n    waiting = false;\n    translate(getPosition());\n    Components2.Transition.cancel();\n  }\n  function toIndex(position) {\n    const Slides = Components2.Slides.get();\n    let index = 0;\n    let minDistance = Infinity;\n    for (let i = 0; i < Slides.length; i++) {\n      const slideIndex = Slides[i].index;\n      const distance = abs(toPosition(slideIndex, true) - position);\n      if (distance <= minDistance) {\n        minDistance = distance;\n        index = slideIndex;\n      } else {\n        break;\n      }\n    }\n    return index;\n  }\n  function toPosition(index, trimming) {\n    const position = orient(totalSize(index - 1) - offset(index));\n    return trimming ? trim(position) : position;\n  }\n  function getPosition() {\n    const left = resolve(\"left\");\n    return rect(list)[left] - rect(track)[left] + orient(getPadding(false));\n  }\n  function trim(position) {\n    if (options.trimSpace && Splide2.is(SLIDE)) {\n      position = clamp(position, 0, orient(sliderSize() - listSize()));\n    }\n    return position;\n  }\n  function offset(index) {\n    const { focus } = options;\n    return focus === \"center\" ? (listSize() - slideSize(index, true)) / 2 : +focus * slideSize(index) || 0;\n  }\n  function getLimit(max) {\n    return toPosition(max ? Components2.Controller.getEnd() : 0, !!options.trimSpace);\n  }\n  function isBusy() {\n    return !!waiting;\n  }\n  function exceededLimit(max, position) {\n    position = isUndefined(position) ? getPosition() : position;\n    const exceededMin = max !== true && orient(position) < orient(getLimit(false));\n    const exceededMax = max !== false && orient(position) > orient(getLimit(true));\n    return exceededMin || exceededMax;\n  }\n  return {\n    mount,\n    destroy,\n    move,\n    jump,\n    translate,\n    shift,\n    cancel,\n    toIndex,\n    toPosition,\n    getPosition,\n    getLimit,\n    isBusy,\n    exceededLimit\n  };\n}\n\nfunction Controller(Splide2, Components2, options) {\n  const { on } = EventInterface(Splide2);\n  const { Move } = Components2;\n  const { getPosition, getLimit } = Move;\n  const { isEnough, getLength } = Components2.Slides;\n  const isLoop = Splide2.is(LOOP);\n  const isSlide = Splide2.is(SLIDE);\n  let currIndex = options.start || 0;\n  let prevIndex = currIndex;\n  let slideCount;\n  let perMove;\n  let perPage;\n  function mount() {\n    init();\n    on([EVENT_UPDATED, EVENT_REFRESH], init, DEFAULT_EVENT_PRIORITY - 1);\n  }\n  function init() {\n    slideCount = getLength(true);\n    perMove = options.perMove;\n    perPage = options.perPage;\n    currIndex = clamp(currIndex, 0, slideCount - 1);\n  }\n  function go(control, allowSameIndex, callback) {\n    const dest = parse(control);\n    if (options.useScroll) {\n      scroll(dest, true, true, options.speed, callback);\n    } else {\n      const index = loop(dest);\n      if (index > -1 && !Move.isBusy() && (allowSameIndex || index !== currIndex)) {\n        setIndex(index);\n        Move.move(dest, index, prevIndex, callback);\n      }\n    }\n  }\n  function scroll(destination, useIndex, snap, duration, callback) {\n    const dest = useIndex ? destination : toDest(destination);\n    Components2.Scroll.scroll(useIndex || snap ? Move.toPosition(dest, true) : destination, duration, () => {\n      setIndex(Move.toIndex(Move.getPosition()));\n      callback && callback();\n    });\n  }\n  function parse(control) {\n    let index = currIndex;\n    if (isString(control)) {\n      const [, indicator, number] = control.match(/([+\\-<>])(\\d+)?/) || [];\n      if (indicator === \"+\" || indicator === \"-\") {\n        index = computeDestIndex(currIndex + +`${indicator}${+number || 1}`, currIndex, true);\n      } else if (indicator === \">\") {\n        index = number ? toIndex(+number) : getNext(true);\n      } else if (indicator === \"<\") {\n        index = getPrev(true);\n      }\n    } else {\n      if (isLoop) {\n        index = clamp(control, -perPage, slideCount + perPage - 1);\n      } else {\n        index = clamp(control, 0, getEnd());\n      }\n    }\n    return index;\n  }\n  function getNext(destination) {\n    return getAdjacent(false, destination);\n  }\n  function getPrev(destination) {\n    return getAdjacent(true, destination);\n  }\n  function getAdjacent(prev, destination) {\n    const number = perMove || (hasFocus() ? 1 : perPage);\n    const dest = computeDestIndex(currIndex + number * (prev ? -1 : 1), currIndex);\n    if (dest === -1 && isSlide) {\n      if (!approximatelyEqual(getPosition(), getLimit(!prev), 1)) {\n        return prev ? 0 : getEnd();\n      }\n    }\n    return destination ? dest : loop(dest);\n  }\n  function computeDestIndex(dest, from, incremental) {\n    if (isEnough()) {\n      const end = getEnd();\n      if (dest < 0 || dest > end) {\n        if (between(0, dest, from, true) || between(end, from, dest, true)) {\n          dest = toIndex(toPage(dest));\n        } else {\n          if (isLoop) {\n            dest = perMove ? dest : dest < 0 ? -(slideCount % perPage || perPage) : slideCount;\n          } else if (options.rewind) {\n            dest = dest < 0 ? end : 0;\n          } else {\n            dest = -1;\n          }\n        }\n      } else {\n        if (!isLoop && !incremental && dest !== from) {\n          dest = perMove ? dest : toIndex(toPage(from) + (dest < from ? -1 : 1));\n        }\n      }\n    } else {\n      dest = -1;\n    }\n    return dest;\n  }\n  function getEnd() {\n    let end = slideCount - perPage;\n    if (hasFocus() || isLoop && perMove) {\n      end = slideCount - 1;\n    }\n    return max(end, 0);\n  }\n  function loop(index) {\n    if (isLoop) {\n      return isEnough() ? index % slideCount + (index < 0 ? slideCount : 0) : -1;\n    }\n    return index;\n  }\n  function toIndex(page) {\n    return clamp(hasFocus() ? page : perPage * page, 0, getEnd());\n  }\n  function toPage(index) {\n    if (!hasFocus()) {\n      index = between(index, slideCount - perPage, slideCount - 1) ? slideCount - 1 : index;\n      index = floor(index / perPage);\n    }\n    return index;\n  }\n  function toDest(destination) {\n    const closest = Move.toIndex(destination);\n    return isSlide ? clamp(closest, 0, getEnd()) : closest;\n  }\n  function setIndex(index) {\n    if (index !== currIndex) {\n      prevIndex = currIndex;\n      currIndex = index;\n    }\n  }\n  function getIndex(prev) {\n    return prev ? prevIndex : currIndex;\n  }\n  function hasFocus() {\n    return !isUndefined(options.focus) || options.isNavigation;\n  }\n  return {\n    mount,\n    go,\n    scroll,\n    getNext,\n    getPrev,\n    getEnd,\n    setIndex,\n    getIndex,\n    toIndex,\n    toPage,\n    toDest,\n    hasFocus\n  };\n}\n\nconst XML_NAME_SPACE = \"http://www.w3.org/2000/svg\";\nconst 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\";\nconst SIZE = 40;\n\nfunction Arrows(Splide2, Components2, options) {\n  const { on, bind, emit } = EventInterface(Splide2);\n  const { classes, i18n } = options;\n  const { Elements, Controller } = Components2;\n  let wrapper = Elements.arrows;\n  let prev = Elements.prev;\n  let next = Elements.next;\n  let created;\n  const arrows = {};\n  function mount() {\n    init();\n    on(EVENT_UPDATED, init);\n  }\n  function init() {\n    if (options.arrows) {\n      if (!prev || !next) {\n        createArrows();\n      }\n    }\n    if (prev && next) {\n      if (!arrows.prev) {\n        const { id } = Elements.track;\n        setAttribute(prev, ARIA_CONTROLS, id);\n        setAttribute(next, ARIA_CONTROLS, id);\n        arrows.prev = prev;\n        arrows.next = next;\n        listen();\n        emit(EVENT_ARROWS_MOUNTED, prev, next);\n      } else {\n        display(wrapper, options.arrows === false ? \"none\" : \"\");\n      }\n    }\n  }\n  function destroy() {\n    if (created) {\n      remove(wrapper);\n    } else {\n      removeAttribute(prev, ALL_ATTRIBUTES);\n      removeAttribute(next, ALL_ATTRIBUTES);\n    }\n  }\n  function listen() {\n    const { go } = Controller;\n    on([EVENT_MOUNTED, EVENT_MOVED, EVENT_UPDATED, EVENT_REFRESH, EVENT_SCROLLED], update);\n    bind(next, \"click\", () => {\n      go(\">\", true);\n    });\n    bind(prev, \"click\", () => {\n      go(\"<\", true);\n    });\n  }\n  function createArrows() {\n    wrapper = create(\"div\", classes.arrows);\n    prev = createArrow(true);\n    next = createArrow(false);\n    created = true;\n    append(wrapper, [prev, next]);\n    before(wrapper, child(options.arrows === \"slider\" && Elements.slider || Splide2.root));\n  }\n  function createArrow(prev2) {\n    const 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}\"><path d=\"${options.arrowPath || PATH}\" />`;\n    return parseHtml(arrow);\n  }\n  function update() {\n    const index = Splide2.index;\n    const prevIndex = Controller.getPrev();\n    const nextIndex = Controller.getNext();\n    const prevLabel = prevIndex > -1 && index < prevIndex ? i18n.last : i18n.prev;\n    const 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  return {\n    arrows,\n    mount,\n    destroy\n  };\n}\n\nfunction Autoplay(Splide2, Components2, options) {\n  const { on, bind, emit } = EventInterface(Splide2);\n  const { Elements } = Components2;\n  const interval = RequestInterval(options.interval, Splide2.go.bind(Splide2, \">\"), update);\n  const { isPaused } = interval;\n  let hovered;\n  let focused;\n  let paused;\n  function mount() {\n    const { autoplay } = options;\n    if (autoplay) {\n      initButton(true);\n      initButton(false);\n      listen();\n      if (autoplay !== \"pause\") {\n        play();\n      }\n    }\n  }\n  function initButton(forPause) {\n    const prop = forPause ? \"pause\" : \"play\";\n    const button = Elements[prop];\n    if (button) {\n      setAttribute(button, ARIA_CONTROLS, Elements.track.id);\n      setAttribute(button, ARIA_LABEL, options.i18n[prop]);\n      bind(button, \"click\", forPause ? pause : play);\n    }\n  }\n  function listen() {\n    const { root } = Elements;\n    if (options.pauseOnHover) {\n      bind(root, \"mouseenter mouseleave\", (e) => {\n        hovered = e.type === \"mouseenter\";\n        autoToggle();\n      });\n    }\n    if (options.pauseOnFocus) {\n      bind(root, \"focusin focusout\", (e) => {\n        focused = e.type === \"focusin\";\n        autoToggle();\n      });\n    }\n    on([EVENT_MOVE, EVENT_SCROLL, EVENT_REFRESH], interval.rewind);\n  }\n  function play() {\n    if (isPaused() && Components2.Slides.isEnough()) {\n      interval.start(!options.resetProgress);\n      focused = hovered = paused = false;\n      emit(EVENT_AUTOPLAY_PLAY);\n    }\n  }\n  function pause(manual = true) {\n    if (!isPaused()) {\n      interval.pause();\n      emit(EVENT_AUTOPLAY_PAUSE);\n    }\n    paused = manual;\n  }\n  function autoToggle() {\n    if (!paused) {\n      if (!hovered && !focused) {\n        play();\n      } else {\n        pause(false);\n      }\n    }\n  }\n  function update(rate) {\n    const { bar } = Elements;\n    if (bar) {\n      style(bar, \"width\", `${rate * 100}%`);\n    }\n    emit(EVENT_AUTOPLAY_PLAYING, rate);\n  }\n  return {\n    mount,\n    destroy: interval.cancel,\n    play,\n    pause,\n    isPaused\n  };\n}\n\nfunction Cover(Splide2, Components2, options) {\n  const { on } = EventInterface(Splide2);\n  function mount() {\n    if (options.cover) {\n      on(EVENT_LAZYLOAD_LOADED, (img, Slide) => {\n        toggle(true, img, Slide);\n      });\n      on([EVENT_MOUNTED, EVENT_UPDATED, EVENT_REFRESH], apply.bind(null, true));\n    }\n  }\n  function destroy() {\n    apply(false);\n  }\n  function apply(cover) {\n    Components2.Slides.forEach((Slide) => {\n      const img = child(Slide.container || Slide.slide, \"img\");\n      if (img && img.src) {\n        toggle(cover, img, Slide);\n      }\n    });\n  }\n  function toggle(cover, img, Slide) {\n    Slide.style(\"background\", cover ? `center/cover no-repeat url(\"${img.src}\")` : \"\", true);\n    display(img, cover ? \"none\" : \"\");\n  }\n  return {\n    mount,\n    destroy\n  };\n}\n\nconst BOUNCE_DIFF_THRESHOLD = 10;\nconst BOUNCE_DURATION = 600;\nconst FRICTION_FACTOR = 0.6;\nconst BASE_VELOCITY = 1.5;\nconst MIN_DURATION = 800;\n\nfunction Scroll(Splide2, Components2, options) {\n  const { on, emit } = EventInterface(Splide2);\n  const { Move } = Components2;\n  const { getPosition, getLimit, exceededLimit } = Move;\n  let interval;\n  let scrollCallback;\n  function mount() {\n    on(EVENT_MOVE, clear);\n    on([EVENT_UPDATED, EVENT_REFRESH], cancel);\n  }\n  function scroll(destination, duration, callback, suppressConstraint) {\n    const start = getPosition();\n    let friction = 1;\n    duration = duration || computeDuration(abs(destination - start));\n    scrollCallback = callback;\n    clear();\n    interval = RequestInterval(duration, onScrolled, (rate) => {\n      const position = getPosition();\n      const target = start + (destination - start) * easing(rate);\n      const diff = (target - getPosition()) * friction;\n      Move.translate(position + diff);\n      if (Splide2.is(SLIDE) && !suppressConstraint && exceededLimit()) {\n        friction *= FRICTION_FACTOR;\n        if (abs(diff) < BOUNCE_DIFF_THRESHOLD) {\n          bounce(exceededLimit(false));\n        }\n      }\n    }, 1);\n    emit(EVENT_SCROLL);\n    interval.start();\n  }\n  function bounce(backwards) {\n    scroll(getLimit(!backwards), BOUNCE_DURATION, null, true);\n  }\n  function onScrolled() {\n    const position = getPosition();\n    const index = Move.toIndex(position);\n    if (!between(index, 0, Splide2.length - 1)) {\n      Move.translate(Move.shift(position, index > 0), true);\n    }\n    scrollCallback && scrollCallback();\n    emit(EVENT_SCROLLED);\n  }\n  function computeDuration(distance) {\n    return max(distance / BASE_VELOCITY, MIN_DURATION);\n  }\n  function clear() {\n    if (interval) {\n      interval.cancel();\n    }\n  }\n  function cancel() {\n    if (interval && !interval.isPaused()) {\n      clear();\n      onScrolled();\n    }\n  }\n  function easing(t) {\n    const { easingFunc } = options;\n    return easingFunc ? easingFunc(t) : 1 - Math.pow(1 - t, 4);\n  }\n  return {\n    mount,\n    destroy: clear,\n    scroll,\n    cancel\n  };\n}\n\nconst FRICTION = 5;\nconst LOG_INTERVAL = 200;\nconst POINTER_DOWN_EVENTS = \"touchstart mousedown\";\nconst POINTER_MOVE_EVENTS = \"touchmove mousemove\";\nconst POINTER_UP_EVENTS = \"touchend touchcancel mouseup\";\n\nfunction Drag(Splide2, Components2, options) {\n  const { on, emit, bind, unbind } = EventInterface(Splide2);\n  const { Move, Scroll, Controller } = Components2;\n  const { track } = Components2.Elements;\n  const { resolve, orient } = Components2.Direction;\n  const { getPosition, exceededLimit } = Move;\n  const listenerOptions = { passive: false, capture: true };\n  let basePosition;\n  let baseEvent;\n  let prevBaseEvent;\n  let lastEvent;\n  let isFree;\n  let dragging;\n  let hasExceeded = false;\n  let clickPrevented;\n  let disabled;\n  let target;\n  function mount() {\n    bind(track, POINTER_MOVE_EVENTS, noop, listenerOptions);\n    bind(track, POINTER_UP_EVENTS, noop, listenerOptions);\n    bind(track, POINTER_DOWN_EVENTS, onPointerDown, listenerOptions);\n    bind(track, \"click\", onClick, { capture: true });\n    bind(track, \"dragstart\", prevent);\n    on([EVENT_MOUNTED, EVENT_UPDATED], init);\n  }\n  function init() {\n    const { drag } = options;\n    disable(!drag);\n    isFree = drag === \"free\";\n  }\n  function onPointerDown(e) {\n    if (!disabled) {\n      const isTouch = isTouchEvent(e);\n      if (isTouch || !e.button) {\n        if (!Move.isBusy()) {\n          target = isTouch ? track : window;\n          prevBaseEvent = null;\n          lastEvent = null;\n          clickPrevented = false;\n          bind(target, POINTER_MOVE_EVENTS, onPointerMove, listenerOptions);\n          bind(target, POINTER_UP_EVENTS, onPointerUp, listenerOptions);\n          Move.cancel();\n          Scroll.cancel();\n          save(e);\n        } else {\n          prevent(e, true);\n        }\n      }\n    }\n  }\n  function onPointerMove(e) {\n    if (!lastEvent) {\n      emit(EVENT_DRAG);\n    }\n    lastEvent = e;\n    if (e.cancelable) {\n      if (dragging) {\n        const expired = timeOf(e) - timeOf(baseEvent) > LOG_INTERVAL;\n        const exceeded = hasExceeded !== (hasExceeded = exceededLimit());\n        if (expired || exceeded) {\n          save(e);\n        }\n        Move.translate(basePosition + constrain(coordOf(e) - coordOf(baseEvent)));\n        emit(EVENT_DRAGGING);\n        clickPrevented = true;\n        prevent(e);\n      } else {\n        const diff = abs(coordOf(e) - coordOf(baseEvent));\n        let { dragMinThreshold: thresholds } = options;\n        thresholds = isObject(thresholds) ? thresholds : { mouse: 0, touch: +thresholds || 10 };\n        dragging = diff > (isTouchEvent(e) ? thresholds.touch : thresholds.mouse);\n        if (isSliderDirection()) {\n          prevent(e);\n        }\n      }\n    }\n  }\n  function onPointerUp(e) {\n    unbind(target, POINTER_MOVE_EVENTS, onPointerMove);\n    unbind(target, POINTER_UP_EVENTS, onPointerUp);\n    if (lastEvent) {\n      if (dragging || e.cancelable && isSliderDirection()) {\n        const velocity = computeVelocity(e);\n        const destination = computeDestination(velocity);\n        if (isFree) {\n          Controller.scroll(destination);\n        } else if (Splide2.is(FADE)) {\n          Controller.go(Splide2.index + orient(sign(velocity)));\n        } else {\n          Controller.go(Controller.toDest(destination), true);\n        }\n        prevent(e);\n      }\n      emit(EVENT_DRAGGED);\n    }\n    dragging = false;\n  }\n  function save(e) {\n    prevBaseEvent = baseEvent;\n    baseEvent = e;\n    basePosition = getPosition();\n  }\n  function onClick(e) {\n    if (!disabled && clickPrevented) {\n      prevent(e, true);\n    }\n  }\n  function isSliderDirection() {\n    const diffX = abs(coordOf(lastEvent) - coordOf(baseEvent));\n    const diffY = abs(coordOf(lastEvent, true) - coordOf(baseEvent, true));\n    return diffX > diffY;\n  }\n  function computeVelocity(e) {\n    if (Splide2.is(LOOP) || !hasExceeded) {\n      const base = baseEvent === lastEvent && prevBaseEvent || baseEvent;\n      const diffCoord = coordOf(lastEvent) - coordOf(base);\n      const diffTime = timeOf(e) - timeOf(base);\n      const isFlick = timeOf(e) - timeOf(lastEvent) < LOG_INTERVAL;\n      if (diffTime && isFlick) {\n        return diffCoord / diffTime;\n      }\n    }\n    return 0;\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  function coordOf(e, orthogonal) {\n    return (isTouchEvent(e) ? e.touches[0] : e)[`page${resolve(orthogonal ? \"Y\" : \"X\")}`];\n  }\n  function timeOf(e) {\n    return e.timeStamp;\n  }\n  function constrain(diff) {\n    return diff / (hasExceeded && Splide2.is(SLIDE) ? FRICTION : 1);\n  }\n  function isTouchEvent(e) {\n    return typeof TouchEvent !== \"undefined\" && e instanceof TouchEvent;\n  }\n  function isDragging() {\n    return dragging;\n  }\n  function disable(value) {\n    disabled = value;\n  }\n  return {\n    mount,\n    disable,\n    isDragging\n  };\n}\n\nconst IE_ARROW_KEYS = [\"Left\", \"Right\", \"Up\", \"Down\"];\nfunction Keyboard(Splide2, Components2, options) {\n  const { on, bind, unbind } = EventInterface(Splide2);\n  const { root } = Components2.Elements;\n  const { resolve } = Components2.Direction;\n  let target;\n  function mount() {\n    init();\n    on(EVENT_UPDATED, () => {\n      destroy();\n      init();\n    });\n  }\n  function init() {\n    const { keyboard = \"global\" } = options;\n    if (keyboard) {\n      if (keyboard === \"focused\") {\n        target = root;\n        setAttribute(root, TAB_INDEX, 0);\n      } else {\n        target = window;\n      }\n      bind(target, \"keydown\", onKeydown);\n    }\n  }\n  function destroy() {\n    unbind(target, \"keydown\");\n    if (isHTMLElement(target)) {\n      removeAttribute(target, TAB_INDEX);\n    }\n  }\n  function onKeydown(e) {\n    const { key } = e;\n    const normalizedKey = includes(IE_ARROW_KEYS, key) ? `Arrow${key}` : key;\n    if (normalizedKey === resolve(\"ArrowLeft\")) {\n      Splide2.go(\"<\");\n    } else if (normalizedKey === resolve(\"ArrowRight\")) {\n      Splide2.go(\">\");\n    }\n  }\n  return {\n    mount,\n    destroy\n  };\n}\n\nconst SRC_DATA_ATTRIBUTE = `${DATA_ATTRIBUTE}-lazy`;\nconst SRCSET_DATA_ATTRIBUTE = `${SRC_DATA_ATTRIBUTE}-srcset`;\nconst IMAGE_SELECTOR = `[${SRC_DATA_ATTRIBUTE}], [${SRCSET_DATA_ATTRIBUTE}]`;\n\nfunction LazyLoad(Splide2, Components2, options) {\n  const { on, off, bind, emit } = EventInterface(Splide2);\n  const isSequential = options.lazyLoad === \"sequential\";\n  let images = [];\n  let index = 0;\n  function mount() {\n    if (options.lazyLoad) {\n      on([EVENT_MOUNTED, EVENT_REFRESH], () => {\n        destroy();\n        init();\n      });\n      if (!isSequential) {\n        on([EVENT_MOUNTED, EVENT_REFRESH, EVENT_MOVED], observe);\n      }\n    }\n  }\n  function init() {\n    Components2.Slides.forEach((_Slide) => {\n      queryAll(_Slide.slide, IMAGE_SELECTOR).forEach((_img) => {\n        const src = getAttribute(_img, SRC_DATA_ATTRIBUTE);\n        const srcset = getAttribute(_img, SRCSET_DATA_ATTRIBUTE);\n        if (src !== _img.src || srcset !== _img.srcset) {\n          const _spinner = create(\"span\", options.classes.spinner, _img.parentElement);\n          setAttribute(_spinner, ROLE, \"presentation\");\n          images.push({ _img, _Slide, src, srcset, _spinner });\n          !_img.src && display(_img, \"none\");\n        }\n      });\n    });\n    if (isSequential) {\n      loadNext();\n    }\n  }\n  function destroy() {\n    index = 0;\n    images = [];\n  }\n  function observe() {\n    images = images.filter((data) => {\n      const distance = options.perPage * ((options.preloadPages || 1) + 1) - 1;\n      if (data._Slide.isWithin(Splide2.index, distance)) {\n        return load(data);\n      }\n      return true;\n    });\n    if (!images.length) {\n      off(EVENT_MOVED);\n    }\n  }\n  function load(data) {\n    const { _img } = data;\n    addClass(data._Slide.slide, CLASS_LOADING);\n    bind(_img, \"load error\", (e) => {\n      onLoad(data, e.type === \"error\");\n    });\n    [\"src\", \"srcset\"].forEach((name) => {\n      if (data[name]) {\n        setAttribute(_img, name, data[name]);\n        removeAttribute(_img, name === \"src\" ? SRC_DATA_ATTRIBUTE : SRCSET_DATA_ATTRIBUTE);\n      }\n    });\n  }\n  function onLoad(data, error) {\n    const { _Slide } = data;\n    removeClass(_Slide.slide, CLASS_LOADING);\n    if (!error) {\n      remove(data._spinner);\n      display(data._img, \"\");\n      emit(EVENT_LAZYLOAD_LOADED, data._img, _Slide);\n      emit(EVENT_RESIZE);\n    }\n    if (isSequential) {\n      loadNext();\n    }\n  }\n  function loadNext() {\n    if (index < images.length) {\n      load(images[index++]);\n    }\n  }\n  return {\n    mount,\n    destroy\n  };\n}\n\nfunction Pagination(Splide2, Components2, options) {\n  const { on, emit, bind, unbind } = EventInterface(Splide2);\n  const { Slides, Elements, Controller } = Components2;\n  const { hasFocus, getIndex } = Controller;\n  const items = [];\n  let list;\n  function mount() {\n    init();\n    on([EVENT_UPDATED, EVENT_REFRESH], init);\n    on([EVENT_MOVE, EVENT_SCROLLED], update);\n  }\n  function init() {\n    destroy();\n    if (options.pagination && Slides.isEnough()) {\n      createPagination();\n      emit(EVENT_PAGINATION_MOUNTED, { list, items }, getAt(Splide2.index));\n      update();\n    }\n  }\n  function destroy() {\n    if (list) {\n      remove(list);\n      items.forEach((item) => {\n        unbind(item.button, \"click\");\n      });\n      empty(items);\n      list = null;\n    }\n  }\n  function createPagination() {\n    const { length } = Splide2;\n    const { classes, i18n, perPage } = options;\n    const parent = options.pagination === \"slider\" && Elements.slider || Elements.root;\n    const max = hasFocus() ? length : ceil(length / perPage);\n    list = create(\"ul\", classes.pagination, parent);\n    for (let i = 0; i < max; i++) {\n      const li = create(\"li\", null, list);\n      const button = create(\"button\", { class: classes.page, type: \"button\" }, li);\n      const controls = Slides.getIn(i).map((Slide) => Slide.slide.id);\n      const text = !hasFocus() && perPage > 1 ? i18n.pageX : i18n.slideX;\n      bind(button, \"click\", onClick.bind(null, i));\n      setAttribute(button, ARIA_CONTROLS, controls.join(\" \"));\n      setAttribute(button, ARIA_LABEL, format(text, i + 1));\n      items.push({ li, button, page: i });\n    }\n  }\n  function onClick(page) {\n    Controller.go(`>${page}`, true, () => {\n      const Slide = Slides.getAt(Controller.toIndex(page));\n      Slide && focus(Slide.slide);\n    });\n  }\n  function getAt(index) {\n    return items[Controller.toPage(index)];\n  }\n  function update() {\n    const prev = getAt(getIndex(true));\n    const curr = getAt(getIndex());\n    if (prev) {\n      removeClass(prev.button, CLASS_ACTIVE);\n      removeAttribute(prev.button, ARIA_CURRENT);\n    }\n    if (curr) {\n      addClass(curr.button, CLASS_ACTIVE);\n      setAttribute(curr.button, ARIA_CURRENT, true);\n    }\n    emit(EVENT_PAGINATION_UPDATED, { list, items }, prev, curr);\n  }\n  return {\n    items,\n    mount,\n    destroy,\n    getAt\n  };\n}\n\nconst TRIGGER_KEYS = [\" \", \"Enter\", \"Spacebar\"];\nfunction Sync(Splide2, Components2, options) {\n  const { splides } = Splide2;\n  const { list } = Components2.Elements;\n  function mount() {\n    if (options.isNavigation) {\n      navigate();\n    } else {\n      sync();\n    }\n  }\n  function destroy() {\n    removeAttribute(list, ALL_ATTRIBUTES);\n  }\n  function sync() {\n    const processed = [];\n    splides.concat(Splide2).forEach((splide, index, instances) => {\n      EventInterface(splide).on(EVENT_MOVE, (index2, prev, dest) => {\n        instances.forEach((instance) => {\n          if (instance !== splide && !includes(processed, splide)) {\n            processed.push(instance);\n            instance.go(instance.is(LOOP) ? dest : index2);\n          }\n        });\n        empty(processed);\n      });\n    });\n  }\n  function navigate() {\n    const { on, emit } = EventInterface(Splide2);\n    on(EVENT_CLICK, onClick);\n    on(EVENT_SLIDE_KEYDOWN, onKeydown);\n    on([EVENT_MOUNTED, EVENT_UPDATED], update);\n    setAttribute(list, ROLE, \"menu\");\n    emit(EVENT_NAVIGATION_MOUNTED, Splide2.splides);\n  }\n  function update() {\n    setAttribute(list, ARIA_ORIENTATION, options.direction !== TTB ? \"horizontal\" : null);\n  }\n  function onClick(Slide) {\n    Splide2.go(Slide.index);\n  }\n  function onKeydown(Slide, e) {\n    if (includes(TRIGGER_KEYS, e.key)) {\n      onClick(Slide);\n      prevent(e);\n    }\n  }\n  return {\n    mount,\n    destroy\n  };\n}\n\nfunction Wheel(Splide2, Components2, options) {\n  const { bind } = EventInterface(Splide2);\n  function mount() {\n    if (options.wheel) {\n      bind(Components2.Elements.track, \"wheel\", onWheel, { passive: false, capture: true });\n    }\n  }\n  function onWheel(e) {\n    const { deltaY } = e;\n    if (deltaY) {\n      Splide2.go(deltaY < 0 ? \"<\" : \">\");\n      prevent(e);\n    }\n  }\n  return {\n    mount\n  };\n}\n\nvar ComponentConstructors = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  Options: Options,\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});\n\nconst I18N = {\n  prev: \"Previous slide\",\n  next: \"Next slide\",\n  first: \"Go to first slide\",\n  last: \"Go to last slide\",\n  slideX: \"Go to slide %s\",\n  pageX: \"Go to page %s\",\n  play: \"Start autoplay\",\n  pause: \"Pause autoplay\"\n};\n\nconst DEFAULTS = {\n  type: \"slide\",\n  speed: 400,\n  waitForTransition: true,\n  perPage: 1,\n  arrows: true,\n  pagination: 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  slideFocus: true,\n  trimSpace: true,\n  focusableNodes: \"a, button, textarea, input, select, iframe\",\n  classes: CLASSES,\n  i18n: I18N\n};\n\nfunction Fade(Splide2, Components2, options) {\n  const { on } = EventInterface(Splide2);\n  function mount() {\n    on([EVENT_MOUNTED, EVENT_REFRESH], () => {\n      nextTick(() => {\n        Components2.Slides.style(\"transition\", `opacity ${options.speed}ms ${options.easing}`);\n      });\n    });\n  }\n  function start(index, done) {\n    const { track } = Components2.Elements;\n    style(track, \"height\", unit(rect(track).height));\n    nextTick(() => {\n      done();\n      style(track, \"height\", \"\");\n    });\n  }\n  return {\n    mount,\n    start,\n    cancel: noop\n  };\n}\n\nfunction Slide(Splide2, Components2, options) {\n  const { bind } = EventInterface(Splide2);\n  const { Move, Controller } = Components2;\n  const { list } = Components2.Elements;\n  let endCallback;\n  function mount() {\n    bind(list, \"transitionend\", (e) => {\n      if (e.target === list && endCallback) {\n        cancel();\n        endCallback();\n      }\n    });\n  }\n  function start(index, done) {\n    const destination = Move.toPosition(index, true);\n    const position = Move.getPosition();\n    const speed = getSpeed(index);\n    if (abs(destination - position) >= 1 && speed >= 1) {\n      apply(`transform ${speed}ms ${options.easing}`);\n      Move.translate(destination, true);\n      endCallback = done;\n    } else {\n      Move.jump(index);\n      done();\n    }\n  }\n  function cancel() {\n    apply(\"\");\n  }\n  function getSpeed(index) {\n    const { rewindSpeed } = options;\n    if (Splide2.is(SLIDE) && rewindSpeed) {\n      const prev = Controller.getIndex(true);\n      const end = Controller.getEnd();\n      if (prev === 0 && index >= end || prev >= end && index === 0) {\n        return rewindSpeed;\n      }\n    }\n    return options.speed;\n  }\n  function apply(transition) {\n    style(list, \"transition\", transition);\n  }\n  return {\n    mount,\n    start,\n    cancel\n  };\n}\n\nconst _Splide = class {\n  constructor(target, options) {\n    this.event = EventBus();\n    this.Components = {};\n    this.state = State(CREATED);\n    this.splides = [];\n    this._options = {};\n    this._Extensions = {};\n    const root = isString(target) ? query(document, target) : target;\n    assert(root, `${root} is invalid.`);\n    this.root = root;\n    merge(DEFAULTS, _Splide.defaults);\n    merge(merge(this._options, DEFAULTS), options || {});\n  }\n  mount(Extensions, Transition) {\n    const { state, Components: Components2 } = this;\n    assert(state.is([CREATED, DESTROYED]), \"Already mounted!\");\n    state.set(CREATED);\n    this._Components = Components2;\n    this._Transition = Transition || this._Transition || (this.is(FADE) ? Fade : Slide);\n    this._Extensions = Extensions || this._Extensions;\n    const Constructors = assign({}, ComponentConstructors, this._Extensions, { Transition: this._Transition });\n    forOwn(Constructors, (Component, key) => {\n      const component = Component(this, Components2, this._options);\n      Components2[key] = component;\n      component.setup && component.setup();\n    });\n    forOwn(Components2, (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  sync(splide) {\n    this.splides.push(splide);\n    splide.splides.push(this);\n    return this;\n  }\n  go(control) {\n    this._Components.Controller.go(control);\n    return this;\n  }\n  on(events, callback) {\n    this.event.on(events, callback, null, DEFAULT_USER_EVENT_PRIORITY);\n    return this;\n  }\n  off(events) {\n    this.event.off(events);\n    return this;\n  }\n  emit(event) {\n    this.event.emit(event, ...slice(arguments, 1));\n    return this;\n  }\n  add(slides, index) {\n    this._Components.Slides.add(slides, index);\n    return this;\n  }\n  remove(matcher) {\n    this._Components.Slides.remove(matcher);\n    return this;\n  }\n  is(type) {\n    return this._options.type === type;\n  }\n  refresh() {\n    this.emit(EVENT_REFRESH);\n    return this;\n  }\n  destroy(completely = true) {\n    const { event, state } = this;\n    if (state.is(CREATED)) {\n      event.on(EVENT_READY, this.destroy.bind(this, completely), this);\n    } else {\n      forOwn(this._Components, (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    return this;\n  }\n  get options() {\n    return this._options;\n  }\n  set options(options) {\n    const { _options } = this;\n    merge(_options, options);\n    if (!this.state.is(CREATED)) {\n      this.emit(EVENT_UPDATED, _options);\n    }\n  }\n  get length() {\n    return this._Components.Slides.getLength(true);\n  }\n  get index() {\n    return this._Components.Controller.getIndex();\n  }\n};\nlet Splide = _Splide;\nSplide.defaults = {};\nSplide.STATES = STATES;\n\nconst CLASS_RENDERED = \"is-rendered\";\n\nconst RENDERER_DEFAULT_CONFIG = {\n  listTag: \"ul\",\n  slideTag: \"li\"\n};\n\nclass Style {\n  constructor(id, options) {\n    this.styles = {};\n    this.id = id;\n    this.options = options;\n  }\n  rule(selector, prop, value, breakpoint) {\n    breakpoint = breakpoint || \"default\";\n    const selectors = this.styles[breakpoint] = this.styles[breakpoint] || {};\n    const styles = selectors[selector] = selectors[selector] || {};\n    styles[prop] = value;\n  }\n  build() {\n    let css = \"\";\n    if (this.styles.default) {\n      css += this.buildSelectors(this.styles.default);\n    }\n    Object.keys(this.styles).sort((n, m) => this.options.mediaQuery === \"min\" ? +n - +m : +m - +n).forEach((breakpoint) => {\n      if (breakpoint !== \"default\") {\n        css += `@media screen and (max-width: ${breakpoint}px) {`;\n        css += this.buildSelectors(this.styles[breakpoint]);\n        css += `}`;\n      }\n    });\n    return css;\n  }\n  buildSelectors(selectors) {\n    let css = \"\";\n    forOwn(selectors, (styles, selector) => {\n      css += `#${this.id} ${selector} {`;\n      forOwn(styles, (value, prop) => {\n        if (value || value === 0) {\n          css += `${prop}: ${value};`;\n        }\n      });\n      css += \"}\";\n    });\n    return css;\n  }\n}\n\nclass SplideRenderer {\n  constructor(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  static clean(splide) {\n    const { on } = EventInterface(splide);\n    const { root } = splide;\n    const clones = queryAll(root, `.${CLASS_CLONE}`);\n    on(EVENT_MOUNTED, () => {\n      remove(child(root, \"style\"));\n    });\n    remove(clones);\n  }\n  init() {\n    this.parseBreakpoints();\n    this.initSlides();\n    this.registerRootStyles();\n    this.registerTrackStyles();\n    this.registerSlideStyles();\n    this.registerListStyles();\n  }\n  initSlides() {\n    push(this.slides, this.contents.map((content, index) => {\n      content = isString(content) ? { html: content } : content;\n      content.styles = content.styles || {};\n      content.attrs = content.attrs || {};\n      this.cover(content);\n      const classes = `${this.options.classes.slide} ${index === 0 ? CLASS_ACTIVE : \"\"}`;\n      assign(content.attrs, {\n        class: `${classes} ${content.attrs.class || \"\"}`.trim(),\n        style: this.buildStyles(content.styles)\n      });\n      return content;\n    }));\n    if (this.isLoop()) {\n      this.generateClones(this.slides);\n    }\n  }\n  registerRootStyles() {\n    this.breakpoints.forEach(([width, options]) => {\n      this.Style.rule(\" \", \"max-width\", unit(options.width), width);\n    });\n  }\n  registerTrackStyles() {\n    const { Style: Style2 } = this;\n    const selector = `.${CLASS_TRACK}`;\n    this.breakpoints.forEach(([width, options]) => {\n      Style2.rule(selector, this.resolve(\"paddingLeft\"), this.cssPadding(options, false), width);\n      Style2.rule(selector, this.resolve(\"paddingRight\"), this.cssPadding(options, true), width);\n      Style2.rule(selector, \"height\", this.cssTrackHeight(options), width);\n    });\n  }\n  registerListStyles() {\n    const { Style: Style2 } = this;\n    const selector = `.${CLASS_LIST}`;\n    this.breakpoints.forEach(([width, options]) => {\n      Style2.rule(selector, \"transform\", this.buildTranslate(options), width);\n    });\n  }\n  registerSlideStyles() {\n    const { Style: Style2 } = this;\n    const selector = `.${CLASS_SLIDE}`;\n    this.breakpoints.forEach(([width, options]) => {\n      Style2.rule(selector, \"width\", this.cssSlideWidth(options), width);\n      Style2.rule(selector, this.resolve(\"marginRight\"), unit(options.gap) || \"0px\", width);\n      const height = this.cssSlideHeight(options);\n      if (height) {\n        Style2.rule(selector, \"height\", height, width);\n      } else {\n        Style2.rule(selector, \"padding-top\", this.cssSlidePadding(options), width);\n      }\n      Style2.rule(`${selector} > img`, \"display\", options.cover ? \"none\" : \"inline\", width);\n    });\n  }\n  buildTranslate(options) {\n    const { resolve, orient } = this.Direction;\n    const values = [];\n    values.push(this.cssOffsetClones(options));\n    values.push(this.cssOffsetGaps(options));\n    if (this.isCenter(options)) {\n      values.push(this.buildCssValue(orient(-50), \"%\"));\n      values.push(...this.cssOffsetCenter(options));\n    }\n    return values.filter(Boolean).map((value) => `translate${resolve(\"X\")}(${value})`).join(\" \");\n  }\n  cssOffsetClones(options) {\n    const { resolve, orient } = this.Direction;\n    const cloneCount = this.getCloneCount();\n    if (this.isFixedWidth(options)) {\n      const { value, unit: unit2 } = this.parseCssValue(options[resolve(\"fixedWidth\")]);\n      return this.buildCssValue(orient(value) * cloneCount, unit2);\n    }\n    const percent = 100 * cloneCount / options.perPage;\n    return `${orient(percent)}%`;\n  }\n  cssOffsetCenter(options) {\n    const { resolve, orient } = this.Direction;\n    if (this.isFixedWidth(options)) {\n      const { value, unit: unit2 } = this.parseCssValue(options[resolve(\"fixedWidth\")]);\n      return [this.buildCssValue(orient(value / 2), unit2)];\n    }\n    const values = [];\n    const { perPage, gap } = options;\n    values.push(`${orient(50 / perPage)}%`);\n    if (gap) {\n      const { value, unit: unit2 } = this.parseCssValue(gap);\n      const gapOffset = (value / perPage - value) / 2;\n      values.push(this.buildCssValue(orient(gapOffset), unit2));\n    }\n    return values;\n  }\n  cssOffsetGaps(options) {\n    const cloneCount = this.getCloneCount();\n    if (cloneCount && options.gap) {\n      const { orient } = this.Direction;\n      const { value, unit: unit2 } = this.parseCssValue(options.gap);\n      if (this.isFixedWidth(options)) {\n        return this.buildCssValue(orient(value * cloneCount), unit2);\n      }\n      const { perPage } = options;\n      const gaps = cloneCount / perPage;\n      return this.buildCssValue(orient(gaps * value), unit2);\n    }\n    return \"\";\n  }\n  resolve(prop) {\n    return camelToKebab(this.Direction.resolve(prop));\n  }\n  cssPadding(options, right) {\n    const { padding } = options;\n    const prop = this.Direction.resolve(right ? \"right\" : \"left\", true);\n    return padding && unit(padding[prop] || (isObject(padding) ? 0 : padding)) || \"0px\";\n  }\n  cssTrackHeight(options) {\n    let height = \"\";\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    return height;\n  }\n  cssHeight(options) {\n    return unit(options.height);\n  }\n  cssSlideWidth(options) {\n    return options.autoWidth ? \"\" : unit(options.fixedWidth) || (this.isVertical() ? \"\" : this.cssSlideSize(options));\n  }\n  cssSlideHeight(options) {\n    return unit(options.fixedHeight) || (this.isVertical() ? options.autoHeight ? \"\" : this.cssSlideSize(options) : this.cssHeight(options));\n  }\n  cssSlideSize(options) {\n    const gap = unit(options.gap);\n    return `calc((100%${gap && ` + ${gap}`})/${options.perPage || 1}${gap && ` - ${gap}`})`;\n  }\n  cssSlidePadding(options) {\n    const { heightRatio } = options;\n    return heightRatio ? `${heightRatio * 100}%` : \"\";\n  }\n  buildCssValue(value, unit2) {\n    return `${value}${unit2}`;\n  }\n  parseCssValue(value) {\n    if (isString(value)) {\n      const number = parseFloat(value) || 0;\n      const unit2 = value.replace(/\\d*(\\.\\d*)?/, \"\") || \"px\";\n      return { value: number, unit: unit2 };\n    }\n    return { value, unit: \"px\" };\n  }\n  parseBreakpoints() {\n    const { breakpoints } = this.options;\n    this.breakpoints.push([\"default\", this.options]);\n    if (breakpoints) {\n      forOwn(breakpoints, (options, width) => {\n        this.breakpoints.push([width, merge(merge({}, this.options), options)]);\n      });\n    }\n  }\n  isFixedWidth(options) {\n    return !!options[this.Direction.resolve(\"fixedWidth\")];\n  }\n  isLoop() {\n    return this.options.type === LOOP;\n  }\n  isCenter(options) {\n    if (options.focus === \"center\") {\n      if (this.isLoop()) {\n        return true;\n      }\n      if (this.options.type === SLIDE) {\n        return !this.options.trimSpace;\n      }\n    }\n    return false;\n  }\n  isVertical() {\n    return this.options.direction === TTB;\n  }\n  buildClasses() {\n    const { options } = this;\n    return [\n      CLASS_ROOT,\n      `${CLASS_ROOT}--${options.type}`,\n      `${CLASS_ROOT}--${options.direction}`,\n      options.drag && `${CLASS_ROOT}--draggable`,\n      options.isNavigation && `${CLASS_ROOT}--nav`,\n      CLASS_ACTIVE,\n      !this.config.hidden && CLASS_RENDERED\n    ].filter(Boolean).join(\" \");\n  }\n  buildAttrs(attrs) {\n    let attr = \"\";\n    forOwn(attrs, (value, key) => {\n      attr += value ? ` ${camelToKebab(key)}=\"${value}\"` : \"\";\n    });\n    return attr.trim();\n  }\n  buildStyles(styles) {\n    let style = \"\";\n    forOwn(styles, (value, key) => {\n      style += ` ${camelToKebab(key)}:${value};`;\n    });\n    return style.trim();\n  }\n  renderSlides() {\n    const { slideTag: tag } = this.config;\n    return this.slides.map((content) => {\n      return `<${tag} ${this.buildAttrs(content.attrs)}>${content.html || \"\"}</${tag}>`;\n    }).join(\"\");\n  }\n  cover(content) {\n    const { styles, html = \"\" } = content;\n    if (this.options.cover && !this.options.lazyLoad) {\n      const src = html.match(/<img.*?src\\s*=\\s*(['\"])(.+?)\\1.*?>/);\n      if (src && src[2]) {\n        styles.background = `center/cover no-repeat url('${src[2]}')`;\n      }\n    }\n  }\n  generateClones(contents) {\n    const { classes } = this.options;\n    const count = this.getCloneCount();\n    const slides = contents.slice();\n    while (slides.length < count) {\n      push(slides, slides);\n    }\n    push(slides.slice(-count).reverse(), slides.slice(0, count)).forEach((content, index) => {\n      const attrs = assign({}, content.attrs, { class: `${content.attrs.class} ${classes.clone}` });\n      const clone = assign({}, content, { attrs });\n      index < count ? contents.unshift(clone) : contents.push(clone);\n    });\n  }\n  getCloneCount() {\n    if (this.isLoop()) {\n      const { options } = this;\n      if (options.clones) {\n        return options.clones;\n      }\n      const perPage = max(...this.breakpoints.map(([, options2]) => options2.perPage));\n      return perPage * ((options.flickMaxPages || 1) + 1);\n    }\n    return 0;\n  }\n  renderArrows() {\n    let 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  renderArrow(prev) {\n    const { classes, i18n } = this.options;\n    const 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  html() {\n    const { rootClass, listTag, arrows, beforeTrack, afterTrack, slider, beforeSlider, afterSlider } = this.config;\n    let html = \"\";\n    html += `<div id=\"${this.id}\" class=\"${this.buildClasses()} ${rootClass || \"\"}\">`;\n    html += `<style>${this.Style.build()}</style>`;\n    if (slider) {\n      html += beforeSlider || \"\";\n      html += `<div class=\"splide__slider\">`;\n    }\n    html += beforeTrack || \"\";\n    if (arrows) {\n      html += this.renderArrows();\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    if (slider) {\n      html += `</div>`;\n      html += afterSlider || \"\";\n    }\n    html += `</div>`;\n    return html;\n  }\n}\n\nexport { CLASSES, CLASS_ACTIVE, CLASS_ARROW, CLASS_ARROWS, CLASS_ARROW_NEXT, CLASS_ARROW_PREV, CLASS_AUTOPLAY, CLASS_CLONE, CLASS_CONTAINER, CLASS_INITIALIZED, CLASS_LIST, CLASS_LOADING, CLASS_NEXT, CLASS_PAGINATION, CLASS_PAGINATION_PAGE, CLASS_PAUSE, CLASS_PLAY, CLASS_PREV, CLASS_PROGRESS, CLASS_PROGRESS_BAR, CLASS_ROOT, CLASS_SLIDE, CLASS_SLIDER, CLASS_SPINNER, CLASS_TRACK, CLASS_VISIBLE, 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_HIDDEN, EVENT_INACTIVE, EVENT_LAZYLOAD_LOADED, EVENT_MOUNTED, EVENT_MOVE, EVENT_MOVED, EVENT_NAVIGATION_MOUNTED, EVENT_PAGINATION_MOUNTED, EVENT_PAGINATION_UPDATED, EVENT_READY, EVENT_REFRESH, EVENT_REPOSITIONED, EVENT_RESIZE, EVENT_RESIZED, EVENT_SCROLL, EVENT_SCROLLED, EVENT_SLIDE_KEYDOWN, EVENT_UPDATED, EVENT_VISIBLE, EventBus, EventInterface, RequestInterval, STATUS_CLASSES, Splide, SplideRenderer, State, Throttle, Splide as default };\n","import Splide from '@splidejs/splide';\r\n\r\n \r\nwindow.Splide = Splide\r\n\r\n\r\ndocument.addEventListener( 'DOMContentLoaded', function() {\r\n  console.log('dom loaded.. rune splide')\r\n  var elms = document.getElementsByClassName( 'splide' );\r\n\r\n  for ( var i = 0; i < elms.length; i++ ) {\r\n\r\n\r\n    let options = elms.getAttribute('data-slide').split(\" \");\r\n\r\n    console.log(options)\r\n\r\n\r\n    new Splide( elms[ i ] ).mount();\r\n  }\r\n})\r\n\r\n"],"names":["PROJECT_CODE","DATA_ATTRIBUTE","STATES","CREATED","MOUNTED","IDLE","MOVING","DESTROYED","empty","array","length","isObject","subject","isNull","isArray","Array","isString","isUndefined","isHTMLElement","HTMLElement","toArray","value","forEach","values","iteratee","includes","indexOf","push","items","arrayProto","prototype","slice","arrayLike","start","end","call","toggleClass","elm","classes","add","name","classList","addClass","split","append","parent","children","appendChild","bind","before","nodes","ref","node","parentNode","insertBefore","matches","selector","filter","child","firstElementChild","forOwn","object","right","keys","Object","reverse","i","key","arguments","source","merge","removeAttribute","attrs","attr","setAttribute","value2","String","create","tag","document","createElement","style","prop","getComputedStyle","style2","display","display2","getAttribute","hasClass","className","contains","rect","target","getBoundingClientRect","remove","removeChild","parseHtml","html","DOMParser","parseFromString","body","prevent","e","stopPropagation","preventDefault","stopImmediatePropagation","query","querySelector","queryAll","querySelectorAll","removeClass","unit","assert","condition","message","Error","nextTick","callback","setTimeout","noop","raf","func","requestAnimationFrame","min","max","floor","ceil","abs","Math","between","number","minOrMax","maxOrMin","exclusive","minimum","maximum","clamp","x","y","sign","format","string","replacements","replacement","replace","pad","ids","uniqueId","prefix","EVENT_MOUNTED","EVENT_READY","EVENT_MOVE","EVENT_MOVED","EVENT_CLICK","EVENT_SLIDE_KEYDOWN","EVENT_REFRESH","EVENT_UPDATED","EVENT_RESIZE","EVENT_RESIZED","EVENT_REPOSITIONED","EVENT_SCROLL","EVENT_SCROLLED","EVENT_DESTROY","EVENT_NAVIGATION_MOUNTED","EVENT_LAZYLOAD_LOADED","EventInterface","Splide2","event","listeners","unbind","targets","events","forEachEvent","event2","listener","removeEventListener","destroy","data","offBy","on","priority","off","emit","options","addEventListener","RequestInterval","interval","onInterval","onUpdate","limit","now","Date","startTime","id","rate","paused","count","update","elapsed","pause","cancel","cancelAnimationFrame","resume","rewind","isPaused","Throttle","duration","apply","this","TTB","ORIENTATION_MAP","marginRight","autoWidth","fixedWidth","paddingLeft","paddingRight","width","left","X","Y","ArrowLeft","ArrowRight","Direction","Components2","resolve","axisOnly","direction","orient","CLASS_ROOT","CLASS_SLIDE","CLASS_CLONE","CLASS_ARROWS","CLASS_ARROW","CLASS_ARROW_PREV","CLASS_ARROW_NEXT","CLASS_PAGINATION","CLASS_ACTIVE","CLASS_PREV","CLASS_NEXT","CLASS_VISIBLE","CLASS_LOADING","STATUS_CLASSES","CLASSES","slide","clone","arrows","arrow","prev","next","pagination","page","spinner","ROLE","ARIA_CONTROLS","ARIA_CURRENT","ARIA_LABEL","ARIA_HIDDEN","TAB_INDEX","ARIA_ORIENTATION","ALL_ATTRIBUTES","SLIDE","LOOP","FADE","Slide$1","index","slideIndex","destroyEvents","Components","root","isNavigation","updateOnMove","styles","isClone","container","focusableNodes","destroyed","onMove","dest","updateActivity","currIndex","isActive","updateVisibility","is","trackRect","Elements","track","slideRect","isVisible","active","visible","ariaHidden","slideFocus","mount","idx","label","i18n","slideX","controls","splides","map","splide","join","init","type","useContainer","isWithin","from","distance","diff","XML_NAME_SPACE","PATH","POINTER_MOVE_EVENTS","POINTER_UP_EVENTS","IE_ARROW_KEYS","SRC_DATA_ATTRIBUTE","SRCSET_DATA_ATTRIBUTE","IMAGE_SELECTOR","TRIGGER_KEYS","ComponentConstructors","freeze","__proto__","Options","throttledObserve","observe","initialOptions","points","currPoint","completely","item","predicate","item2","point","newOptions","breakpoints","state","onMatch","setup","JSON","parse","isMin","mediaQuery","sort","n","m","matchMedia","elements","slides","slider","list","autoplay","find","bar","play","collect","identify","getClasses","refresh","drag","DEFAULT_EVENT_PRIORITY","Slides","Slides2","register","forEach$1","Slide2","get","excludeClones","matcher","Slide1","getIn","Controller","toIndex","hasFocus","perPage","getAt","images","img","observeImages","getLength","isEnough","Layout","vertical","cssPadding","resize","height","cssHeight","cssTrackHeight","gap","cssSlideSize","fixedHeight","autoHeight","padding","heightRatio","totalSize","withoutGap","Slide","getGap","parseFloat","window","listSize","slideSize","sliderSize","getPadding","Clones","clones","cloneCount","computeCloneCount","isHead","cloneNode","cloneDeep","generate","clones2","fixedSize","div","measure","flickMaxPages","Move","waiting","reposition","isBusy","Drag","isDragging","Scroll","jump","translate","toPosition","position","preventLoop","transform","getPosition","exceededMin","exceededLimit","exceededMax","shift","loop","backwards","excess","getLimit","size","trimming","focus","offset","trimSpace","trim","getEnd","move","set","looping","waitForTransition","Transition","go","minDistance","Infinity","isLoop","isSlide","slideCount","perMove","prevIndex","scroll","destination","useIndex","snap","toDest","setIndex","getNext","getAdjacent","getPrev","computeDestIndex","epsilon","incremental","toPage","closest","control","allowSameIndex","indicator","match","useScroll","speed","getIndex","Arrows","created","wrapper","createArrow","listen","prev2","arrowPath","nextIndex","prevLabel","last","nextLabel","first","disabled","Autoplay","hovered","focused","initButton","forPause","button","resetProgress","manual","autoToggle","pauseOnHover","pauseOnFocus","Cover","cover","src","toggle","scrollCallback","suppressConstraint","friction","clear","onScrolled","t","easingFunc","pow","easing","listenerOptions","passive","capture","basePosition","baseEvent","prevBaseEvent","lastEvent","isFree","dragging","clickPrevented","hasExceeded","disable","onPointerDown","isTouch","isTouchEvent","onPointerMove","onPointerUp","save","cancelable","expired","timeOf","exceeded","coordOf","dragMinThreshold","thresholds","mouse","touch","isSliderDirection","velocity","base","diffCoord","diffTime","isFlick","computeVelocity","flickPower","computeDestination","onClick","orthogonal","touches","timeStamp","TouchEvent","Keyboard","keyboard","onKeydown","normalizedKey","LazyLoad","isSequential","lazyLoad","preloadPages","_Slide","load","_img","error","_spinner","loadNext","onLoad","srcset","parentElement","Pagination","li","class","text","pageX","createPagination","preventScroll","curr","Sync","navigate","processed","concat","instances","index2","instance","sync","Wheel","onWheel","deltaY","wheel","DEFAULTS","Fade","done","endCallback","transition","rewindSpeed","getSpeed","_Splide","constructor","handlers","namespace","eventHandlers","handler","_key","_namespace","eventNS","fragments","_event","_callback","_priority","handler1","handler2","EventBus","initialState","states","State","_options","_Extensions","defaults","Extensions","_Components","_Transition","Component","component","Splide","console","log","elms","getElementsByClassName"],"sourceRoot":""}