text: 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); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
  
  /*!
   * Splide.js
   * Version  : 4.0.1
   * License  : MIT
   * Copyright: 2022 Naotoshi Fujita
   */
  (function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Splide = factory());
  })(this, function () {
    'use strict';
  
    var MEDIA_PREFERS_REDUCED_MOTION = "(prefers-reduced-motion: reduce)";
    var CREATED = 1;
    var MOUNTED = 2;
    var IDLE = 3;
    var MOVING = 4;
    var SCROLLING = 5;
    var DRAGGING = 6;
    var DESTROYED = 7;
    var STATES = {
      CREATED: CREATED,
      MOUNTED: MOUNTED,
      IDLE: IDLE,
      MOVING: MOVING,
      SCROLLING: SCROLLING,
      DRAGGING: DRAGGING,
      DESTROYED: DESTROYED
    };
  
    function empty(array) {
      array.length = 0;
    }
  
    function slice(arrayLike, start, end) {
      return Array.prototype.slice.call(arrayLike, start, end);
    }
  
    function apply(func) {
      return func.bind.apply(func, [null].concat(slice(arguments, 1)));
    }
  
    var nextTick = setTimeout;
  
    var noop = function noop() {};
  
    function raf(func) {
      return requestAnimationFrame(func);
    }
  
    function typeOf(type, subject) {
      return typeof subject === type;
    }
  
    function isObject(subject) {
      return !isNull(subject) && typeOf("object", subject);
    }
  
    var isArray = Array.isArray;
    var isFunction = apply(typeOf, "function");
    var isString = apply(typeOf, "string");
    var isUndefined = apply(typeOf, "undefined");
  
    function isNull(subject) {
      return subject === null;
    }
  
    function isHTMLElement(subject) {
      return subject instanceof HTMLElement;
    }
  
    function toArray(value) {
      return isArray(value) ? value : [value];
    }
  
    function forEach(values, iteratee) {
      toArray(values).forEach(iteratee);
    }
  
    function includes(array, value) {
      return array.indexOf(value) > -1;
    }
  
    function push(array, items) {
      array.push.apply(array, toArray(items));
      return array;
    }
  
    function toggleClass(elm, classes, add) {
      if (elm) {
        forEach(classes, function (name) {
          if (name) {
            elm.classList[add ? "add" : "remove"](name);
          }
        });
      }
    }
  
    function addClass(elm, classes) {
      toggleClass(elm, isString(classes) ? classes.split(" ") : classes, true);
    }
  
    function append(parent, children) {
      forEach(children, parent.appendChild.bind(parent));
    }
  
    function before(nodes, ref) {
      forEach(nodes, function (node) {
        var parent = (ref || node).parentNode;
  
        if (parent) {
          parent.insertBefore(node, ref);
        }
      });
    }
  
    function matches(elm, selector) {
      return isHTMLElement(elm) && (elm["msMatchesSelector"] || elm.matches).call(elm, selector);
    }
  
    function children(parent, selector) {
      var children2 = parent ? slice(parent.children) : [];
      return selector ? children2.filter(function (child) {
        return matches(child, selector);
      }) : children2;
    }
  
    function child(parent, selector) {
      return selector ? children(parent, selector)[0] : parent.firstElementChild;
    }
  
    var ownKeys = Object.keys;
  
    function forOwn(object, iteratee, right) {
      if (object) {
        var keys = ownKeys(object);
        keys = right ? keys.reverse() : keys;
  
        for (var i = 0; i < keys.length; i++) {
          var key = keys[i];
  
          if (key !== "__proto__") {
            if (iteratee(object[key], key) === false) {
              break;
            }
          }
        }
      }
  
      return object;
    }
  
    function assign(object) {
      slice(arguments, 1).forEach(function (source) {
        forOwn(source, function (value, key) {
          object[key] = source[key];
        });
      });
      return object;
    }
  
    function merge(object) {
      slice(arguments, 1).forEach(function (source) {
        forOwn(source, function (value, key) {
          if (isArray(value)) {
            object[key] = value.slice();
          } else if (isObject(value)) {
            object[key] = merge({}, isObject(object[key]) ? object[key] : {}, value);
          } else {
            object[key] = value;
          }
        });
      });
      return object;
    }
  
    function omit(object, keys) {
      toArray(keys || ownKeys(object)).forEach(function (key) {
        delete object[key];
      });
    }
  
    function removeAttribute(elms, attrs) {
      forEach(elms, function (elm) {
        forEach(attrs, function (attr) {
          elm && elm.removeAttribute(attr);
        });
      });
    }
  
    function setAttribute(elms, attrs, value) {
      if (isObject(attrs)) {
        forOwn(attrs, function (value2, name) {
          setAttribute(elms, name, value2);
        });
      } else {
        forEach(elms, function (elm) {
          isNull(value) || value === "" ? removeAttribute(elm, attrs) : elm.setAttribute(attrs, String(value));
        });
      }
    }
  
    function create(tag, attrs, parent) {
      var elm = document.createElement(tag);
  
      if (attrs) {
        isString(attrs) ? addClass(elm, attrs) : setAttribute(elm, attrs);
      }
  
      parent && append(parent, elm);
      return elm;
    }
  
    function style(elm, prop, value) {
      if (isUndefined(value)) {
        return getComputedStyle(elm)[prop];
      }
  
      if (!isNull(value)) {
        elm.style[prop] = "" + value;
      }
    }
  
    function display(elm, display2) {
      style(elm, "display", display2);
    }
  
    function focus(elm) {
      elm["setActive"] && elm["setActive"]() || elm.focus({
        preventScroll: true
      });
    }
  
    function getAttribute(elm, attr) {
      return elm.getAttribute(attr);
    }
  
    function hasClass(elm, className) {
      return elm && elm.classList.contains(className);
    }
  
    function rect(target) {
      return target.getBoundingClientRect();
    }
  
    function remove(nodes) {
      forEach(nodes, function (node) {
        if (node && node.parentNode) {
          node.parentNode.removeChild(node);
        }
      });
    }
  
    function parseHtml(html) {
      return child(new DOMParser().parseFromString(html, "text/html").body);
    }
  
    function prevent(e, stopPropagation) {
      e.preventDefault();
  
      if (stopPropagation) {
        e.stopPropagation();
        e.stopImmediatePropagation();
      }
    }
  
    function query(parent, selector) {
      return parent && parent.querySelector(selector);
    }
  
    function queryAll(parent, selector) {
      return selector ? slice(parent.querySelectorAll(selector)) : [];
    }
  
    function removeClass(elm, classes) {
      toggleClass(elm, classes, false);
    }
  
    function timeOf(e) {
      return e.timeStamp;
    }
  
    function unit(value) {
      return isString(value) ? value : value ? value + "px" : "";
    }
  
    var PROJECT_CODE = "splide";
    var DATA_ATTRIBUTE = "data-" + PROJECT_CODE;
  
    function assert(condition, message) {
      if (!condition) {
        throw new Error("[" + PROJECT_CODE + "] " + (message || ""));
      }
    }
  
    var min = Math.min,
        max = Math.max,
        floor = Math.floor,
        ceil = Math.ceil,
        abs = Math.abs;
  
    function approximatelyEqual(x, y, epsilon) {
      return abs(x - y) < epsilon;
    }
  
    function between(number, minOrMax, maxOrMin, exclusive) {
      var minimum = min(minOrMax, maxOrMin);
      var maximum = max(minOrMax, maxOrMin);
      return exclusive ? minimum < number && number < maximum : minimum <= number && number <= maximum;
    }
  
    function clamp(number, x, y) {
      var minimum = min(x, y);
      var maximum = max(x, y);
      return min(max(minimum, number), maximum);
    }
  
    function sign(x) {
      return +(x > 0) - +(x < 0);
    }
  
    function format(string, replacements) {
      forEach(replacements, function (replacement) {
        string = string.replace("%s", "" + replacement);
      });
      return string;
    }
  
    function pad(number) {
      return number < 10 ? "0" + number : "" + number;
    }
  
    var ids = {};
  
    function uniqueId(prefix) {
      return "" + prefix + pad(ids[prefix] = (ids[prefix] || 0) + 1);
    }
  
    function EventBinder() {
      var listeners = [];
  
      function bind(targets, events, callback, options) {
        forEachEvent(targets, events, function (target, event, namespace) {
          var isEventTarget = ("addEventListener" in target);
          var remover = isEventTarget ? target.removeEventListener.bind(target, event, callback, options) : target["removeListener"].bind(target, callback);
          isEventTarget ? target.addEventListener(event, callback, options) : target["addListener"](callback);
          listeners.push([target, event, namespace, callback, remover]);
        });
      }
  
      function unbind(targets, events, callback) {
        forEachEvent(targets, events, function (target, event, namespace) {
          listeners = listeners.filter(function (listener) {
            if (listener[0] === target && listener[1] === event && listener[2] === namespace && (!callback || listener[3] === callback)) {
              listener[4]();
              return false;
            }
  
            return true;
          });
        });
      }
  
      function dispatch(target, type, detail) {
        var e;
        var bubbles = true;
  
        if (typeof CustomEvent === "function") {
          e = new CustomEvent(type, {
            bubbles: bubbles,
            detail: detail
          });
        } else {
          e = document.createEvent("CustomEvent");
          e.initCustomEvent(type, bubbles, false, detail);
        }
  
        target.dispatchEvent(e);
        return e;
      }
  
      function forEachEvent(targets, events, iteratee) {
        forEach(targets, function (target) {
          target && forEach(events, function (events2) {
            events2.split(" ").forEach(function (eventNS) {
              var fragment = eventNS.split(".");
              iteratee(target, fragment[0], fragment[1]);
            });
          });
        });
      }
  
      function destroy() {
        listeners.forEach(function (data) {
          data[4]();
        });
        empty(listeners);
      }
  
      return {
        bind: bind,
        unbind: unbind,
        dispatch: dispatch,
        destroy: destroy
      };
    }
  
    var EVENT_MOUNTED = "mounted";
    var EVENT_READY = "ready";
    var EVENT_MOVE = "move";
    var EVENT_MOVED = "moved";
    var EVENT_SHIFTED = "shifted";
    var EVENT_CLICK = "click";
    var EVENT_ACTIVE = "active";
    var EVENT_INACTIVE = "inactive";
    var EVENT_VISIBLE = "visible";
    var EVENT_HIDDEN = "hidden";
    var EVENT_SLIDE_KEYDOWN = "slide:keydown";
    var EVENT_REFRESH = "refresh";
    var EVENT_UPDATED = "updated";
    var EVENT_RESIZE = "resize";
    var EVENT_RESIZED = "resized";
    var EVENT_DRAG = "drag";
    var EVENT_DRAGGING = "dragging";
    var EVENT_DRAGGED = "dragged";
    var EVENT_SCROLL = "scroll";
    var EVENT_SCROLLED = "scrolled";
    var EVENT_DESTROY = "destroy";
    var EVENT_ARROWS_MOUNTED = "arrows:mounted";
    var EVENT_ARROWS_UPDATED = "arrows:updated";
    var EVENT_PAGINATION_MOUNTED = "pagination:mounted";
    var EVENT_PAGINATION_UPDATED = "pagination:updated";
    var EVENT_NAVIGATION_MOUNTED = "navigation:mounted";
    var EVENT_AUTOPLAY_PLAY = "autoplay:play";
    var EVENT_AUTOPLAY_PLAYING = "autoplay:playing";
    var EVENT_AUTOPLAY_PAUSE = "autoplay:pause";
    var EVENT_LAZYLOAD_LOADED = "lazyload:loaded";
  
    function EventInterface(Splide2) {
      var bus = Splide2 ? Splide2.event.bus : document.createDocumentFragment();
      var binder = EventBinder();
  
      function on(events, callback) {
        binder.bind(bus, toArray(events).join(" "), function (e) {
          callback.apply(callback, isArray(e.detail) ? e.detail : []);
        });
      }
  
      function emit(event) {
        binder.dispatch(bus, event, slice(arguments, 1));
      }
  
      if (Splide2) {
        Splide2.event.on(EVENT_DESTROY, binder.destroy);
      }
  
      return assign(binder, {
        bus: bus,
        on: on,
        off: apply(binder.unbind, bus),
        emit: emit
      });
    }
  
    function RequestInterval(interval, onInterval, onUpdate, limit) {
      var now = Date.now;
      var startTime;
      var rate = 0;
      var id;
      var paused = true;
      var count = 0;
  
      function update() {
        if (!paused) {
          rate = interval ? min((now() - startTime) / interval, 1) : 1;
          onUpdate && onUpdate(rate);
  
          if (rate >= 1) {
            onInterval();
            startTime = now();
  
            if (limit && ++count >= limit) {
              return pause();
            }
          }
  
          raf(update);
        }
      }
  
      function start(resume) {
        !resume && cancel();
        startTime = now() - (resume ? rate * interval : 0);
        paused = false;
        raf(update);
      }
  
      function pause() {
        paused = true;
      }
  
      function rewind() {
        startTime = now();
        rate = 0;
  
        if (onUpdate) {
          onUpdate(rate);
        }
      }
  
      function cancel() {
        id && cancelAnimationFrame(id);
        rate = 0;
        id = 0;
        paused = true;
      }
  
      function set(time) {
        interval = time;
      }
  
      function isPaused() {
        return paused;
      }
  
      return {
        start: start,
        rewind: rewind,
        pause: pause,
        cancel: cancel,
        set: set,
        isPaused: isPaused
      };
    }
  
    function State(initialState) {
      var state = initialState;
  
      function set(value) {
        state = value;
      }
  
      function is(states) {
        return includes(toArray(states), state);
      }
  
      return {
        set: set,
        is: is
      };
    }
  
    function Throttle(func, duration) {
      var interval;
  
      function throttled() {
        if (!interval) {
          interval = RequestInterval(duration || 0, function () {
            func();
            interval = null;
          }, null, 1);
          interval.start();
        }
      }
  
      return throttled;
    }
  
    function Media(Splide2, Components2, options) {
      var state = Splide2.state;
      var breakpoints = options.breakpoints || {};
      var reducedMotion = options.reducedMotion || {};
      var binder = EventBinder();
      var queries = [];
  
      function setup() {
        var isMin = options.mediaQuery === "min";
        ownKeys(breakpoints).sort(function (n, m) {
          return isMin ? +n - +m : +m - +n;
        }).forEach(function (key) {
          register(breakpoints[key], "(" + (isMin ? "min" : "max") + "-width:" + key + "px)");
        });
        register(reducedMotion, MEDIA_PREFERS_REDUCED_MOTION);
        update();
      }
  
      function destroy(completely) {
        if (completely) {
          binder.destroy();
        }
      }
  
      function register(options2, query) {
        var queryList = matchMedia(query);
        binder.bind(queryList, "change", update);
        queries.push([options2, queryList]);
      }
  
      function update() {
        var destroyed = state.is(DESTROYED);
        var direction = options.direction;
        var merged = queries.reduce(function (merged2, entry) {
          return merge(merged2, entry[1].matches ? entry[0] : {});
        }, {});
        omit(options);
        set(merged);
  
        if (options.destroy) {
          Splide2.destroy(options.destroy === "completely");
        } else if (destroyed) {
          destroy(true);
          Splide2.mount();
        } else {
          direction !== options.direction && Splide2.refresh();
        }
      }
  
      function reduce(enable) {
        if (matchMedia(MEDIA_PREFERS_REDUCED_MOTION).matches) {
          enable ? merge(options, reducedMotion) : omit(options, ownKeys(reducedMotion));
        }
      }
  
      function set(opts, user) {
        merge(options, opts);
        user && merge(Object.getPrototypeOf(options), opts);
  
        if (!state.is(CREATED)) {
          Splide2.emit(EVENT_UPDATED, options);
        }
      }
  
      return {
        setup: setup,
        destroy: destroy,
        reduce: reduce,
        set: set
      };
    }
  
    var ARROW = "Arrow";
    var ARROW_LEFT = ARROW + "Left";
    var ARROW_RIGHT = ARROW + "Right";
    var ARROW_UP = ARROW + "Up";
    var ARROW_DOWN = ARROW + "Down";
    var RTL = "rtl";
    var TTB = "ttb";
    var ORIENTATION_MAP = {
      width: ["height"],
      left: ["top", "right"],
      right: ["bottom", "left"],
      x: ["y"],
      X: ["Y"],
      Y: ["X"],
      ArrowLeft: [ARROW_UP, ARROW_RIGHT],
      ArrowRight: [ARROW_DOWN, ARROW_LEFT]
    };
  
    function Direction(Splide2, Components2, options) {
      function resolve(prop, axisOnly, direction) {
        direction = direction || options.direction;
        var index = direction === RTL && !axisOnly ? 1 : direction === TTB ? 0 : -1;
        return ORIENTATION_MAP[prop] && ORIENTATION_MAP[prop][index] || prop.replace(/width|left|right/i, function (match, offset) {
          var replacement = ORIENTATION_MAP[match.toLowerCase()][index] || match;
          return offset > 0 ? replacement.charAt(0).toUpperCase() + replacement.slice(1) : replacement;
        });
      }
  
      function orient(value) {
        return value * (options.direction === RTL ? 1 : -1);
      }
  
      return {
        resolve: resolve,
        orient: orient
      };
    }
  
    var ROLE = "role";
    var TAB_INDEX = "tabindex";
    var DISABLED = "disabled";
    var ARIA_PREFIX = "aria-";
    var ARIA_CONTROLS = ARIA_PREFIX + "controls";
    var ARIA_CURRENT = ARIA_PREFIX + "current";
    var ARIA_SELECTED = ARIA_PREFIX + "selected";
    var ARIA_LABEL = ARIA_PREFIX + "label";
    var ARIA_LABELLEDBY = ARIA_PREFIX + "labelledby";
    var ARIA_HIDDEN = ARIA_PREFIX + "hidden";
    var ARIA_ORIENTATION = ARIA_PREFIX + "orientation";
    var ARIA_ROLEDESCRIPTION = ARIA_PREFIX + "roledescription";
    var ARIA_LIVE = ARIA_PREFIX + "live";
    var ARIA_RELEVANT = ARIA_PREFIX + "relevant";
    var ALL_ATTRIBUTES = [ROLE, TAB_INDEX, DISABLED, ARIA_CONTROLS, ARIA_CURRENT, ARIA_LABEL, ARIA_LABELLEDBY, ARIA_HIDDEN, ARIA_ORIENTATION, ARIA_ROLEDESCRIPTION];
    var CLASS_ROOT = PROJECT_CODE;
    var CLASS_TRACK = PROJECT_CODE + "__track";
    var CLASS_LIST = PROJECT_CODE + "__list";
    var CLASS_SLIDE = PROJECT_CODE + "__slide";
    var CLASS_CLONE = CLASS_SLIDE + "--clone";
    var CLASS_CONTAINER = CLASS_SLIDE + "__container";
    var CLASS_ARROWS = PROJECT_CODE + "__arrows";
    var CLASS_ARROW = PROJECT_CODE + "__arrow";
    var CLASS_ARROW_PREV = CLASS_ARROW + "--prev";
    var CLASS_ARROW_NEXT = CLASS_ARROW + "--next";
    var CLASS_PAGINATION = PROJECT_CODE + "__pagination";
    var CLASS_PAGINATION_PAGE = CLASS_PAGINATION + "__page";
    var CLASS_PROGRESS = PROJECT_CODE + "__progress";
    var CLASS_PROGRESS_BAR = CLASS_PROGRESS + "__bar";
    var CLASS_TOGGLE = PROJECT_CODE + "__toggle";
    var CLASS_SPINNER = PROJECT_CODE + "__spinner";
    var CLASS_SR = PROJECT_CODE + "__sr";
    var CLASS_INITIALIZED = "is-initialized";
    var CLASS_ACTIVE = "is-active";
    var CLASS_PREV = "is-prev";
    var CLASS_NEXT = "is-next";
    var CLASS_VISIBLE = "is-visible";
    var CLASS_LOADING = "is-loading";
    var CLASS_FOCUS_IN = "is-focus-in";
    var STATUS_CLASSES = [CLASS_ACTIVE, CLASS_VISIBLE, CLASS_PREV, CLASS_NEXT, CLASS_LOADING, CLASS_FOCUS_IN];
    var CLASSES = {
      slide: CLASS_SLIDE,
      clone: CLASS_CLONE,
      arrows: CLASS_ARROWS,
      arrow: CLASS_ARROW,
      prev: CLASS_ARROW_PREV,
      next: CLASS_ARROW_NEXT,
      pagination: CLASS_PAGINATION,
      page: CLASS_PAGINATION_PAGE,
      spinner: CLASS_SPINNER
    };
  
    function closest(from, selector) {
      if (isFunction(from.closest)) {
        return from.closest(selector);
      }
  
      var elm = from;
  
      while (elm && elm.nodeType === 1) {
        if (matches(elm, selector)) {
          break;
        }
  
        elm = elm.parentElement;
      }
  
      return elm;
    }
  
    var FRICTION = 5;
    var LOG_INTERVAL = 200;
    var POINTER_DOWN_EVENTS = "touchstart mousedown";
    var POINTER_MOVE_EVENTS = "touchmove mousemove";
    var POINTER_UP_EVENTS = "touchend touchcancel mouseup";
  
    function Elements(Splide2, Components2, options) {
      var _EventInterface = EventInterface(Splide2),
          on = _EventInterface.on,
          bind = _EventInterface.bind;
  
      var root = Splide2.root;
      var i18n = options.i18n;
      var elements = {};
      var slides = [];
      var rootClasses = [];
      var trackClasses = [];
      var track;
      var list;
      var isUsingKey;
  
      function setup() {
        collect();
        init();
        update();
      }
  
      function mount() {
        on(EVENT_REFRESH, destroy);
        on(EVENT_REFRESH, setup);
        on(EVENT_UPDATED, update);
        bind(document, POINTER_DOWN_EVENTS + " keydown", function (e) {
          isUsingKey = e.type === "keydown";
        }, {
          capture: true
        });
        bind(root, "focusin", function () {
          toggleClass(root, CLASS_FOCUS_IN, !!isUsingKey);
        });
      }
  
      function destroy(completely) {
        var attrs = ALL_ATTRIBUTES.concat("style");
        empty(slides);
        removeClass(root, rootClasses);
        removeClass(track, trackClasses);
        removeAttribute([track, list], attrs);
        removeAttribute(root, completely ? attrs : ["style", ARIA_ROLEDESCRIPTION]);
      }
  
      function update() {
        removeClass(root, rootClasses);
        removeClass(track, trackClasses);
        rootClasses = getClasses(CLASS_ROOT);
        trackClasses = getClasses(CLASS_TRACK);
        addClass(root, rootClasses);
        addClass(track, trackClasses);
        setAttribute(root, ARIA_LABEL, options.label);
        setAttribute(root, ARIA_LABELLEDBY, options.labelledby);
      }
  
      function collect() {
        track = find("." + CLASS_TRACK);
        list = child(track, "." + CLASS_LIST);
        assert(track && list, "A track/list element is missing.");
        push(slides, children(list, "." + CLASS_SLIDE + ":not(." + CLASS_CLONE + ")"));
        forOwn({
          arrows: CLASS_ARROWS,
          pagination: CLASS_PAGINATION,
          prev: CLASS_ARROW_PREV,
          next: CLASS_ARROW_NEXT,
          bar: CLASS_PROGRESS_BAR,
          toggle: CLASS_TOGGLE
        }, function (className, key) {
          elements[key] = find("." + className);
        });
        assign(elements, {
          root: root,
          track: track,
          list: list,
          slides: slides
        });
      }
  
      function init() {
        var id = root.id || uniqueId(PROJECT_CODE);
        var role = options.role;
        root.id = id;
        track.id = track.id || id + "-track";
        list.id = list.id || id + "-list";
  
        if (!getAttribute(root, ROLE) && root.tagName !== "SECTION" && role) {
          setAttribute(root, ROLE, role);
        }
  
        setAttribute(root, ARIA_ROLEDESCRIPTION, i18n.carousel);
        setAttribute(list, ROLE, "presentation");
      }
  
      function find(selector) {
        var elm = query(root, selector);
        return elm && closest(elm, "." + CLASS_ROOT) === root ? elm : void 0;
      }
  
      function getClasses(base) {
        return [base + "--" + options.type, base + "--" + options.direction, options.drag && base + "--draggable", options.isNavigation && base + "--nav", base === CLASS_ROOT && CLASS_ACTIVE];
      }
  
      return assign(elements, {
        setup: setup,
        mount: mount,
        destroy: destroy
      });
    }
  
    var SLIDE = "slide";
    var LOOP = "loop";
    var FADE = "fade";
  
    function Slide$1(Splide2, index, slideIndex, slide) {
      var event = EventInterface(Splide2);
      var on = event.on,
          emit = event.emit,
          bind = event.bind;
      var Components = Splide2.Components,
          root = Splide2.root,
          options = Splide2.options;
      var isNavigation = options.isNavigation,
          updateOnMove = options.updateOnMove,
          i18n = options.i18n,
          pagination = options.pagination,
          slideFocus = options.slideFocus;
      var resolve = Components.Direction.resolve;
      var styles = getAttribute(slide, "style");
      var label = getAttribute(slide, ARIA_LABEL);
      var isClone = slideIndex > -1;
      var container = child(slide, "." + CLASS_CONTAINER);
      var focusableNodes = queryAll(slide, options.focusableNodes || "");
      var destroyed;
  
      function mount() {
        if (!isClone) {
          slide.id = root.id + "-slide" + pad(index + 1);
          setAttribute(slide, ROLE, pagination ? "tabpanel" : "group");
          setAttribute(slide, ARIA_ROLEDESCRIPTION, i18n.slide);
          setAttribute(slide, ARIA_LABEL, label || format(i18n.slideLabel, [index + 1, Splide2.length]));
        }
  
        listen();
      }
  
      function listen() {
        bind(slide, "click", apply(emit, EVENT_CLICK, self));
        bind(slide, "keydown", apply(emit, EVENT_SLIDE_KEYDOWN, self));
        on([EVENT_MOVED, EVENT_SHIFTED, EVENT_SCROLLED], update);
        on(EVENT_NAVIGATION_MOUNTED, initNavigation);
  
        if (updateOnMove) {
          on(EVENT_MOVE, onMove);
        }
      }
  
      function destroy() {
        destroyed = true;
        event.destroy();
        removeClass(slide, STATUS_CLASSES);
        removeAttribute(slide, ALL_ATTRIBUTES);
        setAttribute(slide, "style", styles);
        setAttribute(slide, ARIA_LABEL, label || "");
      }
  
      function initNavigation() {
        var controls = Splide2.splides.map(function (target) {
          var Slide2 = target.splide.Components.Slides.getAt(index);
          return Slide2 ? Slide2.slide.id : "";
        }).join(" ");
        setAttribute(slide, ARIA_LABEL, format(i18n.slideX, (isClone ? slideIndex : index) + 1));
        setAttribute(slide, ARIA_CONTROLS, controls);
        setAttribute(slide, ROLE, slideFocus ? "button" : "");
        slideFocus && removeAttribute(slide, ARIA_ROLEDESCRIPTION);
      }
  
      function onMove() {
        if (!destroyed) {
          update();
        }
      }
  
      function update() {
        if (!destroyed) {
          var curr = Splide2.index;
          updateActivity();
          updateVisibility();
          toggleClass(slide, CLASS_PREV, index === curr - 1);
          toggleClass(slide, CLASS_NEXT, index === curr + 1);
        }
      }
  
      function updateActivity() {
        var active = isActive();
  
        if (active !== hasClass(slide, CLASS_ACTIVE)) {
          toggleClass(slide, CLASS_ACTIVE, active);
          setAttribute(slide, ARIA_CURRENT, isNavigation && active || "");
          emit(active ? EVENT_ACTIVE : EVENT_INACTIVE, self);
        }
      }
  
      function updateVisibility() {
        var visible = isVisible();
        var hidden = !visible && (!isActive() || isClone);
  
        if (!Splide2.state.is([MOVING, SCROLLING])) {
          setAttribute(slide, ARIA_HIDDEN, hidden || "");
        }
  
        setAttribute(focusableNodes, TAB_INDEX, hidden ? -1 : "");
  
        if (slideFocus) {
          setAttribute(slide, TAB_INDEX, hidden ? -1 : 0);
        }
  
        if (visible !== hasClass(slide, CLASS_VISIBLE)) {
          toggleClass(slide, CLASS_VISIBLE, visible);
          emit(visible ? EVENT_VISIBLE : EVENT_HIDDEN, self);
        }
  
        if (!visible && document.activeElement === slide) {
          var Slide2 = Components.Slides.getAt(Splide2.index);
          Slide2 && focus(Slide2.slide);
        }
      }
  
      function style$1(prop, value, useContainer) {
        style(useContainer && container || slide, prop, value);
      }
  
      function isActive() {
        var curr = Splide2.index;
        return curr === index || options.cloneStatus && curr === slideIndex;
      }
  
      function isVisible() {
        if (Splide2.is(FADE)) {
          return isActive();
        }
  
        var trackRect = rect(Components.Elements.track);
        var slideRect = rect(slide);
        var left = resolve("left");
        var right = resolve("right");
        return floor(trackRect[left]) <= ceil(slideRect[left]) && floor(slideRect[right]) <= ceil(trackRect[right]);
      }
  
      function isWithin(from, distance) {
        var diff = abs(from - index);
  
        if (!isClone && (options.rewind || Splide2.is(LOOP))) {
          diff = min(diff, Splide2.length - diff);
        }
  
        return diff <= distance;
      }
  
      var self = {
        index: index,
        slideIndex: slideIndex,
        slide: slide,
        container: container,
        isClone: isClone,
        mount: mount,
        destroy: destroy,
        update: update,
        style: style$1,
        isWithin: isWithin
      };
      return self;
    }
  
    function Slides(Splide2, Components2, options) {
      var _EventInterface2 = EventInterface(Splide2),
          on = _EventInterface2.on,
          emit = _EventInterface2.emit,
          bind = _EventInterface2.bind;
  
      var _Components2$Elements = Components2.Elements,
          slides = _Components2$Elements.slides,
          list = _Components2$Elements.list;
      var Slides2 = [];
  
      function mount() {
        init();
        on(EVENT_REFRESH, destroy);
        on(EVENT_REFRESH, init);
        on([EVENT_MOUNTED, EVENT_REFRESH], function () {
          Slides2.sort(function (Slide1, Slide2) {
            return Slide1.index - Slide2.index;
          });
        });
      }
  
      function init() {
        slides.forEach(function (slide, index) {
          register(slide, index, -1);
        });
      }
  
      function destroy() {
        forEach$1(function (Slide2) {
          Slide2.destroy();
        });
        empty(Slides2);
      }
  
      function update() {
        forEach$1(function (Slide2) {
          Slide2.update();
        });
      }
  
      function register(slide, index, slideIndex) {
        var object = Slide$1(Splide2, index, slideIndex, slide);
        object.mount();
        Slides2.push(object);
      }
  
      function get(excludeClones) {
        return excludeClones ? filter(function (Slide2) {
          return !Slide2.isClone;
        }) : Slides2;
      }
  
      function getIn(page) {
        var Controller = Components2.Controller;
        var index = Controller.toIndex(page);
        var max = Controller.hasFocus() ? 1 : options.perPage;
        return filter(function (Slide2) {
          return between(Slide2.index, index, index + max - 1);
        });
      }
  
      function getAt(index) {
        return filter(index)[0];
      }
  
      function add(items, index) {
        forEach(items, function (slide) {
          if (isString(slide)) {
            slide = parseHtml(slide);
          }
  
          if (isHTMLElement(slide)) {
            var ref = slides[index];
            ref ? before(slide, ref) : append(list, slide);
            addClass(slide, options.classes.slide);
            observeImages(slide, apply(emit, EVENT_RESIZE));
          }
        });
        emit(EVENT_REFRESH);
      }
  
      function remove$1(matcher) {
        remove(filter(matcher).map(function (Slide2) {
          return Slide2.slide;
        }));
        emit(EVENT_REFRESH);
      }
  
      function forEach$1(iteratee, excludeClones) {
        get(excludeClones).forEach(iteratee);
      }
  
      function filter(matcher) {
        return Slides2.filter(isFunction(matcher) ? matcher : function (Slide2) {
          return isString(matcher) ? matches(Slide2.slide, matcher) : includes(toArray(matcher), Slide2.index);
        });
      }
  
      function style(prop, value, useContainer) {
        forEach$1(function (Slide2) {
          Slide2.style(prop, value, useContainer);
        });
      }
  
      function observeImages(elm, callback) {
        var images = queryAll(elm, "img");
        var length = images.length;
  
        if (length) {
          images.forEach(function (img) {
            bind(img, "load error", function () {
              if (! --length) {
                callback();
              }
            });
          });
        } else {
          callback();
        }
      }
  
      function getLength(excludeClones) {
        return excludeClones ? slides.length : Slides2.length;
      }
  
      function isEnough() {
        return Slides2.length > options.perPage;
      }
  
      return {
        mount: mount,
        destroy: destroy,
        update: update,
        register: register,
        get: get,
        getIn: getIn,
        getAt: getAt,
        add: add,
        remove: remove$1,
        forEach: forEach$1,
        filter: filter,
        style: style,
        getLength: getLength,
        isEnough: isEnough
      };
    }
  
    function Layout(Splide2, Components2, options) {
      var _EventInterface3 = EventInterface(Splide2),
          on = _EventInterface3.on,
          bind = _EventInterface3.bind,
          emit = _EventInterface3.emit;
  
      var Slides = Components2.Slides;
      var resolve = Components2.Direction.resolve;
      var _Components2$Elements2 = Components2.Elements,
          root = _Components2$Elements2.root,
          track = _Components2$Elements2.track,
          list = _Components2$Elements2.list;
      var getAt = Slides.getAt,
          styleSlides = Slides.style;
      var vertical;
      var rootRect;
  
      function mount() {
        init();
        bind(window, "resize load", Throttle(apply(emit, EVENT_RESIZE)));
        on([EVENT_UPDATED, EVENT_REFRESH], init);
        on(EVENT_RESIZE, resize);
      }
  
      function init() {
        rootRect = null;
        vertical = options.direction === TTB;
        style(root, "maxWidth", unit(options.width));
        style(track, resolve("paddingLeft"), cssPadding(false));
        style(track, resolve("paddingRight"), cssPadding(true));
        resize();
      }
  
      function resize() {
        var newRect = rect(root);
  
        if (!rootRect || rootRect.width !== newRect.width || rootRect.height !== newRect.height) {
          style(track, "height", cssTrackHeight());
          styleSlides(resolve("marginRight"), unit(options.gap));
          styleSlides("width", cssSlideWidth());
          styleSlides("height", cssSlideHeight(), true);
          rootRect = newRect;
          emit(EVENT_RESIZED);
        }
      }
  
      function cssPadding(right) {
        var padding = options.padding;
        var prop = resolve(right ? "right" : "left");
        return padding && unit(padding[prop] || (isObject(padding) ? 0 : padding)) || "0px";
      }
  
      function cssTrackHeight() {
        var height = "";
  
        if (vertical) {
          height = cssHeight();
          assert(height, "height or heightRatio is missing.");
          height = "calc(" + height + " - " + cssPadding(false) + " - " + cssPadding(true) + ")";
        }
  
        return height;
      }
  
      function cssHeight() {
        return unit(options.height || rect(list).width * options.heightRatio);
      }
  
      function cssSlideWidth() {
        return options.autoWidth ? null : unit(options.fixedWidth) || (vertical ? "" : cssSlideSize());
      }
  
      function cssSlideHeight() {
        return unit(options.fixedHeight) || (vertical ? options.autoHeight ? null : cssSlideSize() : cssHeight());
      }
  
      function cssSlideSize() {
        var gap = unit(options.gap);
        return "calc((100%" + (gap && " + " + gap) + ")/" + (options.perPage || 1) + (gap && " - " + gap) + ")";
      }
  
      function listSize() {
        return rect(list)[resolve("width")];
      }
  
      function slideSize(index, withoutGap) {
        var Slide = getAt(index || 0);
        return Slide ? rect(Slide.slide)[resolve("width")] + (withoutGap ? 0 : getGap()) : 0;
      }
  
      function totalSize(index, withoutGap) {
        var Slide = getAt(index);
  
        if (Slide) {
          var right = rect(Slide.slide)[resolve("right")];
          var left = rect(list)[resolve("left")];
          return abs(right - left) + (withoutGap ? 0 : getGap());
        }
  
        return 0;
      }
  
      function sliderSize() {
        return totalSize(Splide2.length - 1, true) - totalSize(-1, true);
      }
  
      function getGap() {
        var Slide = getAt(0);
        return Slide && parseFloat(style(Slide.slide, resolve("marginRight"))) || 0;
      }
  
      function getPadding(right) {
        return parseFloat(style(track, resolve("padding" + (right ? "Right" : "Left")))) || 0;
      }
  
      return {
        mount: mount,
        listSize: listSize,
        slideSize: slideSize,
        sliderSize: sliderSize,
        totalSize: totalSize,
        getPadding: getPadding
      };
    }
  
    var MULTIPLIER = 2;
  
    function Clones(Splide2, Components2, options) {
      var _EventInterface4 = EventInterface(Splide2),
          on = _EventInterface4.on,
          emit = _EventInterface4.emit;
  
      var Elements = Components2.Elements,
          Slides = Components2.Slides;
      var resolve = Components2.Direction.resolve;
      var clones = [];
      var cloneCount;
  
      function mount() {
        init();
        on(EVENT_REFRESH, destroy);
        on(EVENT_REFRESH, init);
        on([EVENT_UPDATED, EVENT_RESIZE], observe);
      }
  
      function init() {
        if (cloneCount = computeCloneCount()) {
          generate(cloneCount);
          emit(EVENT_RESIZE);
        }
      }
  
      function destroy() {
        remove(clones);
        empty(clones);
      }
  
      function observe() {
        if (cloneCount < computeCloneCount()) {
          emit(EVENT_REFRESH);
        }
      }
  
      function generate(count) {
        var slides = Slides.get().slice();
        var length = slides.length;
  
        if (length) {
          while (slides.length < count) {
            push(slides, slides);
          }
  
          push(slides.slice(-count), slides.slice(0, count)).forEach(function (Slide, index) {
            var isHead = index < count;
            var clone = cloneDeep(Slide.slide, index);
            isHead ? before(clone, slides[0].slide) : append(Elements.list, clone);
            push(clones, clone);
            Slides.register(clone, index - count + (isHead ? 0 : length), Slide.index);
          });
        }
      }
  
      function cloneDeep(elm, index) {
        var clone = elm.cloneNode(true);
        addClass(clone, options.classes.clone);
        clone.id = Splide2.root.id + "-clone" + pad(index + 1);
        return clone;
      }
  
      function computeCloneCount() {
        var clones2 = options.clones;
  
        if (!Splide2.is(LOOP)) {
          clones2 = 0;
        } else if (!clones2) {
          var fixedSize = options[resolve("fixedWidth")] && Components2.Layout.slideSize(0);
          var fixedCount = fixedSize && ceil(rect(Elements.track)[resolve("width")] / fixedSize);
          clones2 = fixedCount || options[resolve("autoWidth")] && Splide2.length || options.perPage * MULTIPLIER;
        }
  
        return clones2;
      }
  
      return {
        mount: mount,
        destroy: destroy
      };
    }
  
    function Move(Splide2, Components2, options) {
      var _EventInterface5 = EventInterface(Splide2),
          on = _EventInterface5.on,
          emit = _EventInterface5.emit;
  
      var set = Splide2.state.set;
      var _Components2$Layout = Components2.Layout,
          slideSize = _Components2$Layout.slideSize,
          getPadding = _Components2$Layout.getPadding,
          totalSize = _Components2$Layout.totalSize,
          listSize = _Components2$Layout.listSize,
          sliderSize = _Components2$Layout.sliderSize;
      var _Components2$Directio = Components2.Direction,
          resolve = _Components2$Directio.resolve,
          orient = _Components2$Directio.orient;
      var _Components2$Elements3 = Components2.Elements,
          list = _Components2$Elements3.list,
          track = _Components2$Elements3.track;
      var Transition;
  
      function mount() {
        Transition = Components2.Transition;
        on([EVENT_MOUNTED, EVENT_RESIZED, EVENT_UPDATED, EVENT_REFRESH], reposition);
      }
  
      function reposition() {
        if (!Components2.Controller.isBusy()) {
          Components2.Scroll.cancel();
          jump(Splide2.index);
          Components2.Slides.update();
        }
      }
  
      function move(dest, index, prev, callback) {
        var position = getPosition();
  
        if (dest !== index && canShift(dest > index)) {
          cancel();
          translate(shift(position, dest > index), true);
        }
  
        set(MOVING);
        emit(EVENT_MOVE, index, prev, dest);
        Transition.start(index, function () {
          set(IDLE);
          emit(EVENT_MOVED, index, prev, dest);
          callback && callback();
        });
      }
  
      function jump(index) {
        translate(toPosition(index, true));
      }
  
      function translate(position, preventLoop) {
        if (!Splide2.is(FADE)) {
          var translateDirection = resolve("X");
          var destination = preventLoop ? position : loop(position);
          style(list, "transform", "translate3d(" + (translateDirection === "Y" ? "0" : destination) + "px, " + (translateDirection === "X" ? "0" : destination) + "px, 0)");
          position !== destination && emit(EVENT_SHIFTED);
        }
      }
  
      function loop(position) {
        if (Splide2.is(LOOP)) {
          var diff = orient(position - getPosition());
          var exceededMin = exceededLimit(false, position) && diff < 0;
          var exceededMax = exceededLimit(true, position) && diff > 0;
  
          if (exceededMin || exceededMax) {
            position = shift(position, exceededMax);
          }
        }
  
        return position;
      }
  
      function shift(position, backwards) {
        var excess = position - getLimit(backwards);
        var size = sliderSize();
        position -= orient(size * (ceil(abs(excess) / size) || 1)) * (backwards ? 1 : -1);
        return position;
      }
  
      function cancel() {
        translate(getPosition());
        Transition.cancel();
      }
  
      function toIndex(position) {
        var Slides = Components2.Slides.get();
        var index = 0;
        var minDistance = Infinity;
  
        for (var i = 0; i < Slides.length; i++) {
          var slideIndex = Slides[i].index;
          var distance = abs(toPosition(slideIndex, true) - position);
  
          if (distance <= minDistance) {
            minDistance = distance;
            index = slideIndex;
          } else {
            break;
          }
        }
  
        return index;
      }
  
      function toPosition(index, trimming) {
        var position = orient(totalSize(index - 1) - offset(index));
        return trimming ? trim(position) : position;
      }
  
      function getPosition() {
        var left = resolve("left");
        return rect(list)[left] - rect(track)[left] + orient(getPadding(false));
      }
  
      function trim(position) {
        if (options.trimSpace && Splide2.is(SLIDE)) {
          position = clamp(position, 0, orient(sliderSize() - listSize()));
        }
  
        return position;
      }
  
      function offset(index) {
        var focus = options.focus;
        return focus === "center" ? (listSize() - slideSize(index, true)) / 2 : +focus * slideSize(index) || 0;
      }
  
      function getLimit(max) {
        return toPosition(max ? Components2.Controller.getEnd() : 0, !!options.trimSpace);
      }
  
      function canShift(backwards) {
        var shifted = orient(shift(getPosition(), backwards));
        return backwards ? shifted >= 0 : shifted <= list["scroll" + resolve("Width")] - rect(track)[resolve("width")];
      }
  
      function exceededLimit(max, position) {
        position = isUndefined(position) ? getPosition() : position;
        var exceededMin = max !== true && orient(position) < orient(getLimit(false));
        var exceededMax = max !== false && orient(position) > orient(getLimit(true));
        return exceededMin || exceededMax;
      }
  
      return {
        mount: mount,
        move: move,
        jump: jump,
        translate: translate,
        shift: shift,
        cancel: cancel,
        toIndex: toIndex,
        toPosition: toPosition,
        getPosition: getPosition,
        getLimit: getLimit,
        exceededLimit: exceededLimit,
        reposition: reposition
      };
    }
  
    function Controller(Splide2, Components2, options) {
      var _EventInterface6 = EventInterface(Splide2),
          on = _EventInterface6.on;
  
      var Move = Components2.Move;
      var getPosition = Move.getPosition,
          getLimit = Move.getLimit,
          toPosition = Move.toPosition;
      var _Components2$Slides = Components2.Slides,
          isEnough = _Components2$Slides.isEnough,
          getLength = _Components2$Slides.getLength;
      var isLoop = Splide2.is(LOOP);
      var isSlide = Splide2.is(SLIDE);
      var getNext = apply(getAdjacent, false);
      var getPrev = apply(getAdjacent, true);
      var currIndex = options.start || 0;
      var prevIndex = currIndex;
      var slideCount;
      var perMove;
      var perPage;
  
      function mount() {
        init();
        on([EVENT_UPDATED, EVENT_REFRESH], init);
      }
  
      function init() {
        slideCount = getLength(true);
        perMove = options.perMove;
        perPage = options.perPage;
        var index = clamp(currIndex, 0, slideCount - 1);
  
        if (index !== currIndex) {
          currIndex = index;
          Move.reposition();
        }
      }
  
      function go(control, allowSameIndex, callback) {
        if (!isBusy()) {
          var dest = parse(control);
          var index = loop(dest);
  
          if (index > -1 && (allowSameIndex || index !== currIndex)) {
            setIndex(index);
            Move.move(dest, index, prevIndex, callback);
          }
        }
      }
  
      function scroll(destination, duration, snap, callback) {
        Components2.Scroll.scroll(destination, duration, snap, function () {
          setIndex(loop(Move.toIndex(Move.getPosition())));
          callback && callback();
        });
      }
  
      function parse(control) {
        var index = currIndex;
  
        if (isString(control)) {
          var _ref = control.match(/([+\-<>])(\d+)?/) || [],
              indicator = _ref[1],
              number = _ref[2];
  
          if (indicator === "+" || indicator === "-") {
            index = computeDestIndex(currIndex + +("" + indicator + (+number || 1)), currIndex);
          } else if (indicator === ">") {
            index = number ? toIndex(+number) : getNext(true);
          } else if (indicator === "<") {
            index = getPrev(true);
          }
        } else {
          index = isLoop ? control : clamp(control, 0, getEnd());
        }
  
        return index;
      }
  
      function getAdjacent(prev, destination) {
        var number = perMove || (hasFocus() ? 1 : perPage);
        var dest = computeDestIndex(currIndex + number * (prev ? -1 : 1), currIndex, !(perMove || hasFocus()));
  
        if (dest === -1 && isSlide) {
          if (!approximatelyEqual(getPosition(), getLimit(!prev), 1)) {
            return prev ? 0 : getEnd();
          }
        }
  
        return destination ? dest : loop(dest);
      }
  
      function computeDestIndex(dest, from, snapPage) {
        if (isEnough()) {
          var end = getEnd();
          var index = computeMovableDestIndex(dest);
  
          if (index !== dest) {
            from = dest;
            dest = index;
            snapPage = false;
          }
  
          if (dest < 0 || dest > end) {
            if (between(0, dest, from, true) || between(end, from, dest, true)) {
              dest = toIndex(toPage(dest));
            } else {
              if (isLoop) {
                dest = snapPage ? dest < 0 ? -(slideCount % perPage || perPage) : slideCount : dest;
              } else if (options.rewind) {
                dest = dest < 0 ? end : 0;
              } else {
                dest = -1;
              }
            }
          } else {
            if (snapPage && dest !== from) {
              dest = toIndex(toPage(from) + (dest < from ? -1 : 1));
            }
          }
        } else {
          dest = -1;
        }
  
        return dest;
      }
  
      function computeMovableDestIndex(dest) {
        if (isSlide && options.trimSpace === "move" && dest !== currIndex) {
          var position = getPosition();
  
          while (position === toPosition(dest, true) && between(dest, 0, Splide2.length - 1, !options.rewind)) {
            dest < currIndex ? --dest : ++dest;
          }
        }
  
        return dest;
      }
  
      function loop(index) {
        return isLoop ? (index + slideCount) % slideCount || 0 : index;
      }
  
      function getEnd() {
        return max(slideCount - (hasFocus() || isLoop && perMove ? 1 : perPage), 0);
      }
  
      function toIndex(page) {
        return clamp(hasFocus() ? page : perPage * page, 0, getEnd());
      }
  
      function toPage(index) {
        return hasFocus() ? index : floor((index >= getEnd() ? slideCount - 1 : index) / perPage);
      }
  
      function toDest(destination) {
        var closest = Move.toIndex(destination);
        return isSlide ? clamp(closest, 0, getEnd()) : closest;
      }
  
      function setIndex(index) {
        if (index !== currIndex) {
          prevIndex = currIndex;
          currIndex = index;
        }
      }
  
      function getIndex(prev) {
        return prev ? prevIndex : currIndex;
      }
  
      function hasFocus() {
        return !isUndefined(options.focus) || options.isNavigation;
      }
  
      function isBusy() {
        return Splide2.state.is([MOVING, SCROLLING]) && !!options.waitForTransition;
      }
  
      return {
        mount: mount,
        go: go,
        scroll: scroll,
        getNext: getNext,
        getPrev: getPrev,
        getAdjacent: getAdjacent,
        getEnd: getEnd,
        setIndex: setIndex,
        getIndex: getIndex,
        toIndex: toIndex,
        toPage: toPage,
        toDest: toDest,
        hasFocus: hasFocus,
        isBusy: isBusy
      };
    }
  
    var XML_NAME_SPACE = "http://www.w3.org/2000/svg";
    var PATH = "m15.5 0.932-4.3 4.38 14.5 14.6-14.5 14.5 4.3 4.4 14.6-14.6 4.4-4.3-4.4-4.4-14.6-14.6z";
    var SIZE = 40;
  
    function Arrows(Splide2, Components2, options) {
      var event = EventInterface(Splide2);
      var on = event.on,
          bind = event.bind,
          emit = event.emit;
      var classes = options.classes,
          i18n = options.i18n;
      var Elements = Components2.Elements,
          Controller = Components2.Controller;
      var userArrows = Elements.arrows,
          track = Elements.track;
      var wrapper = userArrows;
      var prev = Elements.prev;
      var next = Elements.next;
      var created;
      var wrapperClasses;
      var arrows = {};
  
      function mount() {
        init();
        on(EVENT_UPDATED, remount);
      }
  
      function remount() {
        destroy();
        mount();
      }
  
      function init() {
        var enabled = options.arrows;
  
        if (enabled && !(prev && next)) {
          createArrows();
        }
  
        if (prev && next) {
          assign(arrows, {
            prev: prev,
            next: next
          });
          display(wrapper, enabled ? "" : "none");
          addClass(wrapper, wrapperClasses = CLASS_ARROWS + "--" + options.direction);
  
          if (enabled) {
            listen();
            update();
            setAttribute([prev, next], ARIA_CONTROLS, track.id);
            emit(EVENT_ARROWS_MOUNTED, prev, next);
          }
        }
      }
  
      function destroy() {
        event.destroy();
        removeClass(wrapper, wrapperClasses);
  
        if (created) {
          remove(userArrows ? [prev, next] : wrapper);
          prev = next = null;
        } else {
          removeAttribute([prev, next], ALL_ATTRIBUTES);
        }
      }
  
      function listen() {
        on([EVENT_MOVED, EVENT_REFRESH, EVENT_SCROLLED], update);
        bind(next, "click", apply(go, ">"));
        bind(prev, "click", apply(go, "<"));
      }
  
      function go(control) {
        Controller.go(control, true);
      }
  
      function createArrows() {
        wrapper = userArrows || create("div", classes.arrows);
        prev = createArrow(true);
        next = createArrow(false);
        created = true;
        append(wrapper, [prev, next]);
        !userArrows && before(wrapper, track);
      }
  
      function createArrow(prev2) {
        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) + "\" />";
        return parseHtml(arrow);
      }
  
      function update() {
        var index = Splide2.index;
        var prevIndex = Controller.getPrev();
        var nextIndex = Controller.getNext();
        var prevLabel = prevIndex > -1 && index < prevIndex ? i18n.last : i18n.prev;
        var nextLabel = nextIndex > -1 && index > nextIndex ? i18n.first : i18n.next;
        prev.disabled = prevIndex < 0;
        next.disabled = nextIndex < 0;
        setAttribute(prev, ARIA_LABEL, prevLabel);
        setAttribute(next, ARIA_LABEL, nextLabel);
        emit(EVENT_ARROWS_UPDATED, prev, next, prevIndex, nextIndex);
      }
  
      return {
        arrows: arrows,
        mount: mount,
        destroy: destroy
      };
    }
  
    var INTERVAL_DATA_ATTRIBUTE = DATA_ATTRIBUTE + "-interval";
  
    function Autoplay(Splide2, Components2, options) {
      var _EventInterface7 = EventInterface(Splide2),
          on = _EventInterface7.on,
          bind = _EventInterface7.bind,
          emit = _EventInterface7.emit;
  
      var interval = RequestInterval(options.interval, Splide2.go.bind(Splide2, ">"), onAnimationFrame);
      var isPaused = interval.isPaused;
      var Elements = Components2.Elements,
          _Components2$Elements4 = Components2.Elements,
          root = _Components2$Elements4.root,
          toggle = _Components2$Elements4.toggle;
      var autoplay = options.autoplay;
      var hovered;
      var focused;
      var stopped = autoplay === "pause";
  
      function mount() {
        if (autoplay) {
          listen();
          toggle && setAttribute(toggle, ARIA_CONTROLS, Elements.track.id);
          stopped || play();
          update();
        }
      }
  
      function listen() {
        if (options.pauseOnHover) {
          bind(root, "mouseenter mouseleave", function (e) {
            hovered = e.type === "mouseenter";
            autoToggle();
          });
        }
  
        if (options.pauseOnFocus) {
          bind(root, "focusin focusout", function (e) {
            focused = e.type === "focusin";
            autoToggle();
          });
        }
  
        if (toggle) {
          bind(toggle, "click", function () {
            stopped ? play() : pause(true);
          });
        }
  
        on([EVENT_MOVE, EVENT_SCROLL, EVENT_REFRESH], interval.rewind);
        on(EVENT_MOVE, onMove);
      }
  
      function play() {
        if (isPaused() && Components2.Slides.isEnough()) {
          interval.start(!options.resetProgress);
          focused = hovered = stopped = false;
          update();
          emit(EVENT_AUTOPLAY_PLAY);
        }
      }
  
      function pause(stop) {
        if (stop === void 0) {
          stop = true;
        }
  
        stopped = !!stop;
        update();
  
        if (!isPaused()) {
          interval.pause();
          emit(EVENT_AUTOPLAY_PAUSE);
        }
      }
  
      function autoToggle() {
        if (!stopped) {
          hovered || focused ? pause(false) : play();
        }
      }
  
      function update() {
        if (toggle) {
          toggleClass(toggle, CLASS_ACTIVE, !stopped);
          setAttribute(toggle, ARIA_LABEL, options.i18n[stopped ? "play" : "pause"]);
        }
      }
  
      function onAnimationFrame(rate) {
        var bar = Elements.bar;
        bar && style(bar, "width", rate * 100 + "%");
        emit(EVENT_AUTOPLAY_PLAYING, rate);
      }
  
      function onMove(index) {
        var Slide = Components2.Slides.getAt(index);
        interval.set(Slide && +getAttribute(Slide.slide, INTERVAL_DATA_ATTRIBUTE) || options.interval);
      }
  
      return {
        mount: mount,
        destroy: interval.cancel,
        play: play,
        pause: pause,
        isPaused: isPaused
      };
    }
  
    function Cover(Splide2, Components2, options) {
      var _EventInterface8 = EventInterface(Splide2),
          on = _EventInterface8.on;
  
      function mount() {
        if (options.cover) {
          on(EVENT_LAZYLOAD_LOADED, apply(toggle, true));
          on([EVENT_MOUNTED, EVENT_UPDATED, EVENT_REFRESH], apply(cover, true));
        }
      }
  
      function cover(cover2) {
        Components2.Slides.forEach(function (Slide) {
          var img = child(Slide.container || Slide.slide, "img");
  
          if (img && img.src) {
            toggle(cover2, img, Slide);
          }
        });
      }
  
      function toggle(cover2, img, Slide) {
        Slide.style("background", cover2 ? "center/cover no-repeat url(\"" + img.src + "\")" : "", true);
        display(img, cover2 ? "none" : "");
      }
  
      return {
        mount: mount,
        destroy: apply(cover, false)
      };
    }
  
    var BOUNCE_DIFF_THRESHOLD = 10;
    var BOUNCE_DURATION = 600;
    var FRICTION_FACTOR = 0.6;
    var BASE_VELOCITY = 1.5;
    var MIN_DURATION = 800;
  
    function Scroll(Splide2, Components2, options) {
      var _EventInterface9 = EventInterface(Splide2),
          on = _EventInterface9.on,
          emit = _EventInterface9.emit;
  
      var set = Splide2.state.set;
      var Move = Components2.Move;
      var getPosition = Move.getPosition,
          getLimit = Move.getLimit,
          exceededLimit = Move.exceededLimit,
          translate = Move.translate;
      var interval;
      var callback;
      var friction = 1;
  
      function mount() {
        on(EVENT_MOVE, clear);
        on([EVENT_UPDATED, EVENT_REFRESH], cancel);
      }
  
      function scroll(destination, duration, snap, onScrolled, noConstrain) {
        var from = getPosition();
        clear();
  
        if (snap) {
          var size = Components2.Layout.sliderSize();
          var offset = sign(destination) * size * floor(abs(destination) / size) || 0;
          destination = Move.toPosition(Components2.Controller.toDest(destination % size)) + offset;
        }
  
        var noDistance = approximatelyEqual(from, destination, 1);
        friction = 1;
        duration = noDistance ? 0 : duration || max(abs(destination - from) / BASE_VELOCITY, MIN_DURATION);
        callback = onScrolled;
        interval = RequestInterval(duration, onEnd, apply(update, from, destination, noConstrain), 1);
        set(SCROLLING);
        emit(EVENT_SCROLL);
        interval.start();
      }
  
      function onEnd() {
        set(IDLE);
        callback && callback();
        emit(EVENT_SCROLLED);
      }
  
      function update(from, to, noConstrain, rate) {
        var position = getPosition();
        var target = from + (to - from) * easing(rate);
        var diff = (target - position) * friction;
        translate(position + diff);
  
        if (Splide2.is(SLIDE) && !noConstrain && exceededLimit()) {
          friction *= FRICTION_FACTOR;
  
          if (abs(diff) < BOUNCE_DIFF_THRESHOLD) {
            scroll(getLimit(exceededLimit(true)), BOUNCE_DURATION, false, void 0, true);
          }
        }
      }
  
      function clear() {
        if (interval) {
          interval.cancel();
        }
      }
  
      function cancel() {
        if (interval && !interval.isPaused()) {
          clear();
          onEnd();
        }
      }
  
      function easing(t) {
        var easingFunc = options.easingFunc;
        return easingFunc ? easingFunc(t) : 1 - Math.pow(1 - t, 4);
      }
  
      return {
        mount: mount,
        destroy: clear,
        scroll: scroll,
        cancel: cancel
      };
    }
  
    var SCROLL_LISTENER_OPTIONS = {
      passive: false,
      capture: true
    };
  
    function Drag(Splide2, Components2, options) {
      var _EventInterface10 = EventInterface(Splide2),
          on = _EventInterface10.on,
          emit = _EventInterface10.emit,
          bind = _EventInterface10.bind,
          unbind = _EventInterface10.unbind;
  
      var state = Splide2.state;
      var Move = Components2.Move,
          Scroll = Components2.Scroll,
          Controller = Components2.Controller,
          track = Components2.Elements.track,
          reduce = Components2.Media.reduce;
      var _Components2$Directio2 = Components2.Direction,
          resolve = _Components2$Directio2.resolve,
          orient = _Components2$Directio2.orient;
      var getPosition = Move.getPosition,
          exceededLimit = Move.exceededLimit;
      var basePosition;
      var baseEvent;
      var prevBaseEvent;
      var isFree;
      var dragging;
      var exceeded = false;
      var clickPrevented;
      var disabled;
      var target;
  
      function mount() {
        bind(track, POINTER_MOVE_EVENTS, noop, SCROLL_LISTENER_OPTIONS);
        bind(track, POINTER_UP_EVENTS, noop, SCROLL_LISTENER_OPTIONS);
        bind(track, POINTER_DOWN_EVENTS, onPointerDown, SCROLL_LISTENER_OPTIONS);
        bind(track, "click", onClick, {
          capture: true
        });
        bind(track, "dragstart", prevent);
        on([EVENT_MOUNTED, EVENT_UPDATED], init);
      }
  
      function init() {
        var drag = options.drag;
        disable(!drag);
        isFree = drag === "free";
      }
  
      function onPointerDown(e) {
        clickPrevented = false;
  
        if (!disabled) {
          var isTouch = isTouchEvent(e);
  
          if (isDraggable(e.target) && (isTouch || !e.button)) {
            if (!Controller.isBusy()) {
              target = isTouch ? track : window;
              dragging = state.is([MOVING, SCROLLING]);
              prevBaseEvent = null;
              bind(target, POINTER_MOVE_EVENTS, onPointerMove, SCROLL_LISTENER_OPTIONS);
              bind(target, POINTER_UP_EVENTS, onPointerUp, SCROLL_LISTENER_OPTIONS);
              Move.cancel();
              Scroll.cancel();
              save(e);
            } else {
              prevent(e, true);
            }
          }
        }
      }
  
      function onPointerMove(e) {
        if (!state.is(DRAGGING)) {
          state.set(DRAGGING);
          emit(EVENT_DRAG);
        }
  
        if (e.cancelable) {
          if (dragging) {
            Move.translate(basePosition + constrain(diffCoord(e)));
            var expired = diffTime(e) > LOG_INTERVAL;
            var hasExceeded = exceeded !== (exceeded = exceededLimit());
  
            if (expired || hasExceeded) {
              save(e);
            }
  
            clickPrevented = true;
            emit(EVENT_DRAGGING);
            prevent(e);
          } else if (isSliderDirection(e)) {
            dragging = shouldStart(e);
            prevent(e);
          }
        }
      }
  
      function onPointerUp(e) {
        if (state.is(DRAGGING)) {
          state.set(IDLE);
          emit(EVENT_DRAGGED);
        }
  
        if (dragging) {
          move(e);
          prevent(e);
        }
  
        unbind(target, POINTER_MOVE_EVENTS, onPointerMove);
        unbind(target, POINTER_UP_EVENTS, onPointerUp);
        dragging = false;
      }
  
      function onClick(e) {
        if (!disabled && clickPrevented) {
          prevent(e, true);
        }
      }
  
      function save(e) {
        prevBaseEvent = baseEvent;
        baseEvent = e;
        basePosition = getPosition();
      }
  
      function move(e) {
        var velocity = computeVelocity(e);
        var destination = computeDestination(velocity);
        var rewind = options.rewind && options.rewindByDrag;
        reduce(false);
  
        if (isFree) {
          Controller.scroll(destination, 0, options.snap);
        } else if (Splide2.is(FADE)) {
          Controller.go(orient(sign(velocity)) < 0 ? rewind ? "<" : "-" : rewind ? ">" : "+");
        } else if (Splide2.is(SLIDE) && exceeded && rewind) {
          Controller.go(exceededLimit(true) ? ">" : "<");
        } else {
          Controller.go(Controller.toDest(destination), true);
        }
  
        reduce(true);
      }
  
      function shouldStart(e) {
        var thresholds = options.dragMinThreshold;
        var isObj = isObject(thresholds);
        var mouse = isObj && thresholds.mouse || 0;
        var touch = (isObj ? thresholds.touch : +thresholds) || 10;
        return abs(diffCoord(e)) > (isTouchEvent(e) ? touch : mouse);
      }
  
      function isSliderDirection(e) {
        return abs(diffCoord(e)) > abs(diffCoord(e, true));
      }
  
      function computeVelocity(e) {
        if (Splide2.is(LOOP) || !exceeded) {
          var time = diffTime(e);
  
          if (time && time < LOG_INTERVAL) {
            return diffCoord(e) / time;
          }
        }
  
        return 0;
      }
  
      function computeDestination(velocity) {
        return getPosition() + sign(velocity) * min(abs(velocity) * (options.flickPower || 600), isFree ? Infinity : Components2.Layout.listSize() * (options.flickMaxPages || 1));
      }
  
      function diffCoord(e, orthogonal) {
        return coordOf(e, orthogonal) - coordOf(getBaseEvent(e), orthogonal);
      }
  
      function diffTime(e) {
        return timeOf(e) - timeOf(getBaseEvent(e));
      }
  
      function getBaseEvent(e) {
        return baseEvent === e && prevBaseEvent || baseEvent;
      }
  
      function coordOf(e, orthogonal) {
        return (isTouchEvent(e) ? e.changedTouches[0] : e)["page" + resolve(orthogonal ? "Y" : "X")];
      }
  
      function constrain(diff) {
        return diff / (exceeded && Splide2.is(SLIDE) ? FRICTION : 1);
      }
  
      function isDraggable(target2) {
        var noDrag = options.noDrag;
        return !matches(target2, "." + CLASS_PAGINATION_PAGE + ", ." + CLASS_ARROW) && (!noDrag || !matches(target2, noDrag));
      }
  
      function isTouchEvent(e) {
        return typeof TouchEvent !== "undefined" && e instanceof TouchEvent;
      }
  
      function isDragging() {
        return dragging;
      }
  
      function disable(value) {
        disabled = value;
      }
  
      return {
        mount: mount,
        disable: disable,
        isDragging: isDragging
      };
    }
  
    var NORMALIZATION_MAP = {
      Spacebar: " ",
      Right: ARROW_RIGHT,
      Left: ARROW_LEFT,
      Up: ARROW_UP,
      Down: ARROW_DOWN
    };
  
    function normalizeKey(key) {
      key = isString(key) ? key : key.key;
      return NORMALIZATION_MAP[key] || key;
    }
  
    var KEYBOARD_EVENT = "keydown";
  
    function Keyboard(Splide2, Components2, options) {
      var _EventInterface11 = EventInterface(Splide2),
          on = _EventInterface11.on,
          bind = _EventInterface11.bind,
          unbind = _EventInterface11.unbind;
  
      var root = Splide2.root;
      var resolve = Components2.Direction.resolve;
      var target;
      var disabled;
  
      function mount() {
        init();
        on(EVENT_UPDATED, destroy);
        on(EVENT_UPDATED, init);
        on(EVENT_MOVE, onMove);
      }
  
      function init() {
        var keyboard = options.keyboard;
  
        if (keyboard) {
          target = keyboard === "global" ? window : root;
          bind(target, KEYBOARD_EVENT, onKeydown);
        }
      }
  
      function destroy() {
        unbind(target, KEYBOARD_EVENT);
      }
  
      function disable(value) {
        disabled = value;
      }
  
      function onMove() {
        var _disabled = disabled;
        disabled = true;
        nextTick(function () {
          disabled = _disabled;
        });
      }
  
      function onKeydown(e) {
        if (!disabled) {
          var key = normalizeKey(e);
  
          if (key === resolve(ARROW_LEFT)) {
            Splide2.go("<");
          } else if (key === resolve(ARROW_RIGHT)) {
            Splide2.go(">");
          }
        }
      }
  
      return {
        mount: mount,
        destroy: destroy,
        disable: disable
      };
    }
  
    var SRC_DATA_ATTRIBUTE = DATA_ATTRIBUTE + "-lazy";
    var SRCSET_DATA_ATTRIBUTE = SRC_DATA_ATTRIBUTE + "-srcset";
    var IMAGE_SELECTOR = "[" + SRC_DATA_ATTRIBUTE + "], [" + SRCSET_DATA_ATTRIBUTE + "]";
  
    function LazyLoad(Splide2, Components2, options) {
      var _EventInterface12 = EventInterface(Splide2),
          on = _EventInterface12.on,
          off = _EventInterface12.off,
          bind = _EventInterface12.bind,
          emit = _EventInterface12.emit;
  
      var isSequential = options.lazyLoad === "sequential";
      var events = [EVENT_MOUNTED, EVENT_REFRESH, EVENT_MOVED, EVENT_SCROLLED];
      var entries = [];
  
      function mount() {
        if (options.lazyLoad) {
          init();
          on(EVENT_REFRESH, init);
          isSequential || on(events, observe);
        }
      }
  
      function init() {
        empty(entries);
        Components2.Slides.forEach(function (Slide) {
          queryAll(Slide.slide, IMAGE_SELECTOR).forEach(function (img) {
            var src = getAttribute(img, SRC_DATA_ATTRIBUTE);
            var srcset = getAttribute(img, SRCSET_DATA_ATTRIBUTE);
  
            if (src !== img.src || srcset !== img.srcset) {
              var className = options.classes.spinner;
              var parent = img.parentElement;
              var spinner = child(parent, "." + className) || create("span", className, parent);
              entries.push([img, Slide, spinner]);
              img.src || display(img, "none");
            }
          });
        });
        isSequential && loadNext();
      }
  
      function observe() {
        entries = entries.filter(function (data) {
          var distance = options.perPage * ((options.preloadPages || 1) + 1) - 1;
          return data[1].isWithin(Splide2.index, distance) ? load(data) : true;
        });
        entries.length || off(events);
      }
  
      function load(data) {
        var img = data[0];
        addClass(data[1].slide, CLASS_LOADING);
        bind(img, "load error", apply(onLoad, data));
        setAttribute(img, "src", getAttribute(img, SRC_DATA_ATTRIBUTE));
        setAttribute(img, "srcset", getAttribute(img, SRCSET_DATA_ATTRIBUTE));
        removeAttribute(img, SRC_DATA_ATTRIBUTE);
        removeAttribute(img, SRCSET_DATA_ATTRIBUTE);
      }
  
      function onLoad(data, e) {
        var img = data[0],
            Slide = data[1];
        removeClass(Slide.slide, CLASS_LOADING);
  
        if (e.type !== "error") {
          remove(data[2]);
          display(img, "");
          emit(EVENT_LAZYLOAD_LOADED, img, Slide);
          emit(EVENT_RESIZE);
        }
  
        isSequential && loadNext();
      }
  
      function loadNext() {
        entries.length && load(entries.shift());
      }
  
      return {
        mount: mount,
        destroy: apply(empty, entries)
      };
    }
  
    function Pagination(Splide2, Components2, options) {
      var event = EventInterface(Splide2);
      var on = event.on,
          emit = event.emit,
          bind = event.bind;
      var Slides = Components2.Slides,
          Elements = Components2.Elements,
          Controller = Components2.Controller;
      var hasFocus = Controller.hasFocus,
          getIndex = Controller.getIndex,
          go = Controller.go;
      var resolve = Components2.Direction.resolve;
      var items = [];
      var list;
      var paginationClasses;
  
      function mount() {
        destroy();
        on([EVENT_UPDATED, EVENT_REFRESH], mount);
  
        if (options.pagination && Slides.isEnough()) {
          on([EVENT_MOVE, EVENT_SCROLL, EVENT_SCROLLED], update);
          createPagination();
          update();
          emit(EVENT_PAGINATION_MOUNTED, {
            list: list,
            items: items
          }, getAt(Splide2.index));
        }
      }
  
      function destroy() {
        if (list) {
          remove(Elements.pagination ? slice(list.children) : list);
          removeClass(list, paginationClasses);
          empty(items);
          list = null;
        }
  
        event.destroy();
      }
  
      function createPagination() {
        var length = Splide2.length;
        var classes = options.classes,
            i18n = options.i18n,
            perPage = options.perPage;
        var max = hasFocus() ? length : ceil(length / perPage);
        list = Elements.pagination || create("ul", classes.pagination, Elements.track.parentElement);
        addClass(list, paginationClasses = CLASS_PAGINATION + "--" + getDirection());
        setAttribute(list, ROLE, "tablist");
        setAttribute(list, ARIA_LABEL, i18n.select);
        setAttribute(list, ARIA_ORIENTATION, getDirection() === TTB ? "vertical" : "");
  
        for (var i = 0; i < max; i++) {
          var li = create("li", null, list);
          var button = create("button", {
            class: classes.page,
            type: "button"
          }, li);
          var controls = Slides.getIn(i).map(function (Slide) {
            return Slide.slide.id;
          });
          var text = !hasFocus() && perPage > 1 ? i18n.pageX : i18n.slideX;
          bind(button, "click", apply(onClick, i));
  
          if (options.paginationKeyboard) {
            bind(button, "keydown", apply(onKeydown, i));
          }
  
          setAttribute(li, ROLE, "presentation");
          setAttribute(button, ROLE, "tab");
          setAttribute(button, ARIA_CONTROLS, controls.join(" "));
          setAttribute(button, ARIA_LABEL, format(text, i + 1));
          setAttribute(button, TAB_INDEX, -1);
          items.push({
            li: li,
            button: button,
            page: i
          });
        }
      }
  
      function onClick(page) {
        go(">" + page, true);
      }
  
      function onKeydown(page, e) {
        var length = items.length;
        var key = normalizeKey(e);
        var dir = getDirection();
        var nextPage = -1;
  
        if (key === resolve(ARROW_RIGHT, false, dir)) {
          nextPage = ++page % length;
        } else if (key === resolve(ARROW_LEFT, false, dir)) {
          nextPage = (--page + length) % length;
        } else if (key === "Home") {
          nextPage = 0;
        } else if (key === "End") {
          nextPage = length - 1;
        }
  
        var item = items[nextPage];
  
        if (item) {
          focus(item.button);
          go(">" + nextPage);
          prevent(e, true);
        }
      }
  
      function getDirection() {
        return options.paginationDirection || options.direction;
      }
  
      function getAt(index) {
        return items[Controller.toPage(index)];
      }
  
      function update() {
        var prev = getAt(getIndex(true));
        var curr = getAt(getIndex());
  
        if (prev) {
          var button = prev.button;
          removeClass(button, CLASS_ACTIVE);
          removeAttribute(button, ARIA_SELECTED);
          setAttribute(button, TAB_INDEX, -1);
        }
  
        if (curr) {
          var _button = curr.button;
          addClass(_button, CLASS_ACTIVE);
          setAttribute(_button, ARIA_SELECTED, true);
          setAttribute(_button, TAB_INDEX, "");
        }
  
        emit(EVENT_PAGINATION_UPDATED, {
          list: list,
          items: items
        }, prev, curr);
      }
  
      return {
        items: items,
        mount: mount,
        destroy: destroy,
        getAt: getAt,
        update: update
      };
    }
  
    var TRIGGER_KEYS = [" ", "Enter"];
  
    function Sync(Splide2, Components2, options) {
      var isNavigation = options.isNavigation,
          slideFocus = options.slideFocus;
      var events = [];
  
      function setup() {
        Splide2.options = {
          slideFocus: isUndefined(slideFocus) ? isNavigation : slideFocus
        };
      }
  
      function mount() {
        Splide2.splides.forEach(function (target) {
          if (!target.isParent) {
            sync(Splide2, target.splide);
            sync(target.splide, Splide2);
          }
        });
  
        if (isNavigation) {
          navigate();
        }
      }
  
      function destroy() {
        events.forEach(function (event) {
          event.destroy();
        });
        empty(events);
      }
  
      function remount() {
        destroy();
        mount();
      }
  
      function sync(splide, target) {
        var event = EventInterface(splide);
        event.on(EVENT_MOVE, function (index, prev, dest) {
          target.go(target.is(LOOP) ? dest : index);
        });
        events.push(event);
      }
  
      function navigate() {
        var event = EventInterface(Splide2);
        var on = event.on;
        on(EVENT_CLICK, onClick);
        on(EVENT_SLIDE_KEYDOWN, onKeydown);
        on([EVENT_MOUNTED, EVENT_UPDATED], update);
        events.push(event);
        event.emit(EVENT_NAVIGATION_MOUNTED, Splide2.splides);
      }
  
      function update() {
        setAttribute(Components2.Elements.list, ARIA_ORIENTATION, options.direction === TTB ? "vertical" : "");
      }
  
      function onClick(Slide) {
        Splide2.go(Slide.index);
      }
  
      function onKeydown(Slide, e) {
        if (includes(TRIGGER_KEYS, normalizeKey(e))) {
          onClick(Slide);
          prevent(e);
        }
      }
  
      return {
        setup: setup,
        mount: mount,
        destroy: destroy,
        remount: remount
      };
    }
  
    function Wheel(Splide2, Components2, options) {
      var _EventInterface13 = EventInterface(Splide2),
          bind = _EventInterface13.bind;
  
      var lastTime = 0;
  
      function mount() {
        if (options.wheel) {
          bind(Components2.Elements.track, "wheel", onWheel, SCROLL_LISTENER_OPTIONS);
        }
      }
  
      function onWheel(e) {
        if (e.cancelable) {
          var deltaY = e.deltaY;
          var backwards = deltaY < 0;
          var timeStamp = timeOf(e);
  
          var _min = options.wheelMinThreshold || 0;
  
          var sleep = options.wheelSleep || 0;
  
          if (abs(deltaY) > _min && timeStamp - lastTime > sleep) {
            Splide2.go(backwards ? "<" : ">");
            lastTime = timeStamp;
          }
  
          shouldPrevent(backwards) && prevent(e);
        }
      }
  
      function shouldPrevent(backwards) {
        return !options.releaseWheel || Splide2.state.is(MOVING) || Components2.Controller.getAdjacent(backwards) !== -1;
      }
  
      return {
        mount: mount
      };
    }
  
    function Live(Splide2, Components2, options) {
      var _EventInterface14 = EventInterface(Splide2),
          on = _EventInterface14.on;
  
      var track = Components2.Elements.track;
      var live = options.live;
      var enabled = live && !options.isNavigation;
      var sr = create("span", CLASS_SR);
  
      function mount() {
        if (enabled) {
          disable(!Components2.Autoplay.isPaused());
          setAttribute(track, ARIA_RELEVANT, "additions");
          sr.textContent = "\u2026";
          on(EVENT_AUTOPLAY_PLAY, apply(disable, true));
          on(EVENT_AUTOPLAY_PAUSE, apply(disable, false));
          on([EVENT_MOVED, EVENT_SCROLLED], apply(append, track, sr));
        }
      }
  
      function destroy() {
        removeAttribute(track, [ARIA_LIVE, ARIA_RELEVANT]);
        remove(sr);
      }
  
      function disable(disabled) {
        if (enabled) {
          setAttribute(track, ARIA_LIVE, disabled ? "off" : "polite");
        }
      }
  
      return {
        mount: mount,
        disable: disable,
        destroy: destroy
      };
    }
  
    var ComponentConstructors = /*#__PURE__*/Object.freeze({
      __proto__: null,
      Media: Media,
      Direction: Direction,
      Elements: Elements,
      Slides: Slides,
      Layout: Layout,
      Clones: Clones,
      Move: Move,
      Controller: Controller,
      Arrows: Arrows,
      Autoplay: Autoplay,
      Cover: Cover,
      Scroll: Scroll,
      Drag: Drag,
      Keyboard: Keyboard,
      LazyLoad: LazyLoad,
      Pagination: Pagination,
      Sync: Sync,
      Wheel: Wheel,
      Live: Live
    });
    var I18N = {
      prev: "Previous slide",
      next: "Next slide",
      first: "Go to first slide",
      last: "Go to last slide",
      slideX: "Go to slide %s",
      pageX: "Go to page %s",
      play: "Start autoplay",
      pause: "Pause autoplay",
      carousel: "carousel",
      slide: "slide",
      select: "Select a slide to show",
      slideLabel: "%s of %s"
    };
    var DEFAULTS = {
      type: "slide",
      role: "region",
      speed: 400,
      perPage: 1,
      cloneStatus: true,
      arrows: true,
      pagination: true,
      paginationKeyboard: true,
      interval: 5e3,
      pauseOnHover: true,
      pauseOnFocus: true,
      resetProgress: true,
      easing: "cubic-bezier(0.25, 1, 0.5, 1)",
      drag: true,
      direction: "ltr",
      trimSpace: true,
      focusableNodes: "a, button, textarea, input, select, iframe",
      live: true,
      classes: CLASSES,
      i18n: I18N,
      reducedMotion: {
        speed: 0,
        rewindSpeed: 0,
        autoplay: "pause"
      }
    };
  
    function Fade(Splide2, Components2, options) {
      var _EventInterface15 = EventInterface(Splide2),
          on = _EventInterface15.on;
  
      function mount() {
        on([EVENT_MOUNTED, EVENT_REFRESH], function () {
          nextTick(function () {
            Components2.Slides.style("transition", "opacity " + options.speed + "ms " + options.easing);
          });
        });
      }
  
      function start(index, done) {
        var track = Components2.Elements.track;
        style(track, "height", unit(rect(track).height));
        nextTick(function () {
          done();
          style(track, "height", "");
        });
      }
  
      return {
        mount: mount,
        start: start,
        cancel: noop
      };
    }
  
    function Slide(Splide2, Components2, options) {
      var _EventInterface16 = EventInterface(Splide2),
          bind = _EventInterface16.bind;
  
      var Move = Components2.Move,
          Controller = Components2.Controller,
          Scroll = Components2.Scroll;
      var list = Components2.Elements.list;
      var transition = apply(style, list, "transition");
      var endCallback;
  
      function mount() {
        bind(list, "transitionend", function (e) {
          if (e.target === list && endCallback) {
            cancel();
            endCallback();
          }
        });
      }
  
      function start(index, done) {
        var destination = Move.toPosition(index, true);
        var position = Move.getPosition();
        var speed = getSpeed(index);
  
        if (abs(destination - position) >= 1 && speed >= 1) {
          if (options.useScroll) {
            Scroll.scroll(destination, speed, false, done);
          } else {
            transition("transform " + speed + "ms " + options.easing);
            Move.translate(destination, true);
            endCallback = done;
          }
        } else {
          Move.jump(index);
          done();
        }
      }
  
      function cancel() {
        transition("");
        Scroll.cancel();
      }
  
      function getSpeed(index) {
        var rewindSpeed = options.rewindSpeed;
  
        if (Splide2.is(SLIDE) && rewindSpeed) {
          var prev = Controller.getIndex(true);
          var end = Controller.getEnd();
  
          if (prev === 0 && index >= end || prev >= end && index === 0) {
            return rewindSpeed;
          }
        }
  
        return options.speed;
      }
  
      return {
        mount: mount,
        start: start,
        cancel: cancel
      };
    }
  
    var _Splide = /*#__PURE__*/function () {
      function _Splide(target, options) {
        this.event = EventInterface();
        this.Components = {};
        this.state = State(CREATED);
        this.splides = [];
        this._o = {};
        this._E = {};
        var root = isString(target) ? query(document, target) : target;
        assert(root, root + " is invalid.");
        this.root = root;
        options = merge({
          label: getAttribute(root, ARIA_LABEL) || "",
          labelledby: getAttribute(root, ARIA_LABELLEDBY) || ""
        }, DEFAULTS, _Splide.defaults, options || {});
  
        try {
          merge(options, JSON.parse(getAttribute(root, DATA_ATTRIBUTE)));
        } catch (e) {
          assert(false, "Invalid JSON");
        }
  
        this._o = Object.create(merge({}, options));
      }
  
      var _proto = _Splide.prototype;
  
      _proto.mount = function mount(Extensions, Transition) {
        var _this = this;
  
        var state = this.state,
            Components2 = this.Components;
        assert(state.is([CREATED, DESTROYED]), "Already mounted!");
        state.set(CREATED);
        this._C = Components2;
        this._T = Transition || this._T || (this.is(FADE) ? Fade : Slide);
        this._E = Extensions || this._E;
        var Constructors = assign({}, ComponentConstructors, this._E, {
          Transition: this._T
        });
        forOwn(Constructors, function (Component, key) {
          var component = Component(_this, Components2, _this._o);
          Components2[key] = component;
          component.setup && component.setup();
        });
        forOwn(Components2, function (component) {
          component.mount && component.mount();
        });
        this.emit(EVENT_MOUNTED);
        addClass(this.root, CLASS_INITIALIZED);
        state.set(IDLE);
        this.emit(EVENT_READY);
        return this;
      };
  
      _proto.sync = function sync(splide) {
        this.splides.push({
          splide: splide
        });
        splide.splides.push({
          splide: this,
          isParent: true
        });
  
        if (this.state.is(IDLE)) {
          this._C.Sync.remount();
  
          splide.Components.Sync.remount();
        }
  
        return this;
      };
  
      _proto.go = function go(control) {
        this._C.Controller.go(control);
  
        return this;
      };
  
      _proto.on = function on(events, callback) {
        this.event.on(events, callback);
        return this;
      };
  
      _proto.off = function off(events) {
        this.event.off(events);
        return this;
      };
  
      _proto.emit = function emit(event) {
        var _this$event;
  
        (_this$event = this.event).emit.apply(_this$event, [event].concat(slice(arguments, 1)));
  
        return this;
      };
  
      _proto.add = function add(slides, index) {
        this._C.Slides.add(slides, index);
  
        return this;
      };
  
      _proto.remove = function remove(matcher) {
        this._C.Slides.remove(matcher);
  
        return this;
      };
  
      _proto.is = function is(type) {
        return this._o.type === type;
      };
  
      _proto.refresh = function refresh() {
        this.emit(EVENT_REFRESH);
        return this;
      };
  
      _proto.destroy = function destroy(completely) {
        if (completely === void 0) {
          completely = true;
        }
  
        var event = this.event,
            state = this.state;
  
        if (state.is(CREATED)) {
          EventInterface(this).on(EVENT_READY, this.destroy.bind(this, completely));
        } else {
          forOwn(this._C, function (component) {
            component.destroy && component.destroy(completely);
          }, true);
          event.emit(EVENT_DESTROY);
          event.destroy();
          completely && empty(this.splides);
          state.set(DESTROYED);
        }
  
        return this;
      };
  
      _createClass(_Splide, [{
        key: "options",
        get: function get() {
          return this._o;
        },
        set: function set(options) {
          this._C.Media.set(options, true);
        }
      }, {
        key: "length",
        get: function get() {
          return this._C.Slides.getLength(true);
        }
      }, {
        key: "index",
        get: function get() {
          return this._C.Controller.getIndex();
        }
      }]);
  
      return _Splide;
    }();
  
    var Splide = _Splide;
    Splide.defaults = {};
    Splide.STATES = STATES;
    return Splide;
  });
  