@sledge-app/react-instant-search 1.0.19 → 1.0.21

package/dist/{vendor-efe38901.js → vendor-eadacf73.js}

@@ -8814,11 +8814,11 @@ const sanitize = (v2) => Math.round(v2 * 1e5) / 1e5;
 const floatRegex = /(-)?([\d]*\.?[\d])+/g;
 const colorRegex = /(#[0-9a-f]{3,8}|(rgb|hsl)a?\((-?[\d\.]+%?[,\s]+){2}(-?[\d\.]+%?)\s*[\,\/]?\s*[\d\.]*%?\))/gi;
 const singleColorRegex = /^(#[0-9a-f]{3,8}|(rgb|hsl)a?\((-?[\d\.]+%?[,\s]+){2}(-?[\d\.]+%?)\s*[\,\/]?\s*[\d\.]*%?\))$/i;
-function isString(v2) {
+function isString$1(v2) {
   return typeof v2 === "string";
 }
 const createUnitType = (unit) => ({
-  test: (v2) => isString(v2) && v2.endsWith(unit) && v2.split(" ").length === 1,
+  test: (v2) => isString$1(v2) && v2.endsWith(unit) && v2.split(" ").length === 1,
   parse: parseFloat,
   transform: (v2) => `${v2}${unit}`
 });
@@ -9947,10 +9947,10 @@ const easingDefinitionToFunction = (definition) => {
   return definition;
 };
 const isColorString = (type, testProp) => (v2) => {
-  return Boolean(isString(v2) && singleColorRegex.test(v2) && v2.startsWith(type) || testProp && Object.prototype.hasOwnProperty.call(v2, testProp));
+  return Boolean(isString$1(v2) && singleColorRegex.test(v2) && v2.startsWith(type) || testProp && Object.prototype.hasOwnProperty.call(v2, testProp));
 };
 const splitColor = (aName, bName, cName) => (v2) => {
-  if (!isString(v2))
+  if (!isString$1(v2))
     return v2;
   const [a2, b2, c2, alpha2] = v2.match(floatRegex);
   return {
@@ -10021,7 +10021,7 @@ const color = {
     }
   },
   transform: (v2) => {
-    return isString(v2) ? v2 : v2.hasOwnProperty("red") ? rgba.transform(v2) : hsla.transform(v2);
+    return isString$1(v2) ? v2 : v2.hasOwnProperty("red") ? rgba.transform(v2) : hsla.transform(v2);
   }
 };
 const mix = (from, to, progress2) => -progress2 * from + progress2 * to + from;
@@ -10092,7 +10092,7 @@ const colorToken = "${c}";
 const numberToken = "${n}";
 function test(v2) {
   var _a, _b;
-  return isNaN(v2) && isString(v2) && (((_a = v2.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) || 0) + (((_b = v2.match(colorRegex)) === null || _b === void 0 ? void 0 : _b.length) || 0) > 0;
+  return isNaN(v2) && isString$1(v2) && (((_a = v2.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) || 0) + (((_b = v2.match(colorRegex)) === null || _b === void 0 ? void 0 : _b.length) || 0) > 0;
 }
 function analyseComplexValue(v2) {
   if (typeof v2 === "number")
@@ -17063,6 +17063,1713 @@ const $57acba87d6e25586$export$be92b6f5f03c0fe9 = $57acba87d6e25586$export$ccf8d
 const $57acba87d6e25586$export$d5c6c08dc2d3ca7 = $57acba87d6e25586$export$a21cbf9f11fca853;
 const $57acba87d6e25586$export$9a4e88b92edfce6b = $57acba87d6e25586$export$2fabd85d0eba3c57;
 const $57acba87d6e25586$export$6521433ed15a34db = $57acba87d6e25586$export$9fba1154677d7cd2;
+function isObject$1(subject) {
+  return Object.prototype.toString.call(subject) === "[object Object]";
+}
+function isRecord(subject) {
+  return isObject$1(subject) || Array.isArray(subject);
+}
+function canUseDOM() {
+  return !!(typeof window !== "undefined" && window.document && window.document.createElement);
+}
+function areOptionsEqual(optionsA, optionsB) {
+  const optionsAKeys = Object.keys(optionsA);
+  const optionsBKeys = Object.keys(optionsB);
+  if (optionsAKeys.length !== optionsBKeys.length)
+    return false;
+  const breakpointsA = JSON.stringify(Object.keys(optionsA.breakpoints || {}));
+  const breakpointsB = JSON.stringify(Object.keys(optionsB.breakpoints || {}));
+  if (breakpointsA !== breakpointsB)
+    return false;
+  return optionsAKeys.every((key) => {
+    const valueA = optionsA[key];
+    const valueB = optionsB[key];
+    if (typeof valueA === "function")
+      return `${valueA}` === `${valueB}`;
+    if (!isRecord(valueA) || !isRecord(valueB))
+      return valueA === valueB;
+    return areOptionsEqual(valueA, valueB);
+  });
+}
+function sortAndMapPluginToOptions(plugins) {
+  return plugins.concat().sort((a2, b2) => a2.name > b2.name ? 1 : -1).map((plugin) => plugin.options);
+}
+function arePluginsEqual(pluginsA, pluginsB) {
+  if (pluginsA.length !== pluginsB.length)
+    return false;
+  const optionsA = sortAndMapPluginToOptions(pluginsA);
+  const optionsB = sortAndMapPluginToOptions(pluginsB);
+  return optionsA.every((optionA, index2) => {
+    const optionB = optionsB[index2];
+    return areOptionsEqual(optionA, optionB);
+  });
+}
+function isNumber(subject) {
+  return typeof subject === "number";
+}
+function isString(subject) {
+  return typeof subject === "string";
+}
+function isBoolean(subject) {
+  return typeof subject === "boolean";
+}
+function isObject(subject) {
+  return Object.prototype.toString.call(subject) === "[object Object]";
+}
+function mathAbs(n2) {
+  return Math.abs(n2);
+}
+function mathSign(n2) {
+  return Math.sign(n2);
+}
+function deltaAbs(valueB, valueA) {
+  return mathAbs(valueB - valueA);
+}
+function factorAbs(valueB, valueA) {
+  if (valueB === 0 || valueA === 0)
+    return 0;
+  if (mathAbs(valueB) <= mathAbs(valueA))
+    return 0;
+  const diff = deltaAbs(mathAbs(valueB), mathAbs(valueA));
+  return mathAbs(diff / valueB);
+}
+function arrayKeys(array) {
+  return objectKeys(array).map(Number);
+}
+function arrayLast(array) {
+  return array[arrayLastIndex(array)];
+}
+function arrayLastIndex(array) {
+  return Math.max(0, array.length - 1);
+}
+function arrayFromNumber(n2, startAt = 0) {
+  return Array.from(Array(n2), (_, i2) => startAt + i2);
+}
+function objectKeys(object) {
+  return Object.keys(object);
+}
+function objectsMergeDeep(objectA, objectB) {
+  return [objectA, objectB].reduce((mergedObjects, currentObject) => {
+    objectKeys(currentObject).forEach((key) => {
+      const valueA = mergedObjects[key];
+      const valueB = currentObject[key];
+      const areObjects = isObject(valueA) && isObject(valueB);
+      mergedObjects[key] = areObjects ? objectsMergeDeep(valueA, valueB) : valueB;
+    });
+    return mergedObjects;
+  }, {});
+}
+function isMouseEvent(evt, ownerWindow) {
+  return typeof ownerWindow.MouseEvent !== "undefined" && evt instanceof ownerWindow.MouseEvent;
+}
+function Alignment(align, viewSize) {
+  const predefined = {
+    start,
+    center,
+    end
+  };
+  function start() {
+    return 0;
+  }
+  function center(n2) {
+    return end(n2) / 2;
+  }
+  function end(n2) {
+    return viewSize - n2;
+  }
+  function percent2() {
+    return viewSize * Number(align);
+  }
+  function measure(n2) {
+    if (isNumber(align))
+      return percent2();
+    return predefined[align](n2);
+  }
+  const self = {
+    measure
+  };
+  return self;
+}
+function Axis(axis, direction) {
+  const scroll = axis === "y" ? "y" : "x";
+  const cross = axis === "y" ? "x" : "y";
+  const startEdge = getStartEdge();
+  const endEdge = getEndEdge();
+  function measureSize(rect) {
+    const {
+      width,
+      height
+    } = rect;
+    return scroll === "x" ? width : height;
+  }
+  function getStartEdge() {
+    if (scroll === "y")
+      return "top";
+    return direction === "rtl" ? "right" : "left";
+  }
+  function getEndEdge() {
+    if (scroll === "y")
+      return "bottom";
+    return direction === "rtl" ? "left" : "right";
+  }
+  const self = {
+    scroll,
+    cross,
+    startEdge,
+    endEdge,
+    measureSize
+  };
+  return self;
+}
+function Limit(min, max) {
+  const length = mathAbs(min - max);
+  function reachedMin(n2) {
+    return n2 < min;
+  }
+  function reachedMax(n2) {
+    return n2 > max;
+  }
+  function reachedAny(n2) {
+    return reachedMin(n2) || reachedMax(n2);
+  }
+  function constrain(n2) {
+    if (!reachedAny(n2))
+      return n2;
+    return reachedMin(n2) ? min : max;
+  }
+  function removeOffset(n2) {
+    if (!length)
+      return n2;
+    return n2 - length * Math.ceil((n2 - max) / length);
+  }
+  const self = {
+    length,
+    max,
+    min,
+    constrain,
+    reachedAny,
+    reachedMax,
+    reachedMin,
+    removeOffset
+  };
+  return self;
+}
+function Counter(max, start, loop) {
+  const {
+    constrain
+  } = Limit(0, max);
+  const loopEnd = max + 1;
+  let counter = withinLimit(start);
+  function withinLimit(n2) {
+    return !loop ? constrain(n2) : mathAbs((loopEnd + n2) % loopEnd);
+  }
+  function get() {
+    return counter;
+  }
+  function set(n2) {
+    counter = withinLimit(n2);
+    return self;
+  }
+  function add(n2) {
+    return clone().set(get() + n2);
+  }
+  function clone() {
+    return Counter(max, get(), loop);
+  }
+  const self = {
+    get,
+    set,
+    add,
+    clone
+  };
+  return self;
+}
+function Direction(direction) {
+  const sign = direction === "rtl" ? -1 : 1;
+  function apply(n2) {
+    return n2 * sign;
+  }
+  const self = {
+    apply
+  };
+  return self;
+}
+function EventStore() {
+  let listeners = [];
+  function add(node, type, handler, options = {
+    passive: true
+  }) {
+    let removeListener;
+    if ("addEventListener" in node) {
+      node.addEventListener(type, handler, options);
+      removeListener = () => node.removeEventListener(type, handler, options);
+    } else {
+      const legacyMediaQueryList = node;
+      legacyMediaQueryList.addListener(handler);
+      removeListener = () => legacyMediaQueryList.removeListener(handler);
+    }
+    listeners.push(removeListener);
+    return self;
+  }
+  function clear() {
+    listeners = listeners.filter((remove) => remove());
+  }
+  const self = {
+    add,
+    clear
+  };
+  return self;
+}
+function DragHandler(axis, direction, rootNode, ownerDocument, ownerWindow, target, dragTracker, location, animation, scrollTo, scrollBody, scrollTarget, index2, eventHandler, percentOfView, dragFree, dragThreshold, skipSnaps, baseFriction, watchDrag) {
+  const {
+    cross: crossAxis
+  } = axis;
+  const focusNodes = ["INPUT", "SELECT", "TEXTAREA"];
+  const nonPassiveEvent = {
+    passive: false
+  };
+  const initEvents = EventStore();
+  const dragEvents = EventStore();
+  const goToNextThreshold = Limit(50, 225).constrain(percentOfView.measure(20));
+  const snapForceBoost = {
+    mouse: 300,
+    touch: 400
+  };
+  const freeForceBoost = {
+    mouse: 500,
+    touch: 600
+  };
+  const baseSpeed = dragFree ? 43 : 25;
+  let isMoving = false;
+  let startScroll = 0;
+  let startCross = 0;
+  let pointerIsDown = false;
+  let preventScroll = false;
+  let preventClick = false;
+  let isMouse = false;
+  function init(emblaApi) {
+    if (!watchDrag)
+      return;
+    function downIfAllowed(evt) {
+      if (isBoolean(watchDrag) || watchDrag(emblaApi, evt))
+        down(evt);
+    }
+    const node = rootNode;
+    initEvents.add(node, "dragstart", (evt) => evt.preventDefault(), nonPassiveEvent).add(node, "touchmove", () => void 0, nonPassiveEvent).add(node, "touchend", () => void 0).add(node, "touchstart", downIfAllowed).add(node, "mousedown", downIfAllowed).add(node, "touchcancel", up).add(node, "contextmenu", up).add(node, "click", click, true);
+  }
+  function destroy() {
+    initEvents.clear();
+    dragEvents.clear();
+  }
+  function addDragEvents() {
+    const node = isMouse ? ownerDocument : rootNode;
+    dragEvents.add(node, "touchmove", move, nonPassiveEvent).add(node, "touchend", up).add(node, "mousemove", move, nonPassiveEvent).add(node, "mouseup", up);
+  }
+  function isFocusNode(node) {
+    const nodeName = node.nodeName || "";
+    return focusNodes.includes(nodeName);
+  }
+  function forceBoost() {
+    const boost = dragFree ? freeForceBoost : snapForceBoost;
+    const type = isMouse ? "mouse" : "touch";
+    return boost[type];
+  }
+  function allowedForce(force, targetChanged) {
+    const next = index2.add(mathSign(force) * -1);
+    const baseForce = scrollTarget.byDistance(force, !dragFree).distance;
+    if (dragFree || mathAbs(force) < goToNextThreshold)
+      return baseForce;
+    if (skipSnaps && targetChanged)
+      return baseForce * 0.5;
+    return scrollTarget.byIndex(next.get(), 0).distance;
+  }
+  function down(evt) {
+    const isMouseEvt = isMouseEvent(evt, ownerWindow);
+    isMouse = isMouseEvt;
+    if (isMouseEvt && evt.button !== 0)
+      return;
+    if (isFocusNode(evt.target))
+      return;
+    preventClick = dragFree && isMouseEvt && !evt.buttons && isMoving;
+    isMoving = deltaAbs(target.get(), location.get()) >= 2;
+    pointerIsDown = true;
+    dragTracker.pointerDown(evt);
+    scrollBody.useFriction(0).useDuration(0);
+    target.set(location);
+    addDragEvents();
+    startScroll = dragTracker.readPoint(evt);
+    startCross = dragTracker.readPoint(evt, crossAxis);
+    eventHandler.emit("pointerDown");
+  }
+  function move(evt) {
+    const lastScroll = dragTracker.readPoint(evt);
+    const lastCross = dragTracker.readPoint(evt, crossAxis);
+    const diffScroll = deltaAbs(lastScroll, startScroll);
+    const diffCross = deltaAbs(lastCross, startCross);
+    if (!preventScroll && !isMouse) {
+      if (!evt.cancelable)
+        return up(evt);
+      preventScroll = diffScroll > diffCross;
+      if (!preventScroll)
+        return up(evt);
+    }
+    const diff = dragTracker.pointerMove(evt);
+    if (diffScroll > dragThreshold)
+      preventClick = true;
+    scrollBody.useFriction(0.3).useDuration(1);
+    animation.start();
+    target.add(direction.apply(diff));
+    evt.preventDefault();
+  }
+  function up(evt) {
+    const currentLocation = scrollTarget.byDistance(0, false);
+    const targetChanged = currentLocation.index !== index2.get();
+    const rawForce = dragTracker.pointerUp(evt) * forceBoost();
+    const force = allowedForce(direction.apply(rawForce), targetChanged);
+    const forceFactor = factorAbs(rawForce, force);
+    const speed = baseSpeed - 10 * forceFactor;
+    const friction = baseFriction + forceFactor / 50;
+    preventScroll = false;
+    pointerIsDown = false;
+    dragEvents.clear();
+    scrollBody.useDuration(speed).useFriction(friction);
+    scrollTo.distance(force, !dragFree);
+    isMouse = false;
+    eventHandler.emit("pointerUp");
+  }
+  function click(evt) {
+    if (preventClick) {
+      evt.stopPropagation();
+      evt.preventDefault();
+    }
+  }
+  function pointerDown() {
+    return pointerIsDown;
+  }
+  const self = {
+    init,
+    pointerDown,
+    destroy
+  };
+  return self;
+}
+function DragTracker(axis, ownerWindow) {
+  const logInterval = 170;
+  let startEvent;
+  let lastEvent;
+  function readTime(evt) {
+    return evt.timeStamp;
+  }
+  function readPoint(evt, evtAxis) {
+    const property = evtAxis || axis.scroll;
+    const coord = `client${property === "x" ? "X" : "Y"}`;
+    return (isMouseEvent(evt, ownerWindow) ? evt : evt.touches[0])[coord];
+  }
+  function pointerDown(evt) {
+    startEvent = evt;
+    lastEvent = evt;
+    return readPoint(evt);
+  }
+  function pointerMove(evt) {
+    const diff = readPoint(evt) - readPoint(lastEvent);
+    const expired = readTime(evt) - readTime(startEvent) > logInterval;
+    lastEvent = evt;
+    if (expired)
+      startEvent = evt;
+    return diff;
+  }
+  function pointerUp(evt) {
+    if (!startEvent || !lastEvent)
+      return 0;
+    const diffDrag = readPoint(lastEvent) - readPoint(startEvent);
+    const diffTime = readTime(evt) - readTime(startEvent);
+    const expired = readTime(evt) - readTime(lastEvent) > logInterval;
+    const force = diffDrag / diffTime;
+    const isFlick = diffTime && !expired && mathAbs(force) > 0.1;
+    return isFlick ? force : 0;
+  }
+  const self = {
+    pointerDown,
+    pointerMove,
+    pointerUp,
+    readPoint
+  };
+  return self;
+}
+function PercentOfView(viewSize) {
+  function measure(n2) {
+    return viewSize * (n2 / 100);
+  }
+  const self = {
+    measure
+  };
+  return self;
+}
+function ResizeHandler(container, eventHandler, ownerWindow, slides, axis, watchResize) {
+  let resizeObserver;
+  let containerSize;
+  let slideSizes = [];
+  let destroyed = false;
+  function readSize(node) {
+    return axis.measureSize(node.getBoundingClientRect());
+  }
+  function init(emblaApi) {
+    if (!watchResize)
+      return;
+    containerSize = readSize(container);
+    slideSizes = slides.map(readSize);
+    function defaultCallback(entries) {
+      for (const entry of entries) {
+        const isContainer = entry.target === container;
+        const slideIndex = slides.indexOf(entry.target);
+        const lastSize = isContainer ? containerSize : slideSizes[slideIndex];
+        const newSize = readSize(isContainer ? container : slides[slideIndex]);
+        const diffSize = mathAbs(newSize - lastSize);
+        if (diffSize >= 0.2) {
+          ownerWindow.requestAnimationFrame(() => {
+            emblaApi.reInit();
+            eventHandler.emit("resize");
+          });
+          break;
+        }
+      }
+    }
+    resizeObserver = new ResizeObserver((entries) => {
+      if (destroyed)
+        return;
+      if (isBoolean(watchResize) || watchResize(emblaApi, entries)) {
+        defaultCallback(entries);
+      }
+    });
+    const observeNodes = [container].concat(slides);
+    observeNodes.forEach((node) => resizeObserver.observe(node));
+  }
+  function destroy() {
+    if (resizeObserver)
+      resizeObserver.disconnect();
+    destroyed = true;
+  }
+  const self = {
+    init,
+    destroy
+  };
+  return self;
+}
+function ScrollBody(location, target, baseDuration, baseFriction) {
+  let hasSettled = true;
+  let bodyVelocity = 0;
+  let scrollDirection = 0;
+  let scrollDuration = baseDuration;
+  let scrollFriction = baseFriction;
+  let rawLocation = location.get();
+  let rawLocationPrevious = 0;
+  function seek() {
+    const diff = target.get() - location.get();
+    const isInstant = !scrollDuration;
+    let directionDiff = 0;
+    if (isInstant) {
+      bodyVelocity = 0;
+      location.set(target);
+      directionDiff = diff;
+    } else {
+      bodyVelocity += diff / scrollDuration;
+      bodyVelocity *= scrollFriction;
+      rawLocation += bodyVelocity;
+      location.add(bodyVelocity);
+      directionDiff = rawLocation - rawLocationPrevious;
+    }
+    scrollDirection = mathSign(directionDiff);
+    rawLocationPrevious = rawLocation;
+    hasSettled = mathAbs(diff) < 1e-3;
+    return self;
+  }
+  function settled() {
+    return hasSettled;
+  }
+  function duration() {
+    return scrollDuration;
+  }
+  function direction() {
+    return scrollDirection;
+  }
+  function velocity() {
+    return bodyVelocity;
+  }
+  function useBaseDuration() {
+    return useDuration(baseDuration);
+  }
+  function useBaseFriction() {
+    return useFriction(baseFriction);
+  }
+  function useDuration(n2) {
+    scrollDuration = n2;
+    return self;
+  }
+  function useFriction(n2) {
+    scrollFriction = n2;
+    return self;
+  }
+  const self = {
+    direction,
+    duration,
+    velocity,
+    seek,
+    settled,
+    useBaseFriction,
+    useBaseDuration,
+    useFriction,
+    useDuration
+  };
+  return self;
+}
+function ScrollBounds(limit, location, target, scrollBody, percentOfView) {
+  const pullBackThreshold = percentOfView.measure(10);
+  const edgeOffsetTolerance = percentOfView.measure(50);
+  const frictionLimit = Limit(0.1, 0.99);
+  let disabled = false;
+  function shouldConstrain() {
+    if (disabled)
+      return false;
+    if (!limit.reachedAny(target.get()))
+      return false;
+    if (!limit.reachedAny(location.get()))
+      return false;
+    return true;
+  }
+  function constrain(pointerDown) {
+    if (!shouldConstrain())
+      return;
+    const edge = limit.reachedMin(location.get()) ? "min" : "max";
+    const diffToEdge = mathAbs(limit[edge] - location.get());
+    const diffToTarget = target.get() - location.get();
+    const friction = frictionLimit.constrain(diffToEdge / edgeOffsetTolerance);
+    target.subtract(diffToTarget * friction);
+    if (!pointerDown && mathAbs(diffToTarget) < pullBackThreshold) {
+      target.set(limit.constrain(target.get()));
+      scrollBody.useDuration(25).useBaseFriction();
+    }
+  }
+  function toggleActive(active) {
+    disabled = !active;
+  }
+  const self = {
+    constrain,
+    toggleActive
+  };
+  return self;
+}
+function ScrollContain(viewSize, contentSize, snapsAligned, containScroll) {
+  const scrollBounds = Limit(-contentSize + viewSize, 0);
+  const snapsBounded = measureBounded();
+  const scrollContainLimit = findScrollContainLimit();
+  const snapsContained = measureContained();
+  function findScrollContainLimit() {
+    const startSnap = snapsBounded[0];
+    const endSnap = arrayLast(snapsBounded);
+    const min = snapsBounded.lastIndexOf(startSnap);
+    const max = snapsBounded.indexOf(endSnap) + 1;
+    return Limit(min, max);
+  }
+  function measureBounded() {
+    return snapsAligned.map(scrollBounds.constrain).map((scrollBound) => parseFloat(scrollBound.toFixed(3)));
+  }
+  function measureContained() {
+    if (contentSize <= viewSize)
+      return [scrollBounds.max];
+    if (containScroll === "keepSnaps")
+      return snapsBounded;
+    const {
+      min,
+      max
+    } = scrollContainLimit;
+    return snapsBounded.slice(min, max);
+  }
+  const self = {
+    snapsContained,
+    scrollContainLimit
+  };
+  return self;
+}
+function ScrollLimit(contentSize, scrollSnaps, loop) {
+  const max = scrollSnaps[0];
+  const min = loop ? max - contentSize : arrayLast(scrollSnaps);
+  const limit = Limit(min, max);
+  const self = {
+    limit
+  };
+  return self;
+}
+function ScrollLooper(contentSize, limit, offsetLocation, vectors) {
+  const jointSafety = 0.1;
+  const min = limit.min + jointSafety;
+  const max = limit.max + jointSafety;
+  const {
+    reachedMin,
+    reachedMax
+  } = Limit(min, max);
+  function shouldLoop(direction) {
+    if (direction === 1)
+      return reachedMax(offsetLocation.get());
+    if (direction === -1)
+      return reachedMin(offsetLocation.get());
+    return false;
+  }
+  function loop(direction) {
+    if (!shouldLoop(direction))
+      return;
+    const loopDistance = contentSize * (direction * -1);
+    vectors.forEach((v2) => v2.add(loopDistance));
+  }
+  const self = {
+    loop
+  };
+  return self;
+}
+function ScrollProgress(limit) {
+  const {
+    max,
+    length
+  } = limit;
+  function get(n2) {
+    const currentLocation = n2 - max;
+    return length ? currentLocation / -length : 0;
+  }
+  const self = {
+    get
+  };
+  return self;
+}
+function ScrollSnaps(axis, alignment, containerRect, slideRects, slidesToScroll) {
+  const {
+    startEdge,
+    endEdge
+  } = axis;
+  const {
+    groupSlides
+  } = slidesToScroll;
+  const alignments = measureSizes().map(alignment.measure);
+  const snaps = measureUnaligned();
+  const snapsAligned = measureAligned();
+  function measureSizes() {
+    return groupSlides(slideRects).map((rects) => arrayLast(rects)[endEdge] - rects[0][startEdge]).map(mathAbs);
+  }
+  function measureUnaligned() {
+    return slideRects.map((rect) => containerRect[startEdge] - rect[startEdge]).map((snap) => -mathAbs(snap));
+  }
+  function measureAligned() {
+    return groupSlides(snaps).map((g2) => g2[0]).map((snap, index2) => snap + alignments[index2]);
+  }
+  const self = {
+    snaps,
+    snapsAligned
+  };
+  return self;
+}
+function SlideRegistry(viewSize, contentSize, containSnaps, scrollContainLimit, slidesToScroll, slideIndexes) {
+  const {
+    groupSlides
+  } = slidesToScroll;
+  const {
+    min,
+    max
+  } = scrollContainLimit;
+  const slideRegistry = createSlideRegistry();
+  function createSlideRegistry() {
+    const groupedSlideIndexes = groupSlides(slideIndexes);
+    if (!containSnaps || contentSize <= viewSize)
+      return groupedSlideIndexes;
+    return groupedSlideIndexes.slice(min, max).map((group, index2, groups) => {
+      const indexIsFirst = !index2;
+      const indexIsLast = !indexIsFirst && index2 === arrayLastIndex(groups);
+      if (indexIsFirst) {
+        const range = arrayLast(groups[0]) + 1;
+        return arrayFromNumber(range);
+      }
+      if (indexIsLast) {
+        const range = arrayLastIndex(slideIndexes) - arrayLast(groups)[0] + 1;
+        return arrayFromNumber(range, arrayLast(groups)[0]);
+      }
+      return group;
+    });
+  }
+  const self = {
+    slideRegistry
+  };
+  return self;
+}
+function ScrollTarget(loop, scrollSnaps, contentSize, limit, targetVector) {
+  const {
+    reachedAny,
+    removeOffset,
+    constrain
+  } = limit;
+  function minDistance(distances) {
+    return distances.concat().sort((a2, b2) => mathAbs(a2) - mathAbs(b2))[0];
+  }
+  function findTargetSnap(target) {
+    const distance2 = loop ? removeOffset(target) : constrain(target);
+    const ascDiffsToSnaps = scrollSnaps.map((scrollSnap) => scrollSnap - distance2).map((diffToSnap) => shortcut(diffToSnap, 0)).map((diff, i2) => ({
+      diff,
+      index: i2
+    })).sort((d1, d2) => mathAbs(d1.diff) - mathAbs(d2.diff));
+    const {
+      index: index2
+    } = ascDiffsToSnaps[0];
+    return {
+      index: index2,
+      distance: distance2
+    };
+  }
+  function shortcut(target, direction) {
+    const targets = [target, target + contentSize, target - contentSize];
+    if (!loop)
+      return targets[0];
+    if (!direction)
+      return minDistance(targets);
+    const matchingTargets = targets.filter((t2) => mathSign(t2) === direction);
+    if (matchingTargets.length)
+      return minDistance(matchingTargets);
+    return arrayLast(targets) - contentSize;
+  }
+  function byIndex(index2, direction) {
+    const diffToSnap = scrollSnaps[index2] - targetVector.get();
+    const distance2 = shortcut(diffToSnap, direction);
+    return {
+      index: index2,
+      distance: distance2
+    };
+  }
+  function byDistance(distance2, snap) {
+    const target = targetVector.get() + distance2;
+    const {
+      index: index2,
+      distance: targetSnapDistance
+    } = findTargetSnap(target);
+    const reachedBound = !loop && reachedAny(target);
+    if (!snap || reachedBound)
+      return {
+        index: index2,
+        distance: distance2
+      };
+    const diffToSnap = scrollSnaps[index2] - targetSnapDistance;
+    const snapDistance = distance2 + shortcut(diffToSnap, 0);
+    return {
+      index: index2,
+      distance: snapDistance
+    };
+  }
+  const self = {
+    byDistance,
+    byIndex,
+    shortcut
+  };
+  return self;
+}
+function ScrollTo(animation, indexCurrent, indexPrevious, scrollTarget, scrollBody, targetVector, eventHandler) {
+  function scrollTo(target) {
+    const distanceDiff = target.distance;
+    const indexDiff = target.index !== indexCurrent.get();
+    targetVector.add(distanceDiff);
+    if (distanceDiff) {
+      if (scrollBody.duration()) {
+        animation.start();
+      } else {
+        animation.update();
+        animation.render(1);
+        animation.update();
+      }
+    }
+    if (indexDiff) {
+      indexPrevious.set(indexCurrent.get());
+      indexCurrent.set(target.index);
+      eventHandler.emit("select");
+    }
+  }
+  function distance2(n2, snap) {
+    const target = scrollTarget.byDistance(n2, snap);
+    scrollTo(target);
+  }
+  function index2(n2, direction) {
+    const targetIndex = indexCurrent.clone().set(n2);
+    const target = scrollTarget.byIndex(targetIndex.get(), direction);
+    scrollTo(target);
+  }
+  const self = {
+    distance: distance2,
+    index: index2
+  };
+  return self;
+}
+function SlideFocus(root, slides, slideRegistry, scrollTo, scrollBody, eventStore) {
+  let lastTabPressTime = 0;
+  function init() {
+    eventStore.add(document, "keydown", registerTabPress, false);
+    slides.forEach(addSlideFocusEvent);
+  }
+  function registerTabPress(event) {
+    if (event.code === "Tab")
+      lastTabPressTime = (/* @__PURE__ */ new Date()).getTime();
+  }
+  function addSlideFocusEvent(slide) {
+    const focus = () => {
+      const nowTime = (/* @__PURE__ */ new Date()).getTime();
+      const diffTime = nowTime - lastTabPressTime;
+      if (diffTime > 10)
+        return;
+      root.scrollLeft = 0;
+      const index2 = slides.indexOf(slide);
+      const group = slideRegistry.findIndex((group2) => group2.includes(index2));
+      if (!isNumber(group))
+        return;
+      scrollBody.useDuration(0);
+      scrollTo.index(group, 0);
+    };
+    eventStore.add(slide, "focus", focus, {
+      passive: true,
+      capture: true
+    });
+  }
+  const self = {
+    init
+  };
+  return self;
+}
+function Vector1D(initialValue) {
+  let value = initialValue;
+  function get() {
+    return value;
+  }
+  function set(n2) {
+    value = normalizeInput(n2);
+  }
+  function add(n2) {
+    value += normalizeInput(n2);
+  }
+  function subtract(n2) {
+    value -= normalizeInput(n2);
+  }
+  function normalizeInput(n2) {
+    return isNumber(n2) ? n2 : n2.get();
+  }
+  const self = {
+    get,
+    set,
+    add,
+    subtract
+  };
+  return self;
+}
+function Translate(axis, direction, container) {
+  const translate = axis.scroll === "x" ? x2 : y2;
+  const containerStyle = container.style;
+  let disabled = false;
+  function x2(n2) {
+    return `translate3d(${n2}px,0px,0px)`;
+  }
+  function y2(n2) {
+    return `translate3d(0px,${n2}px,0px)`;
+  }
+  function to(target) {
+    if (disabled)
+      return;
+    containerStyle.transform = translate(direction.apply(target));
+  }
+  function toggleActive(active) {
+    disabled = !active;
+  }
+  function clear() {
+    if (disabled)
+      return;
+    containerStyle.transform = "";
+    if (!container.getAttribute("style"))
+      container.removeAttribute("style");
+  }
+  const self = {
+    clear,
+    to,
+    toggleActive
+  };
+  return self;
+}
+function SlideLooper(axis, direction, viewSize, contentSize, slideSizes, slideSizesWithGaps, snaps, scrollSnaps, offsetLocation, slides) {
+  const roundingSafety = 0.5;
+  const ascItems = arrayKeys(slideSizesWithGaps);
+  const descItems = arrayKeys(slideSizesWithGaps).reverse();
+  const loopPoints = startPoints().concat(endPoints());
+  function removeSlideSizes(indexes, from) {
+    return indexes.reduce((a2, i2) => {
+      return a2 - slideSizesWithGaps[i2];
+    }, from);
+  }
+  function slidesInGap(indexes, gap) {
+    return indexes.reduce((a2, i2) => {
+      const remainingGap = removeSlideSizes(a2, gap);
+      return remainingGap > 0 ? a2.concat([i2]) : a2;
+    }, []);
+  }
+  function findSlideBounds(offset) {
+    return snaps.map((snap, index2) => ({
+      start: snap - slideSizes[index2] + roundingSafety + offset,
+      end: snap + viewSize - roundingSafety + offset
+    }));
+  }
+  function findLoopPoints(indexes, offset, isEndEdge) {
+    const slideBounds = findSlideBounds(offset);
+    return indexes.map((index2) => {
+      const initial = isEndEdge ? 0 : -contentSize;
+      const altered = isEndEdge ? contentSize : 0;
+      const boundEdge = isEndEdge ? "end" : "start";
+      const loopPoint = slideBounds[index2][boundEdge];
+      return {
+        index: index2,
+        slideLocation: Vector1D(-1),
+        translate: Translate(axis, direction, slides[index2]),
+        target: () => offsetLocation.get() > loopPoint ? initial : altered
+      };
+    });
+  }
+  function startPoints() {
+    const gap = scrollSnaps[0] - 1;
+    const indexes = slidesInGap(descItems, gap);
+    return findLoopPoints(indexes, contentSize, false);
+  }
+  function endPoints() {
+    const gap = viewSize - scrollSnaps[0] - 1;
+    const indexes = slidesInGap(ascItems, gap);
+    return findLoopPoints(indexes, -contentSize, true);
+  }
+  function canLoop() {
+    return loopPoints.every(({
+      index: index2
+    }) => {
+      const otherIndexes = ascItems.filter((i2) => i2 !== index2);
+      return removeSlideSizes(otherIndexes, viewSize) <= 0.1;
+    });
+  }
+  function loop() {
+    loopPoints.forEach((loopPoint) => {
+      const {
+        target,
+        translate,
+        slideLocation
+      } = loopPoint;
+      const shiftLocation = target();
+      if (shiftLocation === slideLocation.get())
+        return;
+      translate.to(shiftLocation);
+      slideLocation.set(shiftLocation);
+    });
+  }
+  function clear() {
+    loopPoints.forEach((loopPoint) => loopPoint.translate.clear());
+  }
+  const self = {
+    canLoop,
+    clear,
+    loop,
+    loopPoints
+  };
+  return self;
+}
+function SlidesHandler(container, eventHandler, watchSlides) {
+  let mutationObserver;
+  let destroyed = false;
+  function init(emblaApi) {
+    if (!watchSlides)
+      return;
+    function defaultCallback(mutations) {
+      for (const mutation of mutations) {
+        if (mutation.type === "childList") {
+          emblaApi.reInit();
+          eventHandler.emit("slidesChanged");
+          break;
+        }
+      }
+    }
+    mutationObserver = new MutationObserver((mutations) => {
+      if (destroyed)
+        return;
+      if (isBoolean(watchSlides) || watchSlides(emblaApi, mutations)) {
+        defaultCallback(mutations);
+      }
+    });
+    mutationObserver.observe(container, {
+      childList: true
+    });
+  }
+  function destroy() {
+    if (mutationObserver)
+      mutationObserver.disconnect();
+    destroyed = true;
+  }
+  const self = {
+    init,
+    destroy
+  };
+  return self;
+}
+function SlidesInView(container, slides, eventHandler, threshold) {
+  const intersectionEntryMap = {};
+  let inViewCache = null;
+  let notInViewCache = null;
+  let intersectionObserver;
+  let destroyed = false;
+  function init() {
+    intersectionObserver = new IntersectionObserver((entries) => {
+      if (destroyed)
+        return;
+      entries.forEach((entry) => {
+        const index2 = slides.indexOf(entry.target);
+        intersectionEntryMap[index2] = entry;
+      });
+      inViewCache = null;
+      notInViewCache = null;
+      eventHandler.emit("slidesInView");
+    }, {
+      root: container.parentElement,
+      threshold
+    });
+    slides.forEach((slide) => intersectionObserver.observe(slide));
+  }
+  function destroy() {
+    if (intersectionObserver)
+      intersectionObserver.disconnect();
+    destroyed = true;
+  }
+  function createInViewList(inView) {
+    return objectKeys(intersectionEntryMap).reduce((list, slideIndex) => {
+      const index2 = parseInt(slideIndex);
+      const {
+        isIntersecting
+      } = intersectionEntryMap[index2];
+      const inViewMatch = inView && isIntersecting;
+      const notInViewMatch = !inView && !isIntersecting;
+      if (inViewMatch || notInViewMatch)
+        list.push(index2);
+      return list;
+    }, []);
+  }
+  function get(inView = true) {
+    if (inView && inViewCache)
+      return inViewCache;
+    if (!inView && notInViewCache)
+      return notInViewCache;
+    const slideIndexes = createInViewList(inView);
+    if (inView)
+      inViewCache = slideIndexes;
+    if (!inView)
+      notInViewCache = slideIndexes;
+    return slideIndexes;
+  }
+  const self = {
+    init,
+    destroy,
+    get
+  };
+  return self;
+}
+function SlideSizes(axis, containerRect, slideRects, slides, readEdgeGap, ownerWindow) {
+  const {
+    measureSize,
+    startEdge,
+    endEdge
+  } = axis;
+  const withEdgeGap = slideRects[0] && readEdgeGap;
+  const startGap = measureStartGap();
+  const endGap = measureEndGap();
+  const slideSizes = slideRects.map(measureSize);
+  const slideSizesWithGaps = measureWithGaps();
+  function measureStartGap() {
+    if (!withEdgeGap)
+      return 0;
+    const slideRect = slideRects[0];
+    return mathAbs(containerRect[startEdge] - slideRect[startEdge]);
+  }
+  function measureEndGap() {
+    if (!withEdgeGap)
+      return 0;
+    const style = ownerWindow.getComputedStyle(arrayLast(slides));
+    return parseFloat(style.getPropertyValue(`margin-${endEdge}`));
+  }
+  function measureWithGaps() {
+    return slideRects.map((rect, index2, rects) => {
+      const isFirst = !index2;
+      const isLast = index2 === arrayLastIndex(rects);
+      if (isFirst)
+        return slideSizes[index2] + startGap;
+      if (isLast)
+        return slideSizes[index2] + endGap;
+      return rects[index2 + 1][startEdge] - rect[startEdge];
+    }).map(mathAbs);
+  }
+  const self = {
+    slideSizes,
+    slideSizesWithGaps,
+    startGap,
+    endGap
+  };
+  return self;
+}
+function SlidesToScroll(axis, direction, viewSize, slidesToScroll, loop, containerRect, slideRects, startGap, endGap) {
+  const {
+    startEdge,
+    endEdge
+  } = axis;
+  const groupByNumber = isNumber(slidesToScroll);
+  function byNumber(array, groupSize) {
+    return arrayKeys(array).filter((i2) => i2 % groupSize === 0).map((i2) => array.slice(i2, i2 + groupSize));
+  }
+  function bySize(array) {
+    if (!array.length)
+      return [];
+    return arrayKeys(array).reduce((groups, rectB) => {
+      const rectA = arrayLast(groups) || 0;
+      const isFirst = rectA === 0;
+      const isLast = rectB === arrayLastIndex(array);
+      const edgeA = containerRect[startEdge] - slideRects[rectA][startEdge];
+      const edgeB = containerRect[startEdge] - slideRects[rectB][endEdge];
+      const gapA = !loop && isFirst ? direction.apply(startGap) : 0;
+      const gapB = !loop && isLast ? direction.apply(endGap) : 0;
+      const chunkSize = mathAbs(edgeB - gapB - (edgeA + gapA));
+      if (chunkSize > viewSize)
+        groups.push(rectB);
+      if (isLast)
+        groups.push(array.length);
+      return groups;
+    }, []).map((currentSize, index2, groups) => {
+      const previousSize = Math.max(groups[index2 - 1] || 0);
+      return array.slice(previousSize, currentSize);
+    });
+  }
+  function groupSlides(array) {
+    return groupByNumber ? byNumber(array, slidesToScroll) : bySize(array);
+  }
+  const self = {
+    groupSlides
+  };
+  return self;
+}
+function Engine(root, container, slides, ownerDocument, ownerWindow, options, eventHandler, animations2) {
+  const {
+    align,
+    axis: scrollAxis,
+    direction: contentDirection,
+    startIndex,
+    loop,
+    duration,
+    dragFree,
+    dragThreshold,
+    inViewThreshold,
+    slidesToScroll: groupSlides,
+    skipSnaps,
+    containScroll,
+    watchResize,
+    watchSlides,
+    watchDrag
+  } = options;
+  const containerRect = container.getBoundingClientRect();
+  const slideRects = slides.map((slide) => slide.getBoundingClientRect());
+  const direction = Direction(contentDirection);
+  const axis = Axis(scrollAxis, contentDirection);
+  const viewSize = axis.measureSize(containerRect);
+  const percentOfView = PercentOfView(viewSize);
+  const alignment = Alignment(align, viewSize);
+  const containSnaps = !loop && !!containScroll;
+  const readEdgeGap = loop || !!containScroll;
+  const {
+    slideSizes,
+    slideSizesWithGaps,
+    startGap,
+    endGap
+  } = SlideSizes(axis, containerRect, slideRects, slides, readEdgeGap, ownerWindow);
+  const slidesToScroll = SlidesToScroll(axis, direction, viewSize, groupSlides, loop, containerRect, slideRects, startGap, endGap);
+  const {
+    snaps,
+    snapsAligned
+  } = ScrollSnaps(axis, alignment, containerRect, slideRects, slidesToScroll);
+  const contentSize = -arrayLast(snaps) + arrayLast(slideSizesWithGaps);
+  const {
+    snapsContained,
+    scrollContainLimit
+  } = ScrollContain(viewSize, contentSize, snapsAligned, containScroll);
+  const scrollSnaps = containSnaps ? snapsContained : snapsAligned;
+  const {
+    limit
+  } = ScrollLimit(contentSize, scrollSnaps, loop);
+  const index2 = Counter(arrayLastIndex(scrollSnaps), startIndex, loop);
+  const indexPrevious = index2.clone();
+  const slideIndexes = arrayKeys(slides);
+  const update = ({
+    dragHandler,
+    scrollBody: scrollBody2,
+    scrollBounds,
+    eventHandler: eventHandler2,
+    animation: animation2,
+    options: {
+      loop: loop2
+    }
+  }) => {
+    const pointerDown = dragHandler.pointerDown();
+    if (!loop2)
+      scrollBounds.constrain(pointerDown);
+    const hasSettled = scrollBody2.seek().settled();
+    if (hasSettled && !pointerDown) {
+      animation2.stop();
+      eventHandler2.emit("settle");
+    }
+    if (!hasSettled)
+      eventHandler2.emit("scroll");
+  };
+  const render = ({
+    scrollBody: scrollBody2,
+    translate,
+    location: location2,
+    offsetLocation: offsetLocation2,
+    scrollLooper,
+    slideLooper,
+    options: {
+      loop: loop2
+    }
+  }, lagOffset) => {
+    const velocity = scrollBody2.velocity();
+    offsetLocation2.set(location2.get() - velocity + velocity * lagOffset);
+    if (loop2) {
+      scrollLooper.loop(scrollBody2.direction());
+      slideLooper.loop();
+    }
+    translate.to(offsetLocation2.get());
+  };
+  const animation = {
+    start: () => animations2.start(engine),
+    stop: () => animations2.stop(engine),
+    update: () => update(engine),
+    render: (lagOffset) => render(engine, lagOffset)
+  };
+  const friction = 0.68;
+  const startLocation = scrollSnaps[index2.get()];
+  const location = Vector1D(startLocation);
+  const offsetLocation = Vector1D(startLocation);
+  const target = Vector1D(startLocation);
+  const scrollBody = ScrollBody(location, target, duration, friction);
+  const scrollTarget = ScrollTarget(loop, scrollSnaps, contentSize, limit, target);
+  const scrollTo = ScrollTo(animation, index2, indexPrevious, scrollTarget, scrollBody, target, eventHandler);
+  const scrollProgress = ScrollProgress(limit);
+  const eventStore = EventStore();
+  const slidesInView = SlidesInView(container, slides, eventHandler, inViewThreshold);
+  const {
+    slideRegistry
+  } = SlideRegistry(viewSize, contentSize, containSnaps, scrollContainLimit, slidesToScroll, slideIndexes);
+  const slideFocus = SlideFocus(root, slides, slideRegistry, scrollTo, scrollBody, eventStore);
+  const engine = {
+    ownerDocument,
+    ownerWindow,
+    eventHandler,
+    containerRect,
+    slideRects,
+    animation,
+    axis,
+    direction,
+    dragHandler: DragHandler(axis, direction, root, ownerDocument, ownerWindow, target, DragTracker(axis, ownerWindow), location, animation, scrollTo, scrollBody, scrollTarget, index2, eventHandler, percentOfView, dragFree, dragThreshold, skipSnaps, friction, watchDrag),
+    eventStore,
+    percentOfView,
+    index: index2,
+    indexPrevious,
+    limit,
+    location,
+    offsetLocation,
+    options,
+    resizeHandler: ResizeHandler(container, eventHandler, ownerWindow, slides, axis, watchResize),
+    scrollBody,
+    scrollBounds: ScrollBounds(limit, location, target, scrollBody, percentOfView),
+    scrollLooper: ScrollLooper(contentSize, limit, offsetLocation, [location, offsetLocation, target]),
+    scrollProgress,
+    scrollSnapList: scrollSnaps.map(scrollProgress.get),
+    scrollSnaps,
+    scrollTarget,
+    scrollTo,
+    slideLooper: SlideLooper(axis, direction, viewSize, contentSize, slideSizes, slideSizesWithGaps, snaps, scrollSnaps, offsetLocation, slides),
+    slideFocus,
+    slidesHandler: SlidesHandler(container, eventHandler, watchSlides),
+    slidesInView,
+    slideIndexes,
+    slideRegistry,
+    slidesToScroll,
+    target,
+    translate: Translate(axis, direction, container)
+  };
+  return engine;
+}
+function Animations(ownerWindow) {
+  const timeStep = 1e3 / 60;
+  let engines = [];
+  let lastTimeStamp = null;
+  let lag = 0;
+  let animationFrame = 0;
+  function animate(timeStamp) {
+    if (!lastTimeStamp)
+      lastTimeStamp = timeStamp;
+    const elapsed = timeStamp - lastTimeStamp;
+    lastTimeStamp = timeStamp;
+    lag += elapsed;
+    while (lag >= timeStep) {
+      engines.forEach(({
+        animation
+      }) => animation.update());
+      lag -= timeStep;
+    }
+    const lagOffset = mathAbs(lag / timeStep);
+    engines.forEach(({
+      animation
+    }) => animation.render(lagOffset));
+    if (animationFrame)
+      ownerWindow.requestAnimationFrame(animate);
+  }
+  function start(engine) {
+    if (!engines.includes(engine))
+      engines.push(engine);
+    if (animationFrame)
+      return;
+    animationFrame = ownerWindow.requestAnimationFrame(animate);
+  }
+  function stop(engine) {
+    engines = engines.filter((e2) => e2 !== engine);
+    if (engines.length)
+      return;
+    ownerWindow.cancelAnimationFrame(animationFrame);
+    lastTimeStamp = null;
+    lag = 0;
+    animationFrame = 0;
+  }
+  function reset() {
+    lastTimeStamp = null;
+    lag = 0;
+  }
+  const self = {
+    start,
+    stop,
+    reset,
+    window: ownerWindow
+  };
+  return self;
+}
+function EventHandler() {
+  const listeners = {};
+  let api;
+  function init(emblaApi) {
+    api = emblaApi;
+  }
+  function getListeners(evt) {
+    return listeners[evt] || [];
+  }
+  function emit(evt) {
+    getListeners(evt).forEach((e2) => e2(api, evt));
+    return self;
+  }
+  function on(evt, cb) {
+    listeners[evt] = getListeners(evt).concat([cb]);
+    return self;
+  }
+  function off(evt, cb) {
+    listeners[evt] = getListeners(evt).filter((e2) => e2 !== cb);
+    return self;
+  }
+  const self = {
+    init,
+    emit,
+    off,
+    on
+  };
+  return self;
+}
+const defaultOptions = {
+  align: "center",
+  axis: "x",
+  container: null,
+  slides: null,
+  containScroll: "trimSnaps",
+  direction: "ltr",
+  slidesToScroll: 1,
+  inViewThreshold: 0,
+  breakpoints: {},
+  dragFree: false,
+  dragThreshold: 10,
+  loop: false,
+  skipSnaps: false,
+  duration: 25,
+  startIndex: 0,
+  active: true,
+  watchDrag: true,
+  watchResize: true,
+  watchSlides: true
+};
+function OptionsHandler(ownerWindow) {
+  function mergeOptions(optionsA, optionsB) {
+    return objectsMergeDeep(optionsA, optionsB || {});
+  }
+  function optionsAtMedia(options) {
+    const optionsAtMedia2 = options.breakpoints || {};
+    const matchedMediaOptions = objectKeys(optionsAtMedia2).filter((media) => ownerWindow.matchMedia(media).matches).map((media) => optionsAtMedia2[media]).reduce((a2, mediaOption) => mergeOptions(a2, mediaOption), {});
+    return mergeOptions(options, matchedMediaOptions);
+  }
+  function optionsMediaQueries(optionsList) {
+    return optionsList.map((options) => objectKeys(options.breakpoints || {})).reduce((acc, mediaQueries) => acc.concat(mediaQueries), []).map(ownerWindow.matchMedia);
+  }
+  const self = {
+    mergeOptions,
+    optionsAtMedia,
+    optionsMediaQueries
+  };
+  return self;
+}
+function PluginsHandler(optionsHandler) {
+  let activePlugins = [];
+  function init(emblaApi, plugins) {
+    activePlugins = plugins.filter(({
+      options
+    }) => optionsHandler.optionsAtMedia(options).active !== false);
+    activePlugins.forEach((plugin) => plugin.init(emblaApi, optionsHandler));
+    return plugins.reduce((map, plugin) => Object.assign(map, {
+      [plugin.name]: plugin
+    }), {});
+  }
+  function destroy() {
+    activePlugins = activePlugins.filter((plugin) => plugin.destroy());
+  }
+  const self = {
+    init,
+    destroy
+  };
+  return self;
+}
+function EmblaCarousel(root, userOptions, userPlugins) {
+  const ownerDocument = root.ownerDocument;
+  const ownerWindow = ownerDocument.defaultView;
+  const optionsHandler = OptionsHandler(ownerWindow);
+  const pluginsHandler = PluginsHandler(optionsHandler);
+  const mediaHandlers = EventStore();
+  const documentVisibleHandler = EventStore();
+  const eventHandler = EventHandler();
+  const {
+    animationRealms
+  } = EmblaCarousel;
+  const {
+    mergeOptions,
+    optionsAtMedia,
+    optionsMediaQueries
+  } = optionsHandler;
+  const {
+    on,
+    off,
+    emit
+  } = eventHandler;
+  const reInit = reActivate;
+  let destroyed = false;
+  let engine;
+  let optionsBase = mergeOptions(defaultOptions, EmblaCarousel.globalOptions);
+  let options = mergeOptions(optionsBase);
+  let pluginList = [];
+  let pluginApis;
+  let container;
+  let slides;
+  function storeElements() {
+    const {
+      container: userContainer,
+      slides: userSlides
+    } = options;
+    const customContainer = isString(userContainer) ? root.querySelector(userContainer) : userContainer;
+    container = customContainer || root.children[0];
+    const customSlides = isString(userSlides) ? container.querySelectorAll(userSlides) : userSlides;
+    slides = [].slice.call(customSlides || container.children);
+  }
+  function createEngine(options2, animations2) {
+    const engine2 = Engine(root, container, slides, ownerDocument, ownerWindow, options2, eventHandler, animations2);
+    if (options2.loop && !engine2.slideLooper.canLoop()) {
+      const optionsWithoutLoop = Object.assign({}, options2, {
+        loop: false
+      });
+      return createEngine(optionsWithoutLoop, animations2);
+    }
+    return engine2;
+  }
+  function activate(withOptions, withPlugins) {
+    if (destroyed)
+      return;
+    const animationRealm = animationRealms.find((a2) => a2.window === ownerWindow);
+    const animations2 = animationRealm || Animations(ownerWindow);
+    if (!animationRealm)
+      animationRealms.push(animations2);
+    optionsBase = mergeOptions(optionsBase, withOptions);
+    options = optionsAtMedia(optionsBase);
+    pluginList = withPlugins || pluginList;
+    storeElements();
+    engine = createEngine(options, animations2);
+    optionsMediaQueries([optionsBase, ...pluginList.map(({
+      options: options2
+    }) => options2)]).forEach((query) => mediaHandlers.add(query, "change", reActivate));
+    if (!options.active)
+      return;
+    engine.translate.to(engine.location.get());
+    engine.slidesInView.init();
+    engine.slideFocus.init();
+    engine.eventHandler.init(self);
+    engine.resizeHandler.init(self);
+    engine.slidesHandler.init(self);
+    documentVisibleHandler.add(ownerDocument, "visibilitychange", () => {
+      if (ownerDocument.hidden)
+        animations2.reset();
+    });
+    if (engine.options.loop)
+      engine.slideLooper.loop();
+    if (container.offsetParent && slides.length)
+      engine.dragHandler.init(self);
+    pluginApis = pluginsHandler.init(self, pluginList);
+  }
+  function reActivate(withOptions, withPlugins) {
+    const startIndex = selectedScrollSnap();
+    deActivate();
+    activate(mergeOptions({
+      startIndex
+    }, withOptions), withPlugins);
+    eventHandler.emit("reInit");
+  }
+  function deActivate() {
+    engine.dragHandler.destroy();
+    engine.animation.stop();
+    engine.eventStore.clear();
+    engine.translate.clear();
+    engine.slideLooper.clear();
+    engine.resizeHandler.destroy();
+    engine.slidesHandler.destroy();
+    pluginsHandler.destroy();
+    mediaHandlers.clear();
+    documentVisibleHandler.clear();
+  }
+  function destroy() {
+    if (destroyed)
+      return;
+    destroyed = true;
+    mediaHandlers.clear();
+    deActivate();
+    eventHandler.emit("destroy");
+  }
+  function scrollTo(index2, jump, direction) {
+    if (!options.active || destroyed)
+      return;
+    engine.scrollBody.useBaseFriction().useDuration(jump ? 0 : options.duration);
+    engine.scrollTo.index(index2, direction || 0);
+  }
+  function scrollNext(jump) {
+    const next = engine.index.add(1).get();
+    scrollTo(next, jump === true, -1);
+  }
+  function scrollPrev(jump) {
+    const prev = engine.index.add(-1).get();
+    scrollTo(prev, jump === true, 1);
+  }
+  function canScrollNext() {
+    const next = engine.index.add(1).get();
+    return next !== selectedScrollSnap();
+  }
+  function canScrollPrev() {
+    const prev = engine.index.add(-1).get();
+    return prev !== selectedScrollSnap();
+  }
+  function scrollSnapList() {
+    return engine.scrollSnapList;
+  }
+  function scrollProgress() {
+    return engine.scrollProgress.get(engine.location.get());
+  }
+  function selectedScrollSnap() {
+    return engine.index.get();
+  }
+  function previousScrollSnap() {
+    return engine.indexPrevious.get();
+  }
+  function slidesInView() {
+    return engine.slidesInView.get();
+  }
+  function slidesNotInView() {
+    return engine.slidesInView.get(false);
+  }
+  function plugins() {
+    return pluginApis;
+  }
+  function internalEngine() {
+    return engine;
+  }
+  function rootNode() {
+    return root;
+  }
+  function containerNode() {
+    return container;
+  }
+  function slideNodes() {
+    return slides;
+  }
+  const self = {
+    canScrollNext,
+    canScrollPrev,
+    containerNode,
+    internalEngine,
+    destroy,
+    off,
+    on,
+    emit,
+    plugins,
+    previousScrollSnap,
+    reInit,
+    rootNode,
+    scrollNext,
+    scrollPrev,
+    scrollProgress,
+    scrollSnapList,
+    scrollTo,
+    selectedScrollSnap,
+    slideNodes,
+    slidesInView,
+    slidesNotInView
+  };
+  activate(userOptions, userPlugins);
+  setTimeout(() => eventHandler.emit("init"), 0);
+  return self;
+}
+EmblaCarousel.animationRealms = [];
+EmblaCarousel.globalOptions = void 0;
+function useEmblaCarousel(options = {}, plugins = []) {
+  const storedOptions = useRef(options);
+  const storedPlugins = useRef(plugins);
+  const [emblaApi, setEmblaApi] = useState();
+  const [viewport, setViewport] = useState();
+  const reInit = useCallback(() => {
+    if (emblaApi)
+      emblaApi.reInit(storedOptions.current, storedPlugins.current);
+  }, [emblaApi]);
+  useEffect(() => {
+    if (canUseDOM() && viewport) {
+      EmblaCarousel.globalOptions = useEmblaCarousel.globalOptions;
+      const newEmblaApi = EmblaCarousel(viewport, storedOptions.current, storedPlugins.current);
+      setEmblaApi(newEmblaApi);
+      return () => newEmblaApi.destroy();
+    } else {
+      setEmblaApi(void 0);
+    }
+  }, [viewport, setEmblaApi]);
+  useEffect(() => {
+    if (areOptionsEqual(storedOptions.current, options))
+      return;
+    storedOptions.current = options;
+    reInit();
+  }, [options, reInit]);
+  useEffect(() => {
+    if (arePluginsEqual(storedPlugins.current, plugins))
+      return;
+    storedPlugins.current = plugins;
+    reInit();
+  }, [plugins, reInit]);
+  return [setViewport, emblaApi];
+}
+useEmblaCarousel.globalOptions = void 0;
 export {
   $cb5cc270b50c6fcd$export$be92b6f5f03c0fe9 as $,
   $cc7e05a45900e73f$export$2f60d3ec9ad468f2 as A,
@@ -17082,10 +18789,11 @@ export {
   $57acba87d6e25586$export$6521433ed15a34db as O,
   MasonryResponsive as P,
   Masonry as Q,
-  $5d3850c4d0b4e6c7$export$be92b6f5f03c0fe9 as R,
-  $5d3850c4d0b4e6c7$export$602eac185826482c as S,
-  $5d3850c4d0b4e6c7$export$c6fdb837b070b4ff as T,
-  $5d3850c4d0b4e6c7$export$7c6e2c02157bb7d2 as U,
+  useEmblaCarousel as R,
+  $5d3850c4d0b4e6c7$export$be92b6f5f03c0fe9 as S,
+  $5d3850c4d0b4e6c7$export$602eac185826482c as T,
+  $5d3850c4d0b4e6c7$export$c6fdb837b070b4ff as U,
+  $5d3850c4d0b4e6c7$export$7c6e2c02157bb7d2 as V,
   $cb5cc270b50c6fcd$export$41fb9f06171c75f4 as a,
   $cb5cc270b50c6fcd$export$602eac185826482c as b,
   $cb5cc270b50c6fcd$export$7c6e2c02157bb7d2 as c,
@@ -17113,4 +18821,4 @@ export {
   $cc7e05a45900e73f$export$602eac185826482c as y,
   $cc7e05a45900e73f$export$7c6e2c02157bb7d2 as z
 };
-//# sourceMappingURL=vendor-efe38901.js.map
+//# sourceMappingURL=vendor-eadacf73.js.map