@ozdao/prometheus-framework 0.2.198 → 0.2.200

package/dist/node_modules/embla-carousel/esm/embla-carousel.esm.js

@@ -1,1016 +1,1374 @@
-function Et(t) {
-  return typeof t == "number";
+function isNumber(subject) {
+  return typeof subject === "number";
 }
-function bt(t) {
-  return typeof t == "string";
+function isString(subject) {
+  return typeof subject === "string";
 }
-function It(t) {
-  return typeof t == "boolean";
+function isBoolean(subject) {
+  return typeof subject === "boolean";
 }
-function Nt(t) {
-  return Object.prototype.toString.call(t) === "[object Object]";
+function isObject(subject) {
+  return Object.prototype.toString.call(subject) === "[object Object]";
 }
-function P(t) {
-  return Math.abs(t);
+function mathAbs(n) {
+  return Math.abs(n);
 }
-function Tt(t) {
-  return Math.sign(t);
+function mathSign(n) {
+  return Math.sign(n);
 }
-function ut(t, n) {
-  return P(t - n);
+function deltaAbs(valueB, valueA) {
+  return mathAbs(valueB - valueA);
 }
-function Xt(t, n) {
-  if (t === 0 || n === 0 || P(t) <= P(n)) return 0;
-  const r = ut(P(t), P(n));
-  return P(r / t);
+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 ft(t) {
-  return at(t).map(Number);
+function arrayKeys(array) {
+  return objectKeys(array).map(Number);
 }
-function H(t) {
-  return t[dt(t)];
+function arrayLast(array) {
+  return array[arrayLastIndex(array)];
 }
-function dt(t) {
-  return Math.max(0, t.length - 1);
+function arrayLastIndex(array) {
+  return Math.max(0, array.length - 1);
 }
-function vt(t, n) {
-  return n === dt(t);
+function arrayIsLastIndex(array, index) {
+  return index === arrayLastIndex(array);
 }
-function Vt(t, n = 0) {
-  return Array.from(Array(t), (r, s) => n + s);
+function arrayFromNumber(n, startAt = 0) {
+  return Array.from(Array(n), (_, i) => startAt + i);
 }
-function at(t) {
-  return Object.keys(t);
+function objectKeys(object) {
+  return Object.keys(object);
 }
-function zt(t, n) {
-  return [t, n].reduce((r, s) => (at(s).forEach((c) => {
-    const o = r[c], e = s[c], f = Nt(o) && Nt(e);
-    r[c] = f ? zt(o, e) : e;
-  }), r), {});
+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 Lt(t, n) {
-  return typeof n.MouseEvent < "u" && t instanceof n.MouseEvent;
+function isMouseEvent(evt, ownerWindow) {
+  return typeof ownerWindow.MouseEvent !== "undefined" && evt instanceof ownerWindow.MouseEvent;
 }
-function Yt(t, n) {
-  const r = {
-    start: s,
-    center: c,
-    end: o
+function Alignment(align, viewSize) {
+  const predefined = {
+    start,
+    center,
+    end
   };
-  function s() {
+  function start() {
     return 0;
   }
-  function c(i) {
-    return o(i) / 2;
+  function center(n) {
+    return end(n) / 2;
   }
-  function o(i) {
-    return n - i;
+  function end(n) {
+    return viewSize - n;
   }
-  function e(i, u) {
-    return bt(t) ? r[t](i) : t(n, i, u);
+  function measure(n, index) {
+    if (isString(align)) return predefined[align](n);
+    return align(viewSize, n, index);
   }
-  return {
-    measure: e
+  const self = {
+    measure
   };
+  return self;
 }
-function lt() {
-  let t = [];
-  function n(c, o, e, f = {
-    passive: !0
+function EventStore() {
+  let listeners = [];
+  function add(node, type, handler, options = {
+    passive: true
   }) {
-    let i;
-    if ("addEventListener" in c)
-      c.addEventListener(o, e, f), i = () => c.removeEventListener(o, e, f);
-    else {
-      const u = c;
-      u.addListener(e), i = () => u.removeListener(e);
+    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);
     }
-    return t.push(i), s;
+    listeners.push(removeListener);
+    return self;
   }
-  function r() {
-    t = t.filter((c) => c());
+  function clear() {
+    listeners = listeners.filter((remove) => remove());
   }
-  const s = {
-    add: n,
-    clear: r
+  const self = {
+    add,
+    clear
   };
-  return s;
+  return self;
 }
-function _t(t, n, r, s) {
-  const c = lt(), o = 1e3 / 60;
-  let e = null, f = 0, i = 0;
-  function u() {
-    c.add(t, "visibilitychange", () => {
-      t.hidden && d();
+function Animations(ownerDocument, ownerWindow, update, render) {
+  const documentVisibleHandler = EventStore();
+  const timeStep = 1e3 / 60;
+  let lastTimeStamp = null;
+  let lag = 0;
+  let animationFrame = 0;
+  function init() {
+    documentVisibleHandler.add(ownerDocument, "visibilitychange", () => {
+      if (ownerDocument.hidden) reset();
     });
   }
-  function h() {
-    b(), c.clear();
-  }
-  function l(g) {
-    if (!i) return;
-    e || (e = g);
-    const a = g - e;
-    for (e = g, f += a; f >= o; )
-      r(o), f -= o;
-    const S = f / o;
-    s(S), i && n.requestAnimationFrame(l);
-  }
-  function p() {
-    i || (i = n.requestAnimationFrame(l));
-  }
-  function b() {
-    n.cancelAnimationFrame(i), e = null, f = 0, i = 0;
-  }
-  function d() {
-    e = null, f = 0;
-  }
-  return {
-    init: u,
-    destroy: h,
-    start: p,
-    stop: b,
-    update: () => r(o),
-    render: s
+  function destroy() {
+    stop();
+    documentVisibleHandler.clear();
+  }
+  function animate(timeStamp) {
+    if (!animationFrame) return;
+    if (!lastTimeStamp) lastTimeStamp = timeStamp;
+    const elapsed = timeStamp - lastTimeStamp;
+    lastTimeStamp = timeStamp;
+    lag += elapsed;
+    while (lag >= timeStep) {
+      update(timeStep);
+      lag -= timeStep;
+    }
+    const lagOffset = lag / timeStep;
+    render(lagOffset);
+    if (animationFrame) ownerWindow.requestAnimationFrame(animate);
+  }
+  function start() {
+    if (animationFrame) return;
+    animationFrame = ownerWindow.requestAnimationFrame(animate);
+  }
+  function stop() {
+    ownerWindow.cancelAnimationFrame(animationFrame);
+    lastTimeStamp = null;
+    lag = 0;
+    animationFrame = 0;
+  }
+  function reset() {
+    lastTimeStamp = null;
+    lag = 0;
+  }
+  const self = {
+    init,
+    destroy,
+    start,
+    stop,
+    update: () => update(timeStep),
+    render
   };
+  return self;
 }
-function Jt(t, n) {
-  const r = n === "rtl", s = t === "y", c = s ? "y" : "x", o = s ? "x" : "y", e = !s && r ? -1 : 1, f = h(), i = l();
-  function u(d) {
+function Axis(axis, contentDirection) {
+  const isRightToLeft = contentDirection === "rtl";
+  const isVertical = axis === "y";
+  const scroll = isVertical ? "y" : "x";
+  const cross = isVertical ? "x" : "y";
+  const sign = !isVertical && isRightToLeft ? -1 : 1;
+  const startEdge = getStartEdge();
+  const endEdge = getEndEdge();
+  function measureSize(nodeRect) {
     const {
-      height: m,
-      width: g
-    } = d;
-    return s ? m : g;
-  }
-  function h() {
-    return s ? "top" : r ? "right" : "left";
-  }
-  function l() {
-    return s ? "bottom" : r ? "left" : "right";
-  }
-  function p(d) {
-    return d * e;
-  }
-  return {
-    scroll: c,
-    cross: o,
-    startEdge: f,
-    endEdge: i,
-    measureSize: u,
-    direction: p
+      height,
+      width
+    } = nodeRect;
+    return isVertical ? height : width;
+  }
+  function getStartEdge() {
+    if (isVertical) return "top";
+    return isRightToLeft ? "right" : "left";
+  }
+  function getEndEdge() {
+    if (isVertical) return "bottom";
+    return isRightToLeft ? "left" : "right";
+  }
+  function direction(n) {
+    return n * sign;
+  }
+  const self = {
+    scroll,
+    cross,
+    startEdge,
+    endEdge,
+    measureSize,
+    direction
   };
+  return self;
 }
-function nt(t = 0, n = 0) {
-  const r = P(t - n);
-  function s(u) {
-    return u < t;
-  }
-  function c(u) {
-    return u > n;
-  }
-  function o(u) {
-    return s(u) || c(u);
-  }
-  function e(u) {
-    return o(u) ? s(u) ? t : n : u;
-  }
-  function f(u) {
-    return r ? u - r * Math.ceil((u - n) / r) : u;
-  }
-  return {
-    length: r,
-    max: n,
-    min: t,
-    constrain: e,
-    reachedAny: o,
-    reachedMax: c,
-    reachedMin: s,
-    removeOffset: f
+function Limit(min = 0, max = 0) {
+  const length = mathAbs(min - max);
+  function reachedMin(n) {
+    return n < min;
+  }
+  function reachedMax(n) {
+    return n > max;
+  }
+  function reachedAny(n) {
+    return reachedMin(n) || reachedMax(n);
+  }
+  function constrain(n) {
+    if (!reachedAny(n)) return n;
+    return reachedMin(n) ? min : max;
+  }
+  function removeOffset(n) {
+    if (!length) return n;
+    return n - length * Math.ceil((n - max) / length);
+  }
+  const self = {
+    length,
+    max,
+    min,
+    constrain,
+    reachedAny,
+    reachedMax,
+    reachedMin,
+    removeOffset
   };
+  return self;
 }
-function Bt(t, n, r) {
+function Counter(max, start, loop) {
   const {
-    constrain: s
-  } = nt(0, t), c = t + 1;
-  let o = e(n);
-  function e(p) {
-    return r ? P((c + p) % c) : s(p);
-  }
-  function f() {
-    return o;
-  }
-  function i(p) {
-    return o = e(p), l;
-  }
-  function u(p) {
-    return h().set(f() + p);
-  }
-  function h() {
-    return Bt(t, f(), r);
-  }
-  const l = {
-    get: f,
-    set: i,
-    add: u,
-    clone: h
+    constrain
+  } = Limit(0, max);
+  const loopEnd = max + 1;
+  let counter = withinLimit(start);
+  function withinLimit(n) {
+    return !loop ? constrain(n) : mathAbs((loopEnd + n) % loopEnd);
+  }
+  function get() {
+    return counter;
+  }
+  function set(n) {
+    counter = withinLimit(n);
+    return self;
+  }
+  function add(n) {
+    return clone().set(get() + n);
+  }
+  function clone() {
+    return Counter(max, get(), loop);
+  }
+  const self = {
+    get,
+    set,
+    add,
+    clone
   };
-  return l;
+  return self;
 }
-function Zt(t, n, r, s, c, o, e, f, i, u, h, l, p, b, d, m, g, a, S) {
+function DragHandler(axis, rootNode, ownerDocument, ownerWindow, target, dragTracker, location, animation, scrollTo, scrollBody, scrollTarget, index, eventHandler, percentOfView, dragFree, dragThreshold, skipSnaps, baseFriction, watchDrag) {
   const {
-    cross: x,
-    direction: T
-  } = t, M = ["INPUT", "SELECT", "TEXTAREA"], v = {
-    passive: !1
-  }, L = lt(), E = lt(), I = nt(50, 225).constrain(b.measure(20)), D = {
+    cross: crossAxis,
+    direction
+  } = 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
-  }, F = {
+  };
+  const freeForceBoost = {
     mouse: 500,
     touch: 600
-  }, V = d ? 43 : 25;
-  let _ = !1, B = 0, q = 0, W = !1, U = !1, J = !1, $ = !1;
-  function tt(y) {
-    if (!S) return;
-    function A(w) {
-      (It(S) || S(y, w)) && z(w);
+  };
+  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 C = n;
-    L.add(C, "dragstart", (w) => w.preventDefault(), v).add(C, "touchmove", () => {
-    }, v).add(C, "touchend", () => {
-    }).add(C, "touchstart", A).add(C, "mousedown", A).add(C, "touchcancel", N).add(C, "contextmenu", N).add(C, "click", ot, !0);
-  }
-  function Q() {
-    L.clear(), E.clear();
-  }
-  function et() {
-    const y = $ ? r : n;
-    E.add(y, "touchmove", G, v).add(y, "touchend", N).add(y, "mousemove", G, v).add(y, "mouseup", N);
-  }
-  function K(y) {
-    const A = y.nodeName || "";
-    return M.includes(A);
-  }
-  function st() {
-    return (d ? F : D)[$ ? "mouse" : "touch"];
-  }
-  function rt(y, A) {
-    const C = l.add(Tt(y) * -1), w = h.byDistance(y, !d).distance;
-    return d || P(y) < I ? w : g && A ? w * 0.5 : h.byIndex(C.get(), 0).distance;
-  }
-  function z(y) {
-    const A = Lt(y, s);
-    $ = A, J = d && A && !y.buttons && _, _ = ut(c.get(), e.get()) >= 2, !(A && y.button !== 0) && (K(y.target) || (W = !0, o.pointerDown(y), u.useFriction(0).useDuration(0), c.set(e), et(), B = o.readPoint(y), q = o.readPoint(y, x), p.emit("pointerDown")));
-  }
-  function G(y) {
-    if (!Lt(y, s) && y.touches.length >= 2) return N(y);
-    const C = o.readPoint(y), w = o.readPoint(y, x), j = ut(C, B), X = ut(w, q);
-    if (!U && !$ && (!y.cancelable || (U = j > X, !U)))
-      return N(y);
-    const R = o.pointerMove(y);
-    j > m && (J = !0), u.useFriction(0.3).useDuration(0.75), f.start(), c.add(T(R)), y.preventDefault();
-  }
-  function N(y) {
-    const C = h.byDistance(0, !1).index !== l.get(), w = o.pointerUp(y) * st(), j = rt(T(w), C), X = Xt(w, j), R = V - 10 * X, Y = a + X / 50;
-    U = !1, W = !1, E.clear(), u.useDuration(R).useFriction(Y), i.distance(j, !d), $ = !1, p.emit("pointerUp");
-  }
-  function ot(y) {
-    J && (y.stopPropagation(), y.preventDefault(), J = !1);
-  }
-  function k() {
-    return W;
-  }
-  return {
-    init: tt,
-    destroy: Q,
-    pointerDown: k
+    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 = index.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;
+    preventClick = dragFree && isMouseEvt && !evt.buttons && isMoving;
+    isMoving = deltaAbs(target.get(), location.get()) >= 2;
+    if (isMouseEvt && evt.button !== 0) return;
+    if (isFocusNode(evt.target)) return;
+    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 isTouchEvt = !isMouseEvent(evt, ownerWindow);
+    if (isTouchEvt && evt.touches.length >= 2) return up(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(0.75);
+    animation.start();
+    target.add(direction(diff));
+    evt.preventDefault();
+  }
+  function up(evt) {
+    const currentLocation = scrollTarget.byDistance(0, false);
+    const targetChanged = currentLocation.index !== index.get();
+    const rawForce = dragTracker.pointerUp(evt) * forceBoost();
+    const force = allowedForce(direction(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();
+      preventClick = false;
+    }
+  }
+  function pointerDown() {
+    return pointerIsDown;
+  }
+  const self = {
+    init,
+    destroy,
+    pointerDown
   };
+  return self;
 }
-function Wt(t, n) {
-  let s, c;
-  function o(l) {
-    return l.timeStamp;
-  }
-  function e(l, p) {
-    const d = `client${(p || t.scroll) === "x" ? "X" : "Y"}`;
-    return (Lt(l, n) ? l : l.touches[0])[d];
-  }
-  function f(l) {
-    return s = l, c = l, e(l);
-  }
-  function i(l) {
-    const p = e(l) - e(c), b = o(l) - o(s) > 170;
-    return c = l, b && (s = l), p;
-  }
-  function u(l) {
-    if (!s || !c) return 0;
-    const p = e(c) - e(s), b = o(l) - o(s), d = o(l) - o(c) > 170, m = p / b;
-    return b && !d && P(m) > 0.1 ? m : 0;
-  }
-  return {
-    pointerDown: f,
-    pointerMove: i,
-    pointerUp: u,
-    readPoint: e
+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 tn() {
-  function t(r) {
+function NodeRects() {
+  function measure(node) {
     const {
-      offsetTop: s,
-      offsetLeft: c,
-      offsetWidth: o,
-      offsetHeight: e
-    } = r;
-    return {
-      top: s,
-      right: c + o,
-      bottom: s + e,
-      left: c,
-      width: o,
-      height: e
+      offsetTop,
+      offsetLeft,
+      offsetWidth,
+      offsetHeight
+    } = node;
+    const offset = {
+      top: offsetTop,
+      right: offsetLeft + offsetWidth,
+      bottom: offsetTop + offsetHeight,
+      left: offsetLeft,
+      width: offsetWidth,
+      height: offsetHeight
     };
+    return offset;
   }
-  return {
-    measure: t
+  const self = {
+    measure
   };
+  return self;
 }
-function nn(t) {
-  function n(s) {
-    return t * (s / 100);
+function PercentOfView(viewSize) {
+  function measure(n) {
+    return viewSize * (n / 100);
   }
-  return {
-    measure: n
+  const self = {
+    measure
   };
+  return self;
 }
-function en(t, n, r, s, c, o, e) {
-  const f = [t].concat(s);
-  let i, u, h = [], l = !1;
-  function p(g) {
-    return c.measureSize(e.measure(g));
-  }
-  function b(g) {
-    if (!o) return;
-    u = p(t), h = s.map(p);
-    function a(S) {
-      for (const x of S) {
-        if (l) return;
-        const T = x.target === t, M = s.indexOf(x.target), v = T ? u : h[M], L = p(T ? t : s[M]);
-        if (P(L - v) >= 0.5) {
-          g.reInit(), n.emit("resize");
+function ResizeHandler(container, eventHandler, ownerWindow, slides, axis, watchResize, nodeRects) {
+  const observeNodes = [container].concat(slides);
+  let resizeObserver;
+  let containerSize;
+  let slideSizes = [];
+  let destroyed = false;
+  function readSize(node) {
+    return axis.measureSize(nodeRects.measure(node));
+  }
+  function init(emblaApi) {
+    if (!watchResize) return;
+    containerSize = readSize(container);
+    slideSizes = slides.map(readSize);
+    function defaultCallback(entries) {
+      for (const entry of entries) {
+        if (destroyed) return;
+        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.5) {
+          emblaApi.reInit();
+          eventHandler.emit("resize");
           break;
         }
       }
     }
-    i = new ResizeObserver((S) => {
-      (It(o) || o(g, S)) && a(S);
-    }), r.requestAnimationFrame(() => {
-      f.forEach((S) => i.observe(S));
+    resizeObserver = new ResizeObserver((entries) => {
+      if (isBoolean(watchResize) || watchResize(emblaApi, entries)) {
+        defaultCallback(entries);
+      }
+    });
+    ownerWindow.requestAnimationFrame(() => {
+      observeNodes.forEach((node) => resizeObserver.observe(node));
     });
   }
-  function d() {
-    l = !0, i && i.disconnect();
+  function destroy() {
+    destroyed = true;
+    if (resizeObserver) resizeObserver.disconnect();
   }
-  return {
-    init: b,
-    destroy: d
-  };
-}
-function on(t, n, r, s, c, o) {
-  let e = 0, f = 0, i = c, u = o, h = t.get(), l = 0;
-  function p(v) {
-    const L = v / 1e3, E = i * L, I = s.get() - t.get(), D = !i;
-    let F = 0;
-    return D ? (e = 0, r.set(s), t.set(s), F = I) : (r.set(t), e += I / E, e *= u, h += e, t.add(e * L), F = h - l), f = Tt(F), l = h, M;
-  }
-  function b() {
-    const v = s.get() - n.get();
-    return P(v) < 1e-3;
-  }
-  function d() {
-    return i;
-  }
-  function m() {
-    return f;
-  }
-  function g() {
-    return e;
-  }
-  function a() {
-    return x(c);
-  }
-  function S() {
-    return T(o);
-  }
-  function x(v) {
-    return i = v, M;
-  }
-  function T(v) {
-    return u = v, M;
-  }
-  const M = {
-    direction: m,
-    duration: d,
-    velocity: g,
-    seek: p,
-    settled: b,
-    useBaseFriction: S,
-    useBaseDuration: a,
-    useFriction: T,
-    useDuration: x
+  const self = {
+    init,
+    destroy
   };
-  return M;
+  return self;
 }
-function sn(t, n, r, s, c) {
-  const o = c.measure(10), e = c.measure(50), f = nt(0.1, 0.99);
-  let i = !1;
-  function u() {
-    return !(i || !t.reachedAny(r.get()) || !t.reachedAny(n.get()));
-  }
-  function h(b) {
-    if (!u()) return;
-    const d = t.reachedMin(n.get()) ? "min" : "max", m = P(t[d] - n.get()), g = r.get() - n.get(), a = f.constrain(m / e);
-    r.subtract(g * a), !b && P(g) < o && (r.set(t.constrain(r.get())), s.useDuration(25).useBaseFriction());
-  }
-  function l(b) {
-    i = !b;
-  }
-  return {
-    shouldConstrain: u,
-    constrain: h,
-    toggleActive: l
+function ScrollBody(location, offsetLocation, previousLocation, target, baseDuration, baseFriction) {
+  let bodyVelocity = 0;
+  let scrollDirection = 0;
+  let scrollDuration = baseDuration;
+  let scrollFriction = baseFriction;
+  let rawLocation = location.get();
+  let rawLocationPrevious = 0;
+  function seek(timeStep) {
+    const fixedDeltaTimeSeconds = timeStep / 1e3;
+    const duration2 = scrollDuration * fixedDeltaTimeSeconds;
+    const diff = target.get() - location.get();
+    const isInstant = !scrollDuration;
+    let directionDiff = 0;
+    if (isInstant) {
+      bodyVelocity = 0;
+      previousLocation.set(target);
+      location.set(target);
+      directionDiff = diff;
+    } else {
+      previousLocation.set(location);
+      bodyVelocity += diff / duration2;
+      bodyVelocity *= scrollFriction;
+      rawLocation += bodyVelocity;
+      location.add(bodyVelocity * fixedDeltaTimeSeconds);
+      directionDiff = rawLocation - rawLocationPrevious;
+    }
+    scrollDirection = mathSign(directionDiff);
+    rawLocationPrevious = rawLocation;
+    return self;
+  }
+  function settled() {
+    const diff = target.get() - offsetLocation.get();
+    return mathAbs(diff) < 1e-3;
+  }
+  function duration() {
+    return scrollDuration;
+  }
+  function direction() {
+    return scrollDirection;
+  }
+  function velocity() {
+    return bodyVelocity;
+  }
+  function useBaseDuration() {
+    return useDuration(baseDuration);
+  }
+  function useBaseFriction() {
+    return useFriction(baseFriction);
+  }
+  function useDuration(n) {
+    scrollDuration = n;
+    return self;
+  }
+  function useFriction(n) {
+    scrollFriction = n;
+    return self;
+  }
+  const self = {
+    direction,
+    duration,
+    velocity,
+    seek,
+    settled,
+    useBaseFriction,
+    useBaseDuration,
+    useFriction,
+    useDuration
   };
+  return self;
 }
-function rn(t, n, r, s, c) {
-  const o = nt(-n + t, 0), e = l(), f = h(), i = p();
-  function u(d, m) {
-    return ut(d, m) < 1;
+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 h() {
-    const d = e[0], m = H(e), g = e.lastIndexOf(d), a = e.indexOf(m) + 1;
-    return nt(g, a);
+  function toggleActive(active) {
+    disabled = !active;
   }
-  function l() {
-    return r.map((d, m) => {
+  const self = {
+    shouldConstrain,
+    constrain,
+    toggleActive
+  };
+  return self;
+}
+function ScrollContain(viewSize, contentSize, snapsAligned, containScroll, pixelTolerance) {
+  const scrollBounds = Limit(-contentSize + viewSize, 0);
+  const snapsBounded = measureBounded();
+  const scrollContainLimit = findScrollContainLimit();
+  const snapsContained = measureContained();
+  function usePixelTolerance(bound, snap) {
+    return deltaAbs(bound, snap) < 1;
+  }
+  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((snapAligned, index) => {
       const {
-        min: g,
-        max: a
-      } = o, S = o.constrain(d), x = !m, T = vt(r, m);
-      return x ? a : T || u(g, S) ? g : u(a, S) ? a : S;
-    }).map((d) => parseFloat(d.toFixed(3)));
-  }
-  function p() {
-    if (n <= t + c) return [o.max];
-    if (s === "keepSnaps") return e;
+        min,
+        max
+      } = scrollBounds;
+      const snap = scrollBounds.constrain(snapAligned);
+      const isFirst = !index;
+      const isLast = arrayIsLastIndex(snapsAligned, index);
+      if (isFirst) return max;
+      if (isLast) return min;
+      if (usePixelTolerance(min, snap)) return min;
+      if (usePixelTolerance(max, snap)) return max;
+      return snap;
+    }).map((scrollBound) => parseFloat(scrollBound.toFixed(3)));
+  }
+  function measureContained() {
+    if (contentSize <= viewSize + pixelTolerance) return [scrollBounds.max];
+    if (containScroll === "keepSnaps") return snapsBounded;
     const {
-      min: d,
-      max: m
-    } = f;
-    return e.slice(d, m);
-  }
-  return {
-    snapsContained: i,
-    scrollContainLimit: f
+      min,
+      max
+    } = scrollContainLimit;
+    return snapsBounded.slice(min, max);
+  }
+  const self = {
+    snapsContained,
+    scrollContainLimit
   };
+  return self;
 }
-function cn(t, n, r) {
-  const s = n[0], c = r ? s - t : H(n);
-  return {
-    limit: nt(c, s)
+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 un(t, n, r, s) {
-  const o = n.min + 0.1, e = n.max + 0.1, {
-    reachedMin: f,
-    reachedMax: i
-  } = nt(o, e);
-  function u(p) {
-    return p === 1 ? i(r.get()) : p === -1 ? f(r.get()) : !1;
-  }
-  function h(p) {
-    if (!u(p)) return;
-    const b = t * (p * -1);
-    s.forEach((d) => d.add(b));
-  }
-  return {
-    loop: h
+function ScrollLooper(contentSize, limit, location, 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(location.get());
+    if (direction === -1) return reachedMin(location.get());
+    return false;
+  }
+  function loop(direction) {
+    if (!shouldLoop(direction)) return;
+    const loopDistance = contentSize * (direction * -1);
+    vectors.forEach((v) => v.add(loopDistance));
+  }
+  const self = {
+    loop
   };
+  return self;
 }
-function fn(t) {
+function ScrollProgress(limit) {
   const {
-    max: n,
-    length: r
-  } = t;
-  function s(o) {
-    const e = o - n;
-    return r ? e / -r : 0;
-  }
-  return {
-    get: s
+    max,
+    length
+  } = limit;
+  function get(n) {
+    const currentLocation = n - max;
+    return length ? currentLocation / -length : 0;
+  }
+  const self = {
+    get
   };
+  return self;
 }
-function an(t, n, r, s, c) {
+function ScrollSnaps(axis, alignment, containerRect, slideRects, slidesToScroll) {
   const {
-    startEdge: o,
-    endEdge: e
-  } = t, {
-    groupSlides: f
-  } = c, i = l().map(n.measure), u = p(), h = b();
-  function l() {
-    return f(s).map((m) => H(m)[e] - m[0][o]).map(P);
-  }
-  function p() {
-    return s.map((m) => r[o] - m[o]).map((m) => -P(m));
-  }
-  function b() {
-    return f(u).map((m) => m[0]).map((m, g) => m + i[g]);
-  }
-  return {
-    snaps: u,
-    snapsAligned: h
+    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((g) => g[0]).map((snap, index) => snap + alignments[index]);
+  }
+  const self = {
+    snaps,
+    snapsAligned
   };
+  return self;
 }
-function ln(t, n, r, s, c, o) {
+function SlideRegistry(containSnaps, containScroll, scrollSnaps, scrollContainLimit, slidesToScroll, slideIndexes) {
+  const {
+    groupSlides
+  } = slidesToScroll;
   const {
-    groupSlides: e
-  } = c, {
-    min: f,
-    max: i
-  } = s, u = h();
-  function h() {
-    const p = e(o), b = !t || n === "keepSnaps";
-    return r.length === 1 ? [o] : b ? p : p.slice(f, i).map((d, m, g) => {
-      const a = !m, S = vt(g, m);
-      if (a) {
-        const x = H(g[0]) + 1;
-        return Vt(x);
+    min,
+    max
+  } = scrollContainLimit;
+  const slideRegistry = createSlideRegistry();
+  function createSlideRegistry() {
+    const groupedSlideIndexes = groupSlides(slideIndexes);
+    const doNotContain = !containSnaps || containScroll === "keepSnaps";
+    if (scrollSnaps.length === 1) return [slideIndexes];
+    if (doNotContain) return groupedSlideIndexes;
+    return groupedSlideIndexes.slice(min, max).map((group, index, groups) => {
+      const isFirst = !index;
+      const isLast = arrayIsLastIndex(groups, index);
+      if (isFirst) {
+        const range = arrayLast(groups[0]) + 1;
+        return arrayFromNumber(range);
       }
-      if (S) {
-        const x = dt(o) - H(g)[0] + 1;
-        return Vt(x, H(g)[0]);
+      if (isLast) {
+        const range = arrayLastIndex(slideIndexes) - arrayLast(groups)[0] + 1;
+        return arrayFromNumber(range, arrayLast(groups)[0]);
       }
-      return d;
+      return group;
     });
   }
-  return {
-    slideRegistry: u
+  const self = {
+    slideRegistry
   };
+  return self;
 }
-function dn(t, n, r, s, c) {
+function ScrollTarget(loop, scrollSnaps, contentSize, limit, targetVector) {
   const {
-    reachedAny: o,
-    removeOffset: e,
-    constrain: f
-  } = s;
-  function i(d) {
-    return d.concat().sort((m, g) => P(m) - P(g))[0];
-  }
-  function u(d) {
-    const m = t ? e(d) : f(d), g = n.map((S, x) => ({
-      diff: h(S - m, 0),
-      index: x
-    })).sort((S, x) => P(S.diff) - P(x.diff)), {
-      index: a
-    } = g[0];
+    reachedAny,
+    removeOffset,
+    constrain
+  } = limit;
+  function minDistance(distances) {
+    return distances.concat().sort((a, b) => mathAbs(a) - mathAbs(b))[0];
+  }
+  function findTargetSnap(target) {
+    const distance = loop ? removeOffset(target) : constrain(target);
+    const ascDiffsToSnaps = scrollSnaps.map((snap, index2) => ({
+      diff: shortcut(snap - distance, 0),
+      index: index2
+    })).sort((d1, d2) => mathAbs(d1.diff) - mathAbs(d2.diff));
+    const {
+      index
+    } = ascDiffsToSnaps[0];
     return {
-      index: a,
-      distance: m
+      index,
+      distance
     };
   }
-  function h(d, m) {
-    const g = [d, d + r, d - r];
-    if (!t) return d;
-    if (!m) return i(g);
-    const a = g.filter((S) => Tt(S) === m);
-    return a.length ? i(a) : H(g) - r;
-  }
-  function l(d, m) {
-    const g = n[d] - c.get(), a = h(g, m);
+  function shortcut(target, direction) {
+    const targets = [target, target + contentSize, target - contentSize];
+    if (!loop) return target;
+    if (!direction) return minDistance(targets);
+    const matchingTargets = targets.filter((t) => mathSign(t) === direction);
+    if (matchingTargets.length) return minDistance(matchingTargets);
+    return arrayLast(targets) - contentSize;
+  }
+  function byIndex(index, direction) {
+    const diffToSnap = scrollSnaps[index] - targetVector.get();
+    const distance = shortcut(diffToSnap, direction);
     return {
-      index: d,
-      distance: a
+      index,
+      distance
     };
   }
-  function p(d, m) {
-    const g = c.get() + d, {
-      index: a,
-      distance: S
-    } = u(g), x = !t && o(g);
-    if (!m || x) return {
-      index: a,
-      distance: d
+  function byDistance(distance, snap) {
+    const target = targetVector.get() + distance;
+    const {
+      index,
+      distance: targetSnapDistance
+    } = findTargetSnap(target);
+    const reachedBound = !loop && reachedAny(target);
+    if (!snap || reachedBound) return {
+      index,
+      distance
     };
-    const T = n[a] - S, M = d + h(T, 0);
+    const diffToSnap = scrollSnaps[index] - targetSnapDistance;
+    const snapDistance = distance + shortcut(diffToSnap, 0);
     return {
-      index: a,
-      distance: M
+      index,
+      distance: snapDistance
     };
   }
-  return {
-    byDistance: p,
-    byIndex: l,
-    shortcut: h
+  const self = {
+    byDistance,
+    byIndex,
+    shortcut
   };
+  return self;
 }
-function pn(t, n, r, s, c, o, e) {
-  function f(l) {
-    const p = l.distance, b = l.index !== n.get();
-    o.add(p), p && (s.duration() ? t.start() : (t.update(), t.render(1), t.update())), b && (r.set(n.get()), n.set(l.index), e.emit("select"));
-  }
-  function i(l, p) {
-    const b = c.byDistance(l, p);
-    f(b);
-  }
-  function u(l, p) {
-    const b = n.clone().set(l), d = c.byIndex(b.get(), p);
-    f(d);
-  }
-  return {
-    distance: i,
-    index: u
+function ScrollTo(animation, indexCurrent, indexPrevious, scrollBody, scrollTarget, 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 distance(n, snap) {
+    const target = scrollTarget.byDistance(n, snap);
+    scrollTo(target);
+  }
+  function index(n, direction) {
+    const targetIndex = indexCurrent.clone().set(n);
+    const target = scrollTarget.byIndex(targetIndex.get(), direction);
+    scrollTo(target);
+  }
+  const self = {
+    distance,
+    index
   };
+  return self;
 }
-function mn(t, n, r, s, c, o, e) {
-  let f = 0;
-  function i() {
-    o.add(document, "keydown", u, !1), n.forEach(h);
-  }
-  function u(p) {
-    p.code === "Tab" && (f = (/* @__PURE__ */ new Date()).getTime());
-  }
-  function h(p) {
-    const b = () => {
-      if ((/* @__PURE__ */ new Date()).getTime() - f > 10) return;
-      t.scrollLeft = 0;
-      const g = n.indexOf(p), a = r.findIndex((S) => S.includes(g));
-      Et(a) && (c.useDuration(0), s.index(a, 0), e.emit("slideFocus"));
+function SlideFocus(root, slides, slideRegistry, scrollTo, scrollBody, eventStore, eventHandler) {
+  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 index = slides.indexOf(slide);
+      const group = slideRegistry.findIndex((group2) => group2.includes(index));
+      if (!isNumber(group)) return;
+      scrollBody.useDuration(0);
+      scrollTo.index(group, 0);
+      eventHandler.emit("slideFocus");
     };
-    o.add(p, "focus", b, {
-      passive: !0,
-      capture: !0
+    eventStore.add(slide, "focus", focus, {
+      passive: true,
+      capture: true
     });
   }
-  return {
-    init: i
+  const self = {
+    init
   };
+  return self;
 }
-function ct(t) {
-  let n = t;
-  function r() {
-    return n;
+function Vector1D(initialValue) {
+  let value = initialValue;
+  function get() {
+    return value;
   }
-  function s(i) {
-    n = e(i);
+  function set(n) {
+    value = normalizeInput(n);
   }
-  function c(i) {
-    n += e(i);
+  function add(n) {
+    value += normalizeInput(n);
   }
-  function o(i) {
-    n -= e(i);
+  function subtract(n) {
+    value -= normalizeInput(n);
   }
-  function e(i) {
-    return Et(i) ? i : i.get();
+  function normalizeInput(n) {
+    return isNumber(n) ? n : n.get();
   }
-  return {
-    get: r,
-    set: s,
-    add: c,
-    subtract: o
+  const self = {
+    get,
+    set,
+    add,
+    subtract
   };
+  return self;
 }
-function kt(t, n) {
-  const r = t.scroll === "x" ? o : e, s = n.style;
-  let c = !1;
-  function o(l) {
-    return `translate3d(${l}px,0px,0px)`;
-  }
-  function e(l) {
-    return `translate3d(0px,${l}px,0px)`;
-  }
-  function f(l) {
-    c || (s.transform = r(t.direction(l)));
-  }
-  function i(l) {
-    c = !l;
-  }
-  function u() {
-    c || (s.transform = "", n.getAttribute("style") || n.removeAttribute("style"));
-  }
-  return {
-    clear: u,
-    to: f,
-    toggleActive: i
+function Translate(axis, container) {
+  const translate = axis.scroll === "x" ? x : y;
+  const containerStyle = container.style;
+  let disabled = false;
+  function x(n) {
+    return `translate3d(${n}px,0px,0px)`;
+  }
+  function y(n) {
+    return `translate3d(0px,${n}px,0px)`;
+  }
+  function to(target) {
+    if (disabled) return;
+    containerStyle.transform = translate(axis.direction(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 gn(t, n, r, s, c, o, e, f, i) {
-  const h = ft(c), l = ft(c).reverse(), p = a().concat(S());
-  function b(L, E) {
-    return L.reduce((I, D) => I - c[D], E);
-  }
-  function d(L, E) {
-    return L.reduce((I, D) => b(I, E) > 0 ? I.concat([D]) : I, []);
-  }
-  function m(L) {
-    return o.map((E, I) => ({
-      start: E - s[I] + 0.5 + L,
-      end: E + n - 0.5 + L
+function SlideLooper(axis, viewSize, contentSize, slideSizes, slideSizesWithGaps, snaps, scrollSnaps, location, 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((a, i) => {
+      return a - slideSizesWithGaps[i];
+    }, from);
+  }
+  function slidesInGap(indexes, gap) {
+    return indexes.reduce((a, i) => {
+      const remainingGap = removeSlideSizes(a, gap);
+      return remainingGap > 0 ? a.concat([i]) : a;
+    }, []);
+  }
+  function findSlideBounds(offset) {
+    return snaps.map((snap, index) => ({
+      start: snap - slideSizes[index] + roundingSafety + offset,
+      end: snap + viewSize - roundingSafety + offset
     }));
   }
-  function g(L, E, I) {
-    const D = m(E);
-    return L.map((F) => {
-      const V = I ? 0 : -r, _ = I ? r : 0, B = I ? "end" : "start", q = D[F][B];
+  function findLoopPoints(indexes, offset, isEndEdge) {
+    const slideBounds = findSlideBounds(offset);
+    return indexes.map((index) => {
+      const initial = isEndEdge ? 0 : -contentSize;
+      const altered = isEndEdge ? contentSize : 0;
+      const boundEdge = isEndEdge ? "end" : "start";
+      const loopPoint = slideBounds[index][boundEdge];
       return {
-        index: F,
-        loopPoint: q,
-        slideLocation: ct(-1),
-        translate: kt(t, i[F]),
-        target: () => f.get() > q ? V : _
+        index,
+        loopPoint,
+        slideLocation: Vector1D(-1),
+        translate: Translate(axis, slides[index]),
+        target: () => location.get() > loopPoint ? initial : altered
       };
     });
   }
-  function a() {
-    const L = e[0], E = d(l, L);
-    return g(E, r, !1);
+  function startPoints() {
+    const gap = scrollSnaps[0];
+    const indexes = slidesInGap(descItems, gap);
+    return findLoopPoints(indexes, contentSize, false);
   }
-  function S() {
-    const L = n - e[0] - 1, E = d(h, L);
-    return g(E, -r, !0);
+  function endPoints() {
+    const gap = viewSize - scrollSnaps[0] - 1;
+    const indexes = slidesInGap(ascItems, gap);
+    return findLoopPoints(indexes, -contentSize, true);
   }
-  function x() {
-    return p.every(({
-      index: L
+  function canLoop() {
+    return loopPoints.every(({
+      index
     }) => {
-      const E = h.filter((I) => I !== L);
-      return b(E, n) <= 0.1;
+      const otherIndexes = ascItems.filter((i) => i !== index);
+      return removeSlideSizes(otherIndexes, viewSize) <= 0.1;
     });
   }
-  function T() {
-    p.forEach((L) => {
+  function loop() {
+    loopPoints.forEach((loopPoint) => {
       const {
-        target: E,
-        translate: I,
-        slideLocation: D
-      } = L, F = E();
-      F !== D.get() && (I.to(F), D.set(F));
+        target,
+        translate,
+        slideLocation
+      } = loopPoint;
+      const shiftLocation = target();
+      if (shiftLocation === slideLocation.get()) return;
+      translate.to(shiftLocation);
+      slideLocation.set(shiftLocation);
     });
   }
-  function M() {
-    p.forEach((L) => L.translate.clear());
+  function clear() {
+    loopPoints.forEach((loopPoint) => loopPoint.translate.clear());
   }
-  return {
-    canLoop: x,
-    clear: M,
-    loop: T,
-    loopPoints: p
+  const self = {
+    canLoop,
+    clear,
+    loop,
+    loopPoints
   };
+  return self;
 }
-function hn(t, n, r) {
-  let s, c = !1;
-  function o(i) {
-    if (!r) return;
-    function u(h) {
-      for (const l of h)
-        if (l.type === "childList") {
-          i.reInit(), n.emit("slidesChanged");
+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;
         }
+      }
     }
-    s = new MutationObserver((h) => {
-      c || (It(r) || r(i, h)) && u(h);
-    }), s.observe(t, {
-      childList: !0
+    mutationObserver = new MutationObserver((mutations) => {
+      if (destroyed) return;
+      if (isBoolean(watchSlides) || watchSlides(emblaApi, mutations)) {
+        defaultCallback(mutations);
+      }
+    });
+    mutationObserver.observe(container, {
+      childList: true
     });
   }
-  function e() {
-    s && s.disconnect(), c = !0;
+  function destroy() {
+    if (mutationObserver) mutationObserver.disconnect();
+    destroyed = true;
   }
-  return {
-    init: o,
-    destroy: e
+  const self = {
+    init,
+    destroy
   };
+  return self;
 }
-function Sn(t, n, r, s) {
-  const c = {};
-  let o = null, e = null, f, i = !1;
-  function u() {
-    f = new IntersectionObserver((d) => {
-      i || (d.forEach((m) => {
-        const g = n.indexOf(m.target);
-        c[g] = m;
-      }), o = null, e = null, r.emit("slidesInView"));
+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 index = slides.indexOf(entry.target);
+        intersectionEntryMap[index] = entry;
+      });
+      inViewCache = null;
+      notInViewCache = null;
+      eventHandler.emit("slidesInView");
     }, {
-      root: t.parentElement,
-      threshold: s
-    }), n.forEach((d) => f.observe(d));
-  }
-  function h() {
-    f && f.disconnect(), i = !0;
-  }
-  function l(d) {
-    return at(c).reduce((m, g) => {
-      const a = parseInt(g), {
-        isIntersecting: S
-      } = c[a];
-      return (d && S || !d && !S) && m.push(a), m;
-    }, []);
+      root: container.parentElement,
+      threshold
+    });
+    slides.forEach((slide) => intersectionObserver.observe(slide));
   }
-  function p(d = !0) {
-    if (d && o) return o;
-    if (!d && e) return e;
-    const m = l(d);
-    return d && (o = m), d || (e = m), m;
+  function destroy() {
+    if (intersectionObserver) intersectionObserver.disconnect();
+    destroyed = true;
   }
-  return {
-    init: u,
-    destroy: h,
-    get: p
+  function createInViewList(inView) {
+    return objectKeys(intersectionEntryMap).reduce((list, slideIndex) => {
+      const index = parseInt(slideIndex);
+      const {
+        isIntersecting
+      } = intersectionEntryMap[index];
+      const inViewMatch = inView && isIntersecting;
+      const notInViewMatch = !inView && !isIntersecting;
+      if (inViewMatch || notInViewMatch) list.push(index);
+      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 yn(t, n, r, s, c, o) {
+function SlideSizes(axis, containerRect, slideRects, slides, readEdgeGap, ownerWindow) {
   const {
-    measureSize: e,
-    startEdge: f,
-    endEdge: i
-  } = t, u = r[0] && c, h = d(), l = m(), p = r.map(e), b = g();
-  function d() {
-    if (!u) return 0;
-    const S = r[0];
-    return P(n[f] - S[f]);
-  }
-  function m() {
-    if (!u) return 0;
-    const S = o.getComputedStyle(H(s));
-    return parseFloat(S.getPropertyValue(`margin-${i}`));
-  }
-  function g() {
-    return r.map((S, x, T) => {
-      const M = !x, v = vt(T, x);
-      return M ? p[x] + h : v ? p[x] + l : T[x + 1][f] - S[f];
-    }).map(P);
-  }
-  return {
-    slideSizes: p,
-    slideSizesWithGaps: b,
-    startGap: h,
-    endGap: l
+    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, index, rects) => {
+      const isFirst = !index;
+      const isLast = arrayIsLastIndex(rects, index);
+      if (isFirst) return slideSizes[index] + startGap;
+      if (isLast) return slideSizes[index] + endGap;
+      return rects[index + 1][startEdge] - rect[startEdge];
+    }).map(mathAbs);
+  }
+  const self = {
+    slideSizes,
+    slideSizesWithGaps,
+    startGap,
+    endGap
   };
+  return self;
 }
-function xn(t, n, r, s, c, o, e, f, i) {
+function SlidesToScroll(axis, viewSize, slidesToScroll, loop, containerRect, slideRects, startGap, endGap, pixelTolerance) {
   const {
-    startEdge: u,
-    endEdge: h,
-    direction: l
-  } = t, p = Et(r);
-  function b(a, S) {
-    return ft(a).filter((x) => x % S === 0).map((x) => a.slice(x, x + S));
-  }
-  function d(a) {
-    return a.length ? ft(a).reduce((S, x, T) => {
-      const M = H(S) || 0, v = M === 0, L = x === dt(a), E = c[u] - o[M][u], I = c[u] - o[x][h], D = !s && v ? l(e) : 0, F = !s && L ? l(f) : 0, V = P(I - F - (E + D));
-      return T && V > n + i && S.push(x), L && S.push(a.length), S;
-    }, []).map((S, x, T) => {
-      const M = Math.max(T[x - 1] || 0);
-      return a.slice(M, S);
-    }) : [];
-  }
-  function m(a) {
-    return p ? b(a, r) : d(a);
-  }
-  return {
-    groupSlides: m
+    startEdge,
+    endEdge,
+    direction
+  } = axis;
+  const groupByNumber = isNumber(slidesToScroll);
+  function byNumber(array, groupSize) {
+    return arrayKeys(array).filter((i) => i % groupSize === 0).map((i) => array.slice(i, i + groupSize));
+  }
+  function bySize(array) {
+    if (!array.length) return [];
+    return arrayKeys(array).reduce((groups, rectB, index) => {
+      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(startGap) : 0;
+      const gapB = !loop && isLast ? direction(endGap) : 0;
+      const chunkSize = mathAbs(edgeB - gapB - (edgeA + gapA));
+      if (index && chunkSize > viewSize + pixelTolerance) groups.push(rectB);
+      if (isLast) groups.push(array.length);
+      return groups;
+    }, []).map((currentSize, index, groups) => {
+      const previousSize = Math.max(groups[index - 1] || 0);
+      return array.slice(previousSize, currentSize);
+    });
+  }
+  function groupSlides(array) {
+    return groupByNumber ? byNumber(array, slidesToScroll) : bySize(array);
+  }
+  const self = {
+    groupSlides
   };
+  return self;
 }
-function bn(t, n, r, s, c, o, e) {
+function Engine(root, container, slides, ownerDocument, ownerWindow, options, eventHandler) {
+  const {
+    align,
+    axis: scrollAxis,
+    direction,
+    startIndex,
+    loop,
+    duration,
+    dragFree,
+    dragThreshold,
+    inViewThreshold,
+    slidesToScroll: groupSlides,
+    skipSnaps,
+    containScroll,
+    watchResize,
+    watchSlides,
+    watchDrag
+  } = options;
+  const pixelTolerance = 2;
+  const nodeRects = NodeRects();
+  const containerRect = nodeRects.measure(container);
+  const slideRects = slides.map(nodeRects.measure);
+  const axis = Axis(scrollAxis, direction);
+  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, viewSize, groupSlides, loop, containerRect, slideRects, startGap, endGap, pixelTolerance);
   const {
-    align: f,
-    axis: i,
-    direction: u,
-    startIndex: h,
-    loop: l,
-    duration: p,
-    dragFree: b,
-    dragThreshold: d,
-    inViewThreshold: m,
-    slidesToScroll: g,
-    skipSnaps: a,
-    containScroll: S,
-    watchResize: x,
-    watchSlides: T,
-    watchDrag: M
-  } = o, v = 2, L = tn(), E = L.measure(n), I = r.map(L.measure), D = Jt(i, u), F = D.measureSize(E), V = nn(F), _ = Yt(f, F), B = !l && !!S, q = l || !!S, {
-    slideSizes: W,
-    slideSizesWithGaps: U,
-    startGap: J,
-    endGap: $
-  } = yn(D, E, I, r, q, c), tt = xn(D, F, g, l, E, I, J, $, v), {
-    snaps: Q,
-    snapsAligned: et
-  } = an(D, _, E, I, tt), K = -H(Q) + H(U), {
-    snapsContained: st,
-    scrollContainLimit: rt
-  } = rn(F, K, et, S, v), z = B ? st : et, {
-    limit: G
-  } = cn(K, z, l), N = Bt(dt(z), h, l), ot = N.clone(), k = ft(r), O = ({
-    dragHandler: Z,
-    scrollBody: St,
-    scrollBounds: yt,
+    snaps,
+    snapsAligned
+  } = ScrollSnaps(axis, alignment, containerRect, slideRects, slidesToScroll);
+  const contentSize = -arrayLast(snaps) + arrayLast(slideSizesWithGaps);
+  const {
+    snapsContained,
+    scrollContainLimit
+  } = ScrollContain(viewSize, contentSize, snapsAligned, containScroll, pixelTolerance);
+  const scrollSnaps = containSnaps ? snapsContained : snapsAligned;
+  const {
+    limit
+  } = ScrollLimit(contentSize, scrollSnaps, loop);
+  const index = Counter(arrayLastIndex(scrollSnaps), startIndex, loop);
+  const indexPrevious = index.clone();
+  const slideIndexes = arrayKeys(slides);
+  const update = ({
+    dragHandler,
+    scrollBody: scrollBody2,
+    scrollBounds,
     options: {
-      loop: pt
+      loop: loop2
     }
-  }, xt) => {
-    pt || yt.constrain(Z.pointerDown()), St.seek(xt);
-  }, y = ({
-    scrollBody: Z,
-    translate: St,
-    location: yt,
-    offsetLocation: pt,
-    scrollLooper: xt,
-    slideLooper: Rt,
-    dragHandler: qt,
-    animation: Ut,
-    eventHandler: Ft,
-    scrollBounds: $t,
+  }, timeStep) => {
+    if (!loop2) scrollBounds.constrain(dragHandler.pointerDown());
+    scrollBody2.seek(timeStep);
+  };
+  const render = ({
+    scrollBody: scrollBody2,
+    translate,
+    location: location2,
+    offsetLocation: offsetLocation2,
+    scrollLooper,
+    slideLooper,
+    dragHandler,
+    animation: animation2,
+    eventHandler: eventHandler2,
+    scrollBounds,
     options: {
-      loop: Pt
+      loop: loop2
+    }
+  }, lagOffset) => {
+    const shouldSettle = scrollBody2.settled();
+    const withinBounds = !scrollBounds.shouldConstrain();
+    const hasSettled = loop2 ? shouldSettle : shouldSettle && withinBounds;
+    if (hasSettled && !dragHandler.pointerDown()) {
+      animation2.stop();
+      eventHandler2.emit("settle");
+    }
+    if (!hasSettled) eventHandler2.emit("scroll");
+    const interpolatedLocation = location2.get() * lagOffset + previousLocation.get() * (1 - lagOffset);
+    offsetLocation2.set(interpolatedLocation);
+    if (loop2) {
+      scrollLooper.loop(scrollBody2.direction());
+      slideLooper.loop();
     }
-  }, Ot) => {
-    const Ct = Z.settled(), Qt = !$t.shouldConstrain(), wt = Pt ? Ct : Ct && Qt;
-    wt && !qt.pointerDown() && (Ut.stop(), Ft.emit("settle")), wt || Ft.emit("scroll");
-    const Kt = yt.get() * Ot + X.get() * (1 - Ot);
-    pt.set(Kt), Pt && (xt.loop(Z.direction()), Rt.loop()), St.to(pt.get());
-  }, A = _t(s, c, (Z) => O(ht, Z), (Z) => y(ht, Z)), C = 0.68, w = z[N.get()], j = ct(w), X = ct(w), R = ct(w), Y = ct(w), it = on(j, R, X, Y, p, C), mt = dn(l, z, K, G, Y), gt = pn(A, N, ot, it, mt, Y, e), Dt = fn(G), At = lt(), Gt = Sn(n, r, e, m), {
-    slideRegistry: Mt
-  } = ln(B, S, z, rt, tt, k), jt = mn(t, r, Mt, gt, it, At, e), ht = {
-    ownerDocument: s,
-    ownerWindow: c,
-    eventHandler: e,
-    containerRect: E,
-    slideRects: I,
-    animation: A,
-    axis: D,
-    dragHandler: Zt(D, t, s, c, Y, Wt(D, c), j, A, gt, it, mt, N, e, V, b, d, a, C, M),
-    eventStore: At,
-    percentOfView: V,
-    index: N,
-    indexPrevious: ot,
-    limit: G,
-    location: j,
-    offsetLocation: R,
-    previousLocation: X,
-    options: o,
-    resizeHandler: en(n, e, c, r, D, x, L),
-    scrollBody: it,
-    scrollBounds: sn(G, R, Y, it, V),
-    scrollLooper: un(K, G, R, [j, R, X, Y]),
-    scrollProgress: Dt,
-    scrollSnapList: z.map(Dt.get),
-    scrollSnaps: z,
-    scrollTarget: mt,
-    scrollTo: gt,
-    slideLooper: gn(D, F, K, W, U, Q, z, R, r),
-    slideFocus: jt,
-    slidesHandler: hn(n, e, T),
-    slidesInView: Gt,
-    slideIndexes: k,
-    slideRegistry: Mt,
-    slidesToScroll: tt,
-    target: Y,
-    translate: kt(D, n)
+    translate.to(offsetLocation2.get());
   };
-  return ht;
+  const animation = Animations(ownerDocument, ownerWindow, (timeStep) => update(engine, timeStep), (lagOffset) => render(engine, lagOffset));
+  const friction = 0.68;
+  const startLocation = scrollSnaps[index.get()];
+  const location = Vector1D(startLocation);
+  const previousLocation = Vector1D(startLocation);
+  const offsetLocation = Vector1D(startLocation);
+  const target = Vector1D(startLocation);
+  const scrollBody = ScrollBody(location, offsetLocation, previousLocation, target, duration, friction);
+  const scrollTarget = ScrollTarget(loop, scrollSnaps, contentSize, limit, target);
+  const scrollTo = ScrollTo(animation, index, indexPrevious, scrollBody, scrollTarget, target, eventHandler);
+  const scrollProgress = ScrollProgress(limit);
+  const eventStore = EventStore();
+  const slidesInView = SlidesInView(container, slides, eventHandler, inViewThreshold);
+  const {
+    slideRegistry
+  } = SlideRegistry(containSnaps, containScroll, scrollSnaps, scrollContainLimit, slidesToScroll, slideIndexes);
+  const slideFocus = SlideFocus(root, slides, slideRegistry, scrollTo, scrollBody, eventStore, eventHandler);
+  const engine = {
+    ownerDocument,
+    ownerWindow,
+    eventHandler,
+    containerRect,
+    slideRects,
+    animation,
+    axis,
+    dragHandler: DragHandler(axis, root, ownerDocument, ownerWindow, target, DragTracker(axis, ownerWindow), location, animation, scrollTo, scrollBody, scrollTarget, index, eventHandler, percentOfView, dragFree, dragThreshold, skipSnaps, friction, watchDrag),
+    eventStore,
+    percentOfView,
+    index,
+    indexPrevious,
+    limit,
+    location,
+    offsetLocation,
+    previousLocation,
+    options,
+    resizeHandler: ResizeHandler(container, eventHandler, ownerWindow, slides, axis, watchResize, nodeRects),
+    scrollBody,
+    scrollBounds: ScrollBounds(limit, offsetLocation, target, scrollBody, percentOfView),
+    scrollLooper: ScrollLooper(contentSize, limit, offsetLocation, [location, offsetLocation, previousLocation, target]),
+    scrollProgress,
+    scrollSnapList: scrollSnaps.map(scrollProgress.get),
+    scrollSnaps,
+    scrollTarget,
+    scrollTo,
+    slideLooper: SlideLooper(axis, viewSize, contentSize, slideSizes, slideSizesWithGaps, snaps, scrollSnaps, offsetLocation, slides),
+    slideFocus,
+    slidesHandler: SlidesHandler(container, eventHandler, watchSlides),
+    slidesInView,
+    slideIndexes,
+    slideRegistry,
+    slidesToScroll,
+    target,
+    translate: Translate(axis, container)
+  };
+  return engine;
 }
-function Ln() {
-  let t = {}, n;
-  function r(u) {
-    n = u;
-  }
-  function s(u) {
-    return t[u] || [];
-  }
-  function c(u) {
-    return s(u).forEach((h) => h(n, u)), i;
-  }
-  function o(u, h) {
-    return t[u] = s(u).concat([h]), i;
-  }
-  function e(u, h) {
-    return t[u] = s(u).filter((l) => l !== h), i;
-  }
-  function f() {
-    t = {};
-  }
-  const i = {
-    init: r,
-    emit: c,
-    off: e,
-    on: o,
-    clear: f
+function EventHandler() {
+  let listeners = {};
+  let api;
+  function init(emblaApi) {
+    api = emblaApi;
+  }
+  function getListeners(evt) {
+    return listeners[evt] || [];
+  }
+  function emit(evt) {
+    getListeners(evt).forEach((e) => e(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((e) => e !== cb);
+    return self;
+  }
+  function clear() {
+    listeners = {};
+  }
+  const self = {
+    init,
+    emit,
+    off,
+    on,
+    clear
   };
-  return i;
+  return self;
 }
-const En = {
+const defaultOptions = {
   align: "center",
   axis: "x",
   container: null,
@@ -1020,174 +1378,235 @@ const En = {
   slidesToScroll: 1,
   inViewThreshold: 0,
   breakpoints: {},
-  dragFree: !1,
+  dragFree: false,
   dragThreshold: 10,
-  loop: !1,
-  skipSnaps: !1,
+  loop: false,
+  skipSnaps: false,
   duration: 25,
   startIndex: 0,
-  active: !0,
-  watchDrag: !0,
-  watchResize: !0,
-  watchSlides: !0
+  active: true,
+  watchDrag: true,
+  watchResize: true,
+  watchSlides: true
 };
-function In(t) {
-  function n(o, e) {
-    return zt(o, e || {});
-  }
-  function r(o) {
-    const e = o.breakpoints || {}, f = at(e).filter((i) => t.matchMedia(i).matches).map((i) => e[i]).reduce((i, u) => n(i, u), {});
-    return n(o, f);
-  }
-  function s(o) {
-    return o.map((e) => at(e.breakpoints || {})).reduce((e, f) => e.concat(f), []).map(t.matchMedia);
-  }
-  return {
-    mergeOptions: n,
-    optionsAtMedia: r,
-    optionsMediaQueries: s
+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((a, mediaOption) => mergeOptions(a, 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 Tn(t) {
-  let n = [];
-  function r(o, e) {
-    return n = e.filter(({
-      options: f
-    }) => t.optionsAtMedia(f).active !== !1), n.forEach((f) => f.init(o, t)), e.reduce((f, i) => Object.assign(f, {
-      [i.name]: i
+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 s() {
-    n = n.filter((o) => o.destroy());
+  function destroy() {
+    activePlugins = activePlugins.filter((plugin) => plugin.destroy());
   }
-  return {
-    init: r,
-    destroy: s
+  const self = {
+    init,
+    destroy
   };
+  return self;
 }
-function Ht(t, n, r) {
-  const s = t.ownerDocument, c = s.defaultView, o = In(c), e = Tn(o), f = lt(), i = Ln(), {
-    mergeOptions: u,
-    optionsAtMedia: h,
-    optionsMediaQueries: l
-  } = o, {
-    on: p,
-    off: b,
-    emit: d
-  } = i, m = F;
-  let g = !1, a, S = u(En, Ht.globalOptions), x = u(S), T = [], M, v, L;
-  function E() {
+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 eventHandler = EventHandler();
+  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: O,
-      slides: y
-    } = x;
-    v = (bt(O) ? t.querySelector(O) : O) || t.children[0];
-    const C = bt(y) ? v.querySelectorAll(y) : y;
-    L = [].slice.call(C || v.children);
-  }
-  function I(O) {
-    const y = bn(t, v, L, s, c, O, i);
-    if (O.loop && !y.slideLooper.canLoop()) {
-      const A = Object.assign({}, O, {
-        loop: !1
+      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) {
+    const engine2 = Engine(root, container, slides, ownerDocument, ownerWindow, options2, eventHandler);
+    if (options2.loop && !engine2.slideLooper.canLoop()) {
+      const optionsWithoutLoop = Object.assign({}, options2, {
+        loop: false
       });
-      return I(A);
+      return createEngine(optionsWithoutLoop);
     }
-    return y;
-  }
-  function D(O, y) {
-    g || (S = u(S, O), x = h(S), T = y || T, E(), a = I(x), l([S, ...T.map(({
-      options: A
-    }) => A)]).forEach((A) => f.add(A, "change", F)), x.active && (a.translate.to(a.location.get()), a.animation.init(), a.slidesInView.init(), a.slideFocus.init(), a.eventHandler.init(k), a.resizeHandler.init(k), a.slidesHandler.init(k), a.options.loop && a.slideLooper.loop(), v.offsetParent && L.length && a.dragHandler.init(k), M = e.init(k, T)));
-  }
-  function F(O, y) {
-    const A = Q();
-    V(), D(u({
-      startIndex: A
-    }, O), y), i.emit("reInit");
-  }
-  function V() {
-    a.dragHandler.destroy(), a.eventStore.clear(), a.translate.clear(), a.slideLooper.clear(), a.resizeHandler.destroy(), a.slidesHandler.destroy(), a.slidesInView.destroy(), a.animation.destroy(), e.destroy(), f.clear();
-  }
-  function _() {
-    g || (g = !0, f.clear(), V(), i.emit("destroy"), i.clear());
-  }
-  function B(O, y, A) {
-    !x.active || g || (a.scrollBody.useBaseFriction().useDuration(y === !0 ? 0 : x.duration), a.scrollTo.index(O, A || 0));
-  }
-  function q(O) {
-    const y = a.index.add(1).get();
-    B(y, O, -1);
-  }
-  function W(O) {
-    const y = a.index.add(-1).get();
-    B(y, O, 1);
-  }
-  function U() {
-    return a.index.add(1).get() !== Q();
-  }
-  function J() {
-    return a.index.add(-1).get() !== Q();
-  }
-  function $() {
-    return a.scrollSnapList;
-  }
-  function tt() {
-    return a.scrollProgress.get(a.location.get());
-  }
-  function Q() {
-    return a.index.get();
-  }
-  function et() {
-    return a.indexPrevious.get();
-  }
-  function K() {
-    return a.slidesInView.get();
-  }
-  function st() {
-    return a.slidesInView.get(!1);
-  }
-  function rt() {
-    return M;
-  }
-  function z() {
-    return a;
-  }
-  function G() {
-    return t;
-  }
-  function N() {
-    return v;
-  }
-  function ot() {
-    return L;
-  }
-  const k = {
-    canScrollNext: U,
-    canScrollPrev: J,
-    containerNode: N,
-    internalEngine: z,
-    destroy: _,
-    off: b,
-    on: p,
-    emit: d,
-    plugins: rt,
-    previousScrollSnap: et,
-    reInit: m,
-    rootNode: G,
-    scrollNext: q,
-    scrollPrev: W,
-    scrollProgress: tt,
-    scrollSnapList: $,
-    scrollTo: B,
-    selectedScrollSnap: Q,
-    slideNodes: ot,
-    slidesInView: K,
-    slidesNotInView: st
+    return engine2;
+  }
+  function activate(withOptions, withPlugins) {
+    if (destroyed) return;
+    optionsBase = mergeOptions(optionsBase, withOptions);
+    options = optionsAtMedia(optionsBase);
+    pluginList = withPlugins || pluginList;
+    storeElements();
+    engine = createEngine(options);
+    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.animation.init();
+    engine.slidesInView.init();
+    engine.slideFocus.init();
+    engine.eventHandler.init(self);
+    engine.resizeHandler.init(self);
+    engine.slidesHandler.init(self);
+    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.eventStore.clear();
+    engine.translate.clear();
+    engine.slideLooper.clear();
+    engine.resizeHandler.destroy();
+    engine.slidesHandler.destroy();
+    engine.slidesInView.destroy();
+    engine.animation.destroy();
+    pluginsHandler.destroy();
+    mediaHandlers.clear();
+  }
+  function destroy() {
+    if (destroyed) return;
+    destroyed = true;
+    mediaHandlers.clear();
+    deActivate();
+    eventHandler.emit("destroy");
+    eventHandler.clear();
+  }
+  function scrollTo(index, jump, direction) {
+    if (!options.active || destroyed) return;
+    engine.scrollBody.useBaseFriction().useDuration(jump === true ? 0 : options.duration);
+    engine.scrollTo.index(index, direction || 0);
+  }
+  function scrollNext(jump) {
+    const next = engine.index.add(1).get();
+    scrollTo(next, jump, -1);
+  }
+  function scrollPrev(jump) {
+    const prev = engine.index.add(-1).get();
+    scrollTo(prev, jump, 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
   };
-  return D(n, r), setTimeout(() => i.emit("init"), 0), k;
+  activate(userOptions, userPlugins);
+  setTimeout(() => eventHandler.emit("init"), 0);
+  return self;
 }
-Ht.globalOptions = void 0;
+EmblaCarousel.globalOptions = void 0;
 export {
-  Ht as default
+  EmblaCarousel as default
 };
+//# sourceMappingURL=embla-carousel.esm.js.map