@ozdao/prometheus-framework 0.2.89 → 0.2.91

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

@@ -1,665 +1,663 @@
-function En(n) {
-  return typeof n == "number";
+function xt(t) {
+  return typeof t == "number";
 }
-function bn(n) {
-  return typeof n == "string";
+function yt(t) {
+  return typeof t == "string";
 }
-function Ln(n) {
-  return typeof n == "boolean";
+function Et(t) {
+  return typeof t == "boolean";
 }
-function On(n) {
-  return Object.prototype.toString.call(n) === "[object Object]";
+function Pt(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
 }
-function F(n) {
-  return Math.abs(n);
+function M(t) {
+  return Math.abs(t);
 }
-function In(n) {
-  return Math.sign(n);
+function Lt(t) {
+  return Math.sign(t);
 }
-function un(n, t) {
-  return F(n - t);
+function it(t, n) {
+  return M(t - n);
 }
-function Qn(n, t) {
-  if (n === 0 || t === 0 || F(n) <= F(t))
+function Ut(t, n) {
+  if (t === 0 || n === 0 || M(t) <= M(n))
     return 0;
-  const r = un(F(n), F(t));
-  return F(r / n);
+  const r = it(M(t), M(n));
+  return M(r / t);
 }
-function fn(n) {
-  return an(n).map(Number);
+function ct(t) {
+  return ut(t).map(Number);
 }
-function B(n) {
-  return n[dn(n)];
+function j(t) {
+  return t[at(t)];
 }
-function dn(n) {
-  return Math.max(0, n.length - 1);
+function at(t) {
+  return Math.max(0, t.length - 1);
 }
-function vn(n, t) {
-  return t === dn(n);
+function It(t, n) {
+  return n === at(t);
 }
-function wn(n, t = 0) {
-  return Array.from(Array(n), (r, i) => t + i);
+function Ot(t, n = 0) {
+  return Array.from(Array(t), (r, s) => n + s);
 }
-function an(n) {
-  return Object.keys(n);
+function ut(t) {
+  return Object.keys(t);
 }
-function Cn(n, t) {
-  return [n, t].reduce((r, i) => (an(i).forEach((c) => {
-    const o = r[c], e = i[c], u = On(o) && On(e);
-    r[c] = u ? Cn(o, e) : e;
+function Ct(t, n) {
+  return [t, n].reduce((r, s) => (ut(s).forEach((c) => {
+    const e = r[c], o = s[c], u = Pt(e) && Pt(o);
+    r[c] = u ? Ct(e, o) : o;
   }), r), {});
 }
-function Nn(n, t) {
-  return typeof t.MouseEvent < "u" && n instanceof t.MouseEvent;
+function bt(t, n) {
+  return typeof n.MouseEvent < "u" && t instanceof n.MouseEvent;
 }
-function Kn(n, t) {
+function $t(t, n) {
   const r = {
-    start: i,
+    start: s,
     center: c,
-    end: o
+    end: e
   };
-  function i() {
+  function s() {
     return 0;
   }
-  function c(s) {
-    return o(s) / 2;
+  function c(i) {
+    return e(i) / 2;
   }
-  function o(s) {
-    return t - s;
+  function e(i) {
+    return n - i;
   }
-  function e(s, a) {
-    return bn(n) ? r[n](s) : n(t, s, a);
+  function o(i, a) {
+    return yt(t) ? r[t](i) : t(n, i, a);
   }
   return {
-    measure: e
+    measure: o
   };
 }
-function ln() {
-  let n = [];
-  function t(c, o, e, u = {
+function ft() {
+  let t = [];
+  function n(c, e, o, u = {
     passive: !0
   }) {
-    let s;
+    let i;
     if ("addEventListener" in c)
-      c.addEventListener(o, e, u), s = () => c.removeEventListener(o, e, u);
+      c.addEventListener(e, o, u), i = () => c.removeEventListener(e, o, u);
     else {
       const a = c;
-      a.addListener(e), s = () => a.removeListener(e);
+      a.addListener(o), i = () => a.removeListener(o);
     }
-    return n.push(s), i;
+    return t.push(i), s;
   }
   function r() {
-    n = n.filter((c) => c());
+    t = t.filter((c) => c());
   }
-  const i = {
-    add: t,
+  const s = {
+    add: n,
     clear: r
   };
-  return i;
+  return s;
 }
-function Xn(n, t, r, i) {
-  const c = ln(), o = 1e3 / 60;
-  let e = null, u = 0, s = 0;
+function Qt(t, n, r, s) {
+  const c = ft(), e = 1e3 / 60;
+  let o = null, u = 0, i = 0;
   function a() {
-    c.add(n, "visibilitychange", () => {
-      n.hidden && m();
+    c.add(t, "visibilitychange", () => {
+      t.hidden && d();
     });
   }
   function S() {
-    b(), c.clear();
+    x(), c.clear();
   }
-  function l(h) {
-    if (!s)
+  function f(g) {
+    if (!i)
       return;
-    e || (e = h);
-    const f = h - e;
-    for (e = h, u += f; u >= o; )
-      r(), u -= o;
-    const g = F(u / o);
-    i(g), s && t.requestAnimationFrame(l);
+    o || (o = g);
+    const l = g - o;
+    for (o = g, u += l; u >= e; )
+      r(), u -= e;
+    const h = M(u / e);
+    s(h), i && n.requestAnimationFrame(f);
   }
-  function p() {
-    s || (s = t.requestAnimationFrame(l));
+  function m() {
+    i || (i = n.requestAnimationFrame(f));
   }
-  function b() {
-    t.cancelAnimationFrame(s), e = null, u = 0, s = 0;
+  function x() {
+    n.cancelAnimationFrame(i), o = null, u = 0, i = 0;
   }
-  function m() {
-    e = null, u = 0;
+  function d() {
+    o = null, u = 0;
   }
   return {
     init: a,
     destroy: S,
-    start: p,
-    stop: b,
+    start: m,
+    stop: x,
     update: r,
-    render: i
+    render: s
   };
 }
-function Yn(n, t) {
-  const r = n === "y" ? "y" : "x", i = n === "y" ? "x" : "y", c = u(), o = s();
-  function e(S) {
+function Kt(t, n) {
+  const r = n === "rtl", s = t === "y", c = s ? "y" : "x", e = s ? "x" : "y", o = !s && r ? -1 : 1, u = S(), i = f();
+  function a(d) {
     const {
-      width: l,
-      height: p
-    } = S;
-    return r === "x" ? l : p;
+      height: p,
+      width: g
+    } = d;
+    return s ? p : g;
   }
-  function u() {
-    return r === "y" ? "top" : t === "rtl" ? "right" : "left";
+  function S() {
+    return s ? "top" : r ? "right" : "left";
   }
-  function s() {
-    return r === "y" ? "bottom" : t === "rtl" ? "left" : "right";
+  function f() {
+    return s ? "bottom" : r ? "left" : "right";
+  }
+  function m(d) {
+    return d * o;
   }
   return {
-    scroll: r,
-    cross: i,
-    startEdge: c,
-    endEdge: o,
-    measureSize: e
+    scroll: c,
+    cross: e,
+    startEdge: u,
+    endEdge: i,
+    measureSize: a,
+    direction: m
   };
 }
-function nn(n = 0, t = 0) {
-  const r = F(n - t);
-  function i(a) {
-    return a < n;
+function nt(t = 0, n = 0) {
+  const r = M(t - n);
+  function s(a) {
+    return a < t;
   }
   function c(a) {
-    return a > t;
-  }
-  function o(a) {
-    return i(a) || c(a);
+    return a > n;
   }
   function e(a) {
-    return o(a) ? i(a) ? n : t : a;
+    return s(a) || c(a);
+  }
+  function o(a) {
+    return e(a) ? s(a) ? t : n : a;
   }
   function u(a) {
-    return r ? a - r * Math.ceil((a - t) / r) : a;
+    return r ? a - r * Math.ceil((a - n) / r) : a;
   }
   return {
     length: r,
-    max: t,
-    min: n,
-    constrain: e,
-    reachedAny: o,
+    max: n,
+    min: t,
+    constrain: o,
+    reachedAny: e,
     reachedMax: c,
-    reachedMin: i,
+    reachedMin: s,
     removeOffset: u
   };
 }
-function zn(n, t, r) {
+function wt(t, n, r) {
   const {
-    constrain: i
-  } = nn(0, n), c = n + 1;
-  let o = e(t);
-  function e(p) {
-    return r ? F((c + p) % c) : i(p);
+    constrain: s
+  } = nt(0, t), c = t + 1;
+  let e = o(n);
+  function o(m) {
+    return r ? M((c + m) % c) : s(m);
   }
   function u() {
-    return o;
+    return e;
   }
-  function s(p) {
-    return o = e(p), l;
+  function i(m) {
+    return e = o(m), f;
   }
-  function a(p) {
-    return S().set(u() + p);
+  function a(m) {
+    return S().set(u() + m);
   }
   function S() {
-    return zn(n, u(), r);
+    return wt(t, u(), r);
   }
-  const l = {
+  const f = {
     get: u,
-    set: s,
+    set: i,
     add: a,
     clone: S
   };
-  return l;
-}
-function _n(n) {
-  const t = n === "rtl" ? -1 : 1;
-  function r(c) {
-    return c * t;
-  }
-  return {
-    apply: r
-  };
+  return f;
 }
-function Jn(n, t, r, i, c, o, e, u, s, a, S, l, p, b, m, d, h, f, g, x) {
+function Xt(t, n, r, s, c, e, o, u, i, a, S, f, m, x, d, p, g, l, h) {
   const {
-    cross: L
-  } = n, I = ["INPUT", "SELECT", "TEXTAREA"], A = {
+    cross: b,
+    direction: L
+  } = t, v = ["INPUT", "SELECT", "TEXTAREA"], F = {
     passive: !1
-  }, O = ln(), E = ln(), v = nn(50, 225).constrain(m.measure(20)), D = {
+  }, E = ft(), I = ft(), D = nt(50, 225).constrain(x.measure(20)), A = {
     mouse: 300,
     touch: 400
-  }, M = {
+  }, O = {
     mouse: 500,
     touch: 600
-  }, C = d ? 43 : 25;
-  let H = !1, G = 0, q = 0, j = !1, Y = !1, _ = !1, U = !1;
-  function on(y) {
-    if (!x)
+  }, V = d ? 43 : 25;
+  let Y = !1, B = 0, U = 0, J = !1, $ = !1, _ = !1, Q = !1;
+  function Z(y) {
+    if (!h)
       return;
-    function T(N) {
-      (Ln(x) || x(y, N)) && sn(N);
+    function T(w) {
+      (Et(h) || h(y, w)) && z(w);
     }
-    const w = r;
-    O.add(w, "dragstart", (N) => N.preventDefault(), A).add(w, "touchmove", () => {
-    }, A).add(w, "touchend", () => {
-    }).add(w, "touchstart", T).add(w, "mousedown", T).add(w, "touchcancel", z).add(w, "contextmenu", z).add(w, "click", Q, !0);
+    const C = n;
+    E.add(C, "dragstart", (w) => w.preventDefault(), F).add(C, "touchmove", () => {
+    }, F).add(C, "touchend", () => {
+    }).add(C, "touchstart", T).add(C, "mousedown", T).add(C, "touchcancel", N).add(C, "contextmenu", N).add(C, "click", ot, !0);
   }
-  function R() {
-    O.clear(), E.clear();
+  function K() {
+    E.clear(), I.clear();
   }
-  function tn() {
-    const y = U ? i : r;
-    E.add(y, "touchmove", V, A).add(y, "touchend", z).add(y, "mousemove", V, A).add(y, "mouseup", z);
+  function et() {
+    const y = Q ? r : n;
+    I.add(y, "touchmove", R, F).add(y, "touchend", N).add(y, "mousemove", R, F).add(y, "mouseup", N);
   }
-  function en(y) {
+  function X(y) {
     const T = y.nodeName || "";
-    return I.includes(T);
+    return v.includes(T);
   }
-  function $() {
-    return (d ? M : D)[U ? "mouse" : "touch"];
+  function rt() {
+    return (d ? O : A)[Q ? "mouse" : "touch"];
   }
-  function rn(y, T) {
-    const w = p.add(In(y) * -1), N = l.byDistance(y, !d).distance;
-    return d || F(y) < v ? N : f && T ? N * 0.5 : l.byIndex(w.get(), 0).distance;
+  function st(y, T) {
+    const C = f.add(Lt(y) * -1), w = S.byDistance(y, !d).distance;
+    return d || M(y) < D ? w : g && T ? w * 0.5 : S.byIndex(C.get(), 0).distance;
   }
-  function sn(y) {
-    const T = Nn(y, c);
-    U = T, !(T && y.button !== 0) && (en(y.target) || (_ = d && T && !y.buttons && H, H = un(o.get(), u.get()) >= 2, j = !0, e.pointerDown(y), S.useFriction(0).useDuration(0), o.set(u), tn(), G = e.readPoint(y), q = e.readPoint(y, L), b.emit("pointerDown")));
+  function z(y) {
+    const T = bt(y, s);
+    Q = T, _ = d && T && !y.buttons && Y, Y = it(c.get(), o.get()) >= 2, !(T && y.button !== 0) && (X(y.target) || (J = !0, e.pointerDown(y), a.useFriction(0).useDuration(0), c.set(o), et(), B = e.readPoint(y), U = e.readPoint(y, b), m.emit("pointerDown")));
   }
-  function V(y) {
-    const T = e.readPoint(y), w = e.readPoint(y, L), N = un(T, G), J = un(w, q);
-    if (!Y && !U && (!y.cancelable || (Y = N > J, !Y)))
-      return z(y);
-    const K = e.pointerMove(y);
-    N > h && (_ = !0), S.useFriction(0.3).useDuration(1), s.start(), o.add(t.apply(K)), y.preventDefault();
+  function R(y) {
+    if (!bt(y, s) && y.touches.length >= 2)
+      return N(y);
+    const C = e.readPoint(y), w = e.readPoint(y, b), q = it(C, B), H = it(w, U);
+    if (!$ && !Q && (!y.cancelable || ($ = q > H, !$)))
+      return N(y);
+    const G = e.pointerMove(y);
+    q > p && (_ = !0), a.useFriction(0.3).useDuration(1), u.start(), c.add(L(G)), y.preventDefault();
   }
-  function z(y) {
-    const w = l.byDistance(0, !1).index !== p.get(), N = e.pointerUp(y) * $(), J = rn(t.apply(N), w), K = Qn(N, J), Z = C - 10 * K, X = g + K / 50;
-    Y = !1, j = !1, E.clear(), S.useDuration(Z).useFriction(X), a.distance(J, !d), U = !1, b.emit("pointerUp");
+  function N(y) {
+    const C = S.byDistance(0, !1).index !== f.get(), w = e.pointerUp(y) * rt(), q = st(L(w), C), H = Ut(w, q), G = V - 10 * H, W = l + H / 50;
+    $ = !1, J = !1, I.clear(), a.useDuration(G).useFriction(W), i.distance(q, !d), Q = !1, m.emit("pointerUp");
   }
-  function Q(y) {
-    _ && (y.stopPropagation(), y.preventDefault());
+  function ot(y) {
+    _ && (y.stopPropagation(), y.preventDefault(), _ = !1);
   }
   function k() {
-    return j;
+    return J;
   }
   return {
-    init: on,
+    init: Z,
     pointerDown: k,
-    destroy: R
+    destroy: K
   };
 }
-function Zn(n, t) {
-  let i, c;
-  function o(l) {
-    return l.timeStamp;
+function Yt(t, n) {
+  let s, c;
+  function e(f) {
+    return f.timeStamp;
   }
-  function e(l, p) {
-    const m = `client${(p || n.scroll) === "x" ? "X" : "Y"}`;
-    return (Nn(l, t) ? l : l.touches[0])[m];
+  function o(f, m) {
+    const d = `client${(m || t.scroll) === "x" ? "X" : "Y"}`;
+    return (bt(f, n) ? f : f.touches[0])[d];
   }
-  function u(l) {
-    return i = l, c = l, e(l);
+  function u(f) {
+    return s = f, c = f, o(f);
   }
-  function s(l) {
-    const p = e(l) - e(c), b = o(l) - o(i) > 170;
-    return c = l, b && (i = l), p;
+  function i(f) {
+    const m = o(f) - o(c), x = e(f) - e(s) > 170;
+    return c = f, x && (s = f), m;
   }
-  function a(l) {
-    if (!i || !c)
+  function a(f) {
+    if (!s || !c)
       return 0;
-    const p = e(c) - e(i), b = o(l) - o(i), m = o(l) - o(c) > 170, d = p / b;
-    return b && !m && F(d) > 0.1 ? d : 0;
+    const m = o(c) - o(s), x = e(f) - e(s), d = e(f) - e(c) > 170, p = m / x;
+    return x && !d && M(p) > 0.1 ? p : 0;
   }
   return {
     pointerDown: u,
-    pointerMove: s,
+    pointerMove: i,
     pointerUp: a,
-    readPoint: e
+    readPoint: o
   };
 }
-function Wn() {
-  function n(r) {
+function _t() {
+  function t(r) {
     const {
-      offsetTop: i,
+      offsetTop: s,
       offsetLeft: c,
-      offsetWidth: o,
-      offsetHeight: e
+      offsetWidth: e,
+      offsetHeight: o
     } = r;
     return {
-      top: i,
-      right: c + o,
-      bottom: i + e,
+      top: s,
+      right: c + e,
+      bottom: s + o,
       left: c,
-      width: o,
-      height: e
+      width: e,
+      height: o
     };
   }
   return {
-    measure: n
+    measure: t
   };
 }
-function nt(n) {
-  function t(i) {
-    return n * (i / 100);
+function Jt(t) {
+  function n(s) {
+    return t * (s / 100);
   }
   return {
-    measure: t
+    measure: n
   };
 }
-function tt(n, t, r, i, c, o, e) {
-  let u, s, a = [], S = !1;
-  function l(d) {
-    return c.measureSize(e.measure(d));
+function Zt(t, n, r, s, c, e, o) {
+  let u, i, a = [], S = !1;
+  function f(p) {
+    return c.measureSize(o.measure(p));
   }
-  function p(d) {
-    if (!o)
+  function m(p) {
+    if (!e)
       return;
-    s = l(n), a = i.map(l);
-    function h(g) {
-      for (const x of g) {
-        const L = x.target === n, I = i.indexOf(x.target), A = L ? s : a[I], O = l(L ? n : i[I]);
-        if (F(O - A) >= 0.5) {
+    i = f(t), a = s.map(f);
+    function g(h) {
+      for (const b of h) {
+        const L = b.target === t, v = s.indexOf(b.target), F = L ? i : a[v], E = f(L ? t : s[v]);
+        if (M(E - F) >= 0.5) {
           r.requestAnimationFrame(() => {
-            d.reInit(), t.emit("resize");
+            p.reInit(), n.emit("resize");
           });
           break;
         }
       }
     }
-    u = new ResizeObserver((g) => {
-      S || (Ln(o) || o(d, g)) && h(g);
-    }), [n].concat(i).forEach((g) => u.observe(g));
+    u = new ResizeObserver((h) => {
+      S || (Et(e) || e(p, h)) && g(h);
+    }), [t].concat(s).forEach((h) => u.observe(h));
   }
-  function b() {
+  function x() {
     u && u.disconnect(), S = !0;
   }
   return {
-    init: p,
-    destroy: b
+    init: m,
+    destroy: x
   };
 }
-function et(n, t, r, i, c) {
-  let o = 0, e = 0, u = i, s = c, a = n.get(), S = 0;
-  function l() {
-    const I = r.get() - n.get(), A = !u;
-    let O = 0;
-    return A ? (o = 0, n.set(r), O = I) : (o += I / u, o *= s, a += o, n.add(o), O = a - S), e = In(O), S = a, L;
+function Wt(t, n, r, s, c) {
+  let e = 0, o = 0, u = s, i = c, a = t.get(), S = 0;
+  function f() {
+    const v = r.get() - t.get(), F = !u;
+    let E = 0;
+    return F ? (e = 0, t.set(r), E = v) : (e += v / u, e *= i, a += e, t.add(e), E = a - S), o = Lt(E), S = a, L;
   }
-  function p() {
-    const I = r.get() - t.get();
-    return F(I) < 1e-3;
+  function m() {
+    const v = r.get() - n.get();
+    return M(v) < 1e-3;
   }
-  function b() {
+  function x() {
     return u;
   }
-  function m() {
-    return e;
-  }
   function d() {
     return o;
   }
-  function h() {
-    return g(i);
+  function p() {
+    return e;
   }
-  function f() {
-    return x(c);
+  function g() {
+    return h(s);
   }
-  function g(I) {
-    return u = I, L;
+  function l() {
+    return b(c);
   }
-  function x(I) {
-    return s = I, L;
+  function h(v) {
+    return u = v, L;
+  }
+  function b(v) {
+    return i = v, L;
   }
   const L = {
-    direction: m,
-    duration: b,
-    velocity: d,
-    seek: l,
-    settled: p,
-    useBaseFriction: f,
-    useBaseDuration: h,
-    useFriction: x,
-    useDuration: g
+    direction: d,
+    duration: x,
+    velocity: p,
+    seek: f,
+    settled: m,
+    useBaseFriction: l,
+    useBaseDuration: g,
+    useFriction: b,
+    useDuration: h
   };
   return L;
 }
-function ot(n, t, r, i, c) {
-  const o = c.measure(10), e = c.measure(50), u = nn(0.1, 0.99);
-  let s = !1;
+function tn(t, n, r, s, c) {
+  const e = c.measure(10), o = c.measure(50), u = nt(0.1, 0.99);
+  let i = !1;
   function a() {
-    return !(s || !n.reachedAny(r.get()) || !n.reachedAny(t.get()));
+    return !(i || !t.reachedAny(r.get()) || !t.reachedAny(n.get()));
   }
-  function S(b) {
+  function S(x) {
     if (!a())
       return;
-    const m = n.reachedMin(t.get()) ? "min" : "max", d = F(n[m] - t.get()), h = r.get() - t.get(), f = u.constrain(d / e);
-    r.subtract(h * f), !b && F(h) < o && (r.set(n.constrain(r.get())), i.useDuration(25).useBaseFriction());
+    const d = t.reachedMin(n.get()) ? "min" : "max", p = M(t[d] - n.get()), g = r.get() - n.get(), l = u.constrain(p / o);
+    r.subtract(g * l), !x && M(g) < e && (r.set(t.constrain(r.get())), s.useDuration(25).useBaseFriction());
   }
-  function l(b) {
-    s = !b;
+  function f(x) {
+    i = !x;
   }
   return {
     constrain: S,
-    toggleActive: l
+    toggleActive: f
   };
 }
-function rt(n, t, r, i, c) {
-  const o = nn(-t + n, 0), e = l(), u = S(), s = p();
-  function a(m, d) {
-    return un(m, d) < 1;
+function nn(t, n, r, s, c) {
+  const e = nt(-n + t, 0), o = f(), u = S(), i = m();
+  function a(d, p) {
+    return it(d, p) < 1;
   }
   function S() {
-    const m = e[0], d = B(e), h = e.lastIndexOf(m), f = e.indexOf(d) + 1;
-    return nn(h, f);
+    const d = o[0], p = j(o), g = o.lastIndexOf(d), l = o.indexOf(p) + 1;
+    return nt(g, l);
   }
-  function l() {
-    return r.map((m, d) => {
+  function f() {
+    return r.map((d, p) => {
       const {
-        min: h,
-        max: f
-      } = o, g = o.constrain(m), x = !d, L = vn(r, d);
-      return x ? f : L || a(h, g) ? h : a(f, g) ? f : g;
-    }).map((m) => parseFloat(m.toFixed(3)));
+        min: g,
+        max: l
+      } = e, h = e.constrain(d), b = !p, L = It(r, p);
+      return b ? l : L || a(g, h) ? g : a(l, h) ? l : h;
+    }).map((d) => parseFloat(d.toFixed(3)));
   }
-  function p() {
-    if (t <= n + c)
-      return [o.max];
-    if (i === "keepSnaps")
-      return e;
+  function m() {
+    if (n <= t + c)
+      return [e.max];
+    if (s === "keepSnaps")
+      return o;
     const {
-      min: m,
-      max: d
+      min: d,
+      max: p
     } = u;
-    return e.slice(m, d);
+    return o.slice(d, p);
   }
   return {
-    snapsContained: s,
+    snapsContained: i,
     scrollContainLimit: u
   };
 }
-function st(n, t, r) {
-  const i = t[0], c = r ? i - n : B(t);
+function en(t, n, r) {
+  const s = n[0], c = r ? s - t : j(n);
   return {
-    limit: nn(c, i)
+    limit: nt(c, s)
   };
 }
-function it(n, t, r, i) {
-  const o = t.min + 0.1, e = t.max + 0.1, {
+function on(t, n, r, s) {
+  const e = n.min + 0.1, o = n.max + 0.1, {
     reachedMin: u,
-    reachedMax: s
-  } = nn(o, e);
-  function a(p) {
-    return p === 1 ? s(r.get()) : p === -1 ? u(r.get()) : !1;
+    reachedMax: i
+  } = nt(e, o);
+  function a(m) {
+    return m === 1 ? i(r.get()) : m === -1 ? u(r.get()) : !1;
   }
-  function S(p) {
-    if (!a(p))
+  function S(m) {
+    if (!a(m))
       return;
-    const b = n * (p * -1);
-    i.forEach((m) => m.add(b));
+    const x = t * (m * -1);
+    s.forEach((d) => d.add(x));
   }
   return {
     loop: S
   };
 }
-function ct(n) {
+function rn(t) {
   const {
-    max: t,
+    max: n,
     length: r
-  } = n;
-  function i(o) {
-    const e = o - t;
-    return r ? e / -r : 0;
+  } = t;
+  function s(e) {
+    const o = e - n;
+    return r ? o / -r : 0;
   }
   return {
-    get: i
+    get: s
   };
 }
-function ut(n, t, r, i, c) {
+function sn(t, n, r, s, c) {
   const {
-    startEdge: o,
-    endEdge: e
-  } = n, {
+    startEdge: e,
+    endEdge: o
+  } = t, {
     groupSlides: u
-  } = c, s = l().map(t.measure), a = p(), S = b();
-  function l() {
-    return u(i).map((d) => B(d)[e] - d[0][o]).map(F);
+  } = c, i = f().map(n.measure), a = m(), S = x();
+  function f() {
+    return u(s).map((p) => j(p)[o] - p[0][e]).map(M);
   }
-  function p() {
-    return i.map((d) => r[o] - d[o]).map((d) => -F(d));
+  function m() {
+    return s.map((p) => r[e] - p[e]).map((p) => -M(p));
   }
-  function b() {
-    return u(a).map((d) => d[0]).map((d, h) => d + s[h]);
+  function x() {
+    return u(a).map((p) => p[0]).map((p, g) => p + i[g]);
   }
   return {
     snaps: a,
     snapsAligned: S
   };
 }
-function ft(n, t, r, i, c, o) {
+function cn(t, n, r, s, c, e) {
   const {
-    groupSlides: e
+    groupSlides: o
   } = c, {
     min: u,
-    max: s
-  } = i, a = S();
+    max: i
+  } = s, a = S();
   function S() {
-    const p = e(o), b = !n || t === "keepSnaps";
-    return r.length === 1 ? [o] : b ? p : p.slice(u, s).map((m, d, h) => {
-      const f = !d, g = vn(h, d);
-      if (f) {
-        const x = B(h[0]) + 1;
-        return wn(x);
+    const m = o(e), x = !t || n === "keepSnaps";
+    return r.length === 1 ? [e] : x ? m : m.slice(u, i).map((d, p, g) => {
+      const l = !p, h = It(g, p);
+      if (l) {
+        const b = j(g[0]) + 1;
+        return Ot(b);
       }
-      if (g) {
-        const x = dn(o) - B(h)[0] + 1;
-        return wn(x, B(h)[0]);
+      if (h) {
+        const b = at(e) - j(g)[0] + 1;
+        return Ot(b, j(g)[0]);
       }
-      return m;
+      return d;
     });
   }
   return {
     slideRegistry: a
   };
 }
-function at(n, t, r, i, c) {
+function un(t, n, r, s, c) {
   const {
-    reachedAny: o,
-    removeOffset: e,
+    reachedAny: e,
+    removeOffset: o,
     constrain: u
-  } = i;
-  function s(m) {
-    return m.concat().sort((d, h) => F(d) - F(h))[0];
-  }
-  function a(m) {
-    const d = n ? e(m) : u(m), h = t.map((g) => g - d).map((g) => S(g, 0)).map((g, x) => ({
-      diff: g,
-      index: x
-    })).sort((g, x) => F(g.diff) - F(x.diff)), {
-      index: f
-    } = h[0];
+  } = s;
+  function i(d) {
+    return d.concat().sort((p, g) => M(p) - M(g))[0];
+  }
+  function a(d) {
+    const p = t ? o(d) : u(d), g = n.map((h, b) => ({
+      diff: S(h - p, 0),
+      index: b
+    })).sort((h, b) => M(h.diff) - M(b.diff)), {
+      index: l
+    } = g[0];
     return {
-      index: f,
-      distance: d
+      index: l,
+      distance: p
     };
   }
-  function S(m, d) {
-    const h = [m, m + r, m - r];
-    if (!n)
-      return h[0];
-    if (!d)
-      return s(h);
-    const f = h.filter((g) => In(g) === d);
-    return f.length ? s(f) : B(h) - r;
-  }
-  function l(m, d) {
-    const h = t[m] - c.get(), f = S(h, d);
+  function S(d, p) {
+    const g = [d, d + r, d - r];
+    if (!t)
+      return g[0];
+    if (!p)
+      return i(g);
+    const l = g.filter((h) => Lt(h) === p);
+    return l.length ? i(l) : j(g) - r;
+  }
+  function f(d, p) {
+    const g = n[d] - c.get(), l = S(g, p);
     return {
-      index: m,
-      distance: f
+      index: d,
+      distance: l
     };
   }
-  function p(m, d) {
-    const h = c.get() + m, {
-      index: f,
-      distance: g
-    } = a(h), x = !n && o(h);
-    if (!d || x)
+  function m(d, p) {
+    const g = c.get() + d, {
+      index: l,
+      distance: h
+    } = a(g), b = !t && e(g);
+    if (!p || b)
       return {
-        index: f,
-        distance: m
+        index: l,
+        distance: d
       };
-    const L = t[f] - g, I = m + S(L, 0);
+    const L = n[l] - h, v = d + S(L, 0);
     return {
-      index: f,
-      distance: I
+      index: l,
+      distance: v
     };
   }
   return {
-    byDistance: p,
-    byIndex: l,
+    byDistance: m,
+    byIndex: f,
     shortcut: S
   };
 }
-function lt(n, t, r, i, c, o, e) {
-  function u(l) {
-    const p = l.distance, b = l.index !== t.get();
-    o.add(p), p && (i.duration() ? n.start() : (n.update(), n.render(1), n.update())), b && (r.set(t.get()), t.set(l.index), e.emit("select"));
+function fn(t, n, r, s, c, e, o) {
+  function u(f) {
+    const m = f.distance, x = f.index !== n.get();
+    e.add(m), m && (s.duration() ? t.start() : (t.update(), t.render(1), t.update())), x && (r.set(n.get()), n.set(f.index), o.emit("select"));
   }
-  function s(l, p) {
-    const b = c.byDistance(l, p);
-    u(b);
+  function i(f, m) {
+    const x = c.byDistance(f, m);
+    u(x);
   }
-  function a(l, p) {
-    const b = t.clone().set(l), m = c.byIndex(b.get(), p);
-    u(m);
+  function a(f, m) {
+    const x = n.clone().set(f), d = c.byIndex(x.get(), m);
+    u(d);
   }
   return {
-    distance: s,
+    distance: i,
     index: a
   };
 }
-function dt(n, t, r, i, c, o) {
-  let e = 0;
+function an(t, n, r, s, c, e) {
+  let o = 0;
   function u() {
-    o.add(document, "keydown", s, !1), t.forEach(a);
+    e.add(document, "keydown", i, !1), n.forEach(a);
   }
-  function s(l) {
-    l.code === "Tab" && (e = (/* @__PURE__ */ new Date()).getTime());
+  function i(f) {
+    f.code === "Tab" && (o = (/* @__PURE__ */ new Date()).getTime());
   }
-  function a(l) {
-    const p = () => {
-      if ((/* @__PURE__ */ new Date()).getTime() - e > 10)
+  function a(f) {
+    const m = () => {
+      if ((/* @__PURE__ */ new Date()).getTime() - o > 10)
         return;
-      n.scrollLeft = 0;
-      const d = t.indexOf(l), h = r.findIndex((f) => f.includes(d));
-      En(h) && (c.useDuration(0), i.index(h, 0));
+      t.scrollLeft = 0;
+      const p = n.indexOf(f), g = r.findIndex((l) => l.includes(p));
+      xt(g) && (c.useDuration(0), s.index(g, 0));
     };
-    o.add(l, "focus", p, {
+    e.add(f, "focus", m, {
       passive: !0,
       capture: !0
     });
@@ -668,360 +666,360 @@ function dt(n, t, r, i, c, o) {
     init: u
   };
 }
-function mn(n) {
-  let t = n;
+function dt(t) {
+  let n = t;
   function r() {
-    return t;
+    return n;
   }
-  function i(s) {
-    t = e(s);
+  function s(i) {
+    n = o(i);
   }
-  function c(s) {
-    t += e(s);
+  function c(i) {
+    n += o(i);
   }
-  function o(s) {
-    t -= e(s);
+  function e(i) {
+    n -= o(i);
   }
-  function e(s) {
-    return En(s) ? s : s.get();
+  function o(i) {
+    return xt(i) ? i : i.get();
   }
   return {
     get: r,
-    set: i,
+    set: s,
     add: c,
-    subtract: o
+    subtract: e
   };
 }
-function Vn(n, t, r) {
-  const i = n.scroll === "x" ? e : u, c = r.style;
-  let o = !1;
-  function e(p) {
-    return `translate3d(${p}px,0px,0px)`;
+function Nt(t, n) {
+  const r = t.scroll === "x" ? e : o, s = n.style;
+  let c = !1;
+  function e(f) {
+    return `translate3d(${f}px,0px,0px)`;
   }
-  function u(p) {
-    return `translate3d(0px,${p}px,0px)`;
+  function o(f) {
+    return `translate3d(0px,${f}px,0px)`;
   }
-  function s(p) {
-    o || (c.transform = i(t.apply(p)));
+  function u(f) {
+    c || (s.transform = r(t.direction(f)));
   }
-  function a(p) {
-    o = !p;
+  function i(f) {
+    c = !f;
   }
-  function S() {
-    o || (c.transform = "", r.getAttribute("style") || r.removeAttribute("style"));
+  function a() {
+    c || (s.transform = "", n.getAttribute("style") || n.removeAttribute("style"));
   }
   return {
-    clear: S,
-    to: s,
-    toggleActive: a
+    clear: a,
+    to: u,
+    toggleActive: i
   };
 }
-function pt(n, t, r, i, c, o, e, u, s, a) {
-  const l = fn(o), p = fn(o).reverse(), b = g().concat(x());
-  function m(E, v) {
-    return E.reduce((D, M) => D - o[M], v);
-  }
-  function d(E, v) {
-    return E.reduce((D, M) => m(D, v) > 0 ? D.concat([M]) : D, []);
-  }
-  function h(E) {
-    return e.map((v, D) => ({
-      start: v - c[D] + 0.5 + E,
-      end: v + r - 0.5 + E
+function ln(t, n, r, s, c, e, o, u, i) {
+  const S = ct(c), f = ct(c).reverse(), m = l().concat(h());
+  function x(E, I) {
+    return E.reduce((D, A) => D - c[A], I);
+  }
+  function d(E, I) {
+    return E.reduce((D, A) => x(D, I) > 0 ? D.concat([A]) : D, []);
+  }
+  function p(E) {
+    return e.map((I, D) => ({
+      start: I - s[D] + 0.5 + E,
+      end: I + n - 0.5 + E
     }));
   }
-  function f(E, v, D) {
-    const M = h(v);
-    return E.map((C) => {
-      const H = D ? 0 : -i, G = D ? i : 0, q = D ? "end" : "start", j = M[C][q];
+  function g(E, I, D) {
+    const A = p(I);
+    return E.map((O) => {
+      const V = D ? 0 : -r, Y = D ? r : 0, B = D ? "end" : "start", U = A[O][B];
       return {
-        index: C,
-        loopPoint: j,
-        slideLocation: mn(-1),
-        translate: Vn(n, t, a[C]),
-        target: () => s.get() > j ? H : G
+        index: O,
+        loopPoint: U,
+        slideLocation: dt(-1),
+        translate: Nt(t, i[O]),
+        target: () => u.get() > U ? V : Y
       };
     });
   }
-  function g() {
-    const E = u[0], v = d(p, E);
-    return f(v, i, !1);
+  function l() {
+    const E = o[0], I = d(f, E);
+    return g(I, r, !1);
   }
-  function x() {
-    const E = r - u[0] - 1, v = d(l, E);
-    return f(v, -i, !0);
+  function h() {
+    const E = n - o[0] - 1, I = d(S, E);
+    return g(I, -r, !0);
   }
-  function L() {
-    return b.every(({
+  function b() {
+    return m.every(({
       index: E
     }) => {
-      const v = l.filter((D) => D !== E);
-      return m(v, r) <= 0.1;
+      const I = S.filter((D) => D !== E);
+      return x(I, n) <= 0.1;
     });
   }
-  function I() {
-    b.forEach((E) => {
+  function L() {
+    m.forEach((E) => {
       const {
-        target: v,
+        target: I,
         translate: D,
-        slideLocation: M
-      } = E, C = v();
-      C !== M.get() && (D.to(C), M.set(C));
+        slideLocation: A
+      } = E, O = I();
+      O !== A.get() && (D.to(O), A.set(O));
     });
   }
-  function A() {
-    b.forEach((E) => E.translate.clear());
+  function v() {
+    m.forEach((E) => E.translate.clear());
   }
   return {
-    canLoop: L,
-    clear: A,
-    loop: I,
-    loopPoints: b
+    canLoop: b,
+    clear: v,
+    loop: L,
+    loopPoints: m
   };
 }
-function mt(n, t, r) {
-  let i, c = !1;
-  function o(s) {
+function dn(t, n, r) {
+  let s, c = !1;
+  function e(i) {
     if (!r)
       return;
     function a(S) {
-      for (const l of S)
-        if (l.type === "childList") {
-          s.reInit(), t.emit("slidesChanged");
+      for (const f of S)
+        if (f.type === "childList") {
+          i.reInit(), n.emit("slidesChanged");
           break;
         }
     }
-    i = new MutationObserver((S) => {
-      c || (Ln(r) || r(s, S)) && a(S);
-    }), i.observe(n, {
+    s = new MutationObserver((S) => {
+      c || (Et(r) || r(i, S)) && a(S);
+    }), s.observe(t, {
       childList: !0
     });
   }
-  function e() {
-    i && i.disconnect(), c = !0;
+  function o() {
+    s && s.disconnect(), c = !0;
   }
   return {
-    init: o,
-    destroy: e
+    init: e,
+    destroy: o
   };
 }
-function gt(n, t, r, i) {
+function pn(t, n, r, s) {
   const c = {};
-  let o = null, e = null, u, s = !1;
+  let e = null, o = null, u, i = !1;
   function a() {
-    u = new IntersectionObserver((m) => {
-      s || (m.forEach((d) => {
-        const h = t.indexOf(d.target);
-        c[h] = d;
-      }), o = null, e = null, r.emit("slidesInView"));
+    u = new IntersectionObserver((d) => {
+      i || (d.forEach((p) => {
+        const g = n.indexOf(p.target);
+        c[g] = p;
+      }), e = null, o = null, r.emit("slidesInView"));
     }, {
-      root: n.parentElement,
-      threshold: i
-    }), t.forEach((m) => u.observe(m));
+      root: t.parentElement,
+      threshold: s
+    }), n.forEach((d) => u.observe(d));
   }
   function S() {
-    u && u.disconnect(), s = !0;
-  }
-  function l(m) {
-    return an(c).reduce((d, h) => {
-      const f = parseInt(h), {
-        isIntersecting: g
-      } = c[f];
-      return (m && g || !m && !g) && d.push(f), d;
+    u && u.disconnect(), i = !0;
+  }
+  function f(d) {
+    return ut(c).reduce((p, g) => {
+      const l = parseInt(g), {
+        isIntersecting: h
+      } = c[l];
+      return (d && h || !d && !h) && p.push(l), p;
     }, []);
   }
-  function p(m = !0) {
-    if (m && o)
-      return o;
-    if (!m && e)
+  function m(d = !0) {
+    if (d && e)
       return e;
-    const d = l(m);
-    return m && (o = d), m || (e = d), d;
+    if (!d && o)
+      return o;
+    const p = f(d);
+    return d && (e = p), d || (o = p), p;
   }
   return {
     init: a,
     destroy: S,
-    get: p
+    get: m
   };
 }
-function ht(n, t, r, i, c, o) {
+function mn(t, n, r, s, c, e) {
   const {
-    measureSize: e,
+    measureSize: o,
     startEdge: u,
-    endEdge: s
-  } = n, a = r[0] && c, S = m(), l = d(), p = r.map(e), b = h();
-  function m() {
+    endEdge: i
+  } = t, a = r[0] && c, S = d(), f = p(), m = r.map(o), x = g();
+  function d() {
     if (!a)
       return 0;
-    const g = r[0];
-    return F(t[u] - g[u]);
+    const h = r[0];
+    return M(n[u] - h[u]);
   }
-  function d() {
+  function p() {
     if (!a)
       return 0;
-    const g = o.getComputedStyle(B(i));
-    return parseFloat(g.getPropertyValue(`margin-${s}`));
+    const h = e.getComputedStyle(j(s));
+    return parseFloat(h.getPropertyValue(`margin-${i}`));
   }
-  function h() {
-    return r.map((g, x, L) => {
-      const I = !x, A = vn(L, x);
-      return I ? p[x] + S : A ? p[x] + l : L[x + 1][u] - g[u];
-    }).map(F);
+  function g() {
+    return r.map((h, b, L) => {
+      const v = !b, F = It(L, b);
+      return v ? m[b] + S : F ? m[b] + f : L[b + 1][u] - h[u];
+    }).map(M);
   }
   return {
-    slideSizes: p,
-    slideSizesWithGaps: b,
+    slideSizes: m,
+    slideSizesWithGaps: x,
     startGap: S,
-    endGap: l
+    endGap: f
   };
 }
-function St(n, t, r, i, c, o, e, u, s, a) {
+function gn(t, n, r, s, c, e, o, u, i) {
   const {
-    startEdge: S,
-    endEdge: l
-  } = n, p = En(i);
-  function b(f, g) {
-    return fn(f).filter((x) => x % g === 0).map((x) => f.slice(x, x + g));
-  }
-  function m(f) {
-    return f.length ? fn(f).reduce((g, x) => {
-      const L = B(g) || 0, I = L === 0, A = x === dn(f), O = o[S] - e[L][S], E = o[S] - e[x][l], v = !c && I ? t.apply(u) : 0, D = !c && A ? t.apply(s) : 0;
-      return F(E - D - (O + v)) > r + a && g.push(x), A && g.push(f.length), g;
-    }, []).map((g, x, L) => {
-      const I = Math.max(L[x - 1] || 0);
-      return f.slice(I, g);
+    startEdge: a,
+    endEdge: S,
+    direction: f
+  } = t, m = xt(r);
+  function x(l, h) {
+    return ct(l).filter((b) => b % h === 0).map((b) => l.slice(b, b + h));
+  }
+  function d(l) {
+    return l.length ? ct(l).reduce((h, b, L) => {
+      const v = j(h) || 0, F = v === 0, E = b === at(l), I = c[a] - e[v][a], D = c[a] - e[b][S], A = !s && F ? f(o) : 0, O = !s && E ? f(u) : 0, V = M(D - O - (I + A));
+      return L && V > n + i && h.push(b), E && h.push(l.length), h;
+    }, []).map((h, b, L) => {
+      const v = Math.max(L[b - 1] || 0);
+      return l.slice(v, h);
     }) : [];
   }
-  function d(f) {
-    return p ? b(f, i) : m(f);
+  function p(l) {
+    return m ? x(l, r) : d(l);
   }
   return {
-    groupSlides: d
+    groupSlides: p
   };
 }
-function yt(n, t, r, i, c, o, e) {
+function hn(t, n, r, s, c, e, o) {
   const {
     align: u,
-    axis: s,
+    axis: i,
     direction: a,
     startIndex: S,
-    loop: l,
-    duration: p,
-    dragFree: b,
-    dragThreshold: m,
-    inViewThreshold: d,
-    slidesToScroll: h,
-    skipSnaps: f,
-    containScroll: g,
-    watchResize: x,
+    loop: f,
+    duration: m,
+    dragFree: x,
+    dragThreshold: d,
+    inViewThreshold: p,
+    slidesToScroll: g,
+    skipSnaps: l,
+    containScroll: h,
+    watchResize: b,
     watchSlides: L,
-    watchDrag: I
-  } = o, A = 2, O = Wn(), E = O.measure(t), v = r.map(O.measure), D = _n(a), M = Yn(s, a), C = M.measureSize(E), H = nt(C), G = Kn(u, C), q = !l && !!g, j = l || !!g, {
-    slideSizes: Y,
-    slideSizesWithGaps: _,
-    startGap: U,
-    endGap: on
-  } = ht(M, E, v, r, j, c), R = St(M, D, C, h, l, E, v, U, on, A), {
-    snaps: tn,
-    snapsAligned: en
-  } = ut(M, G, E, v, R), $ = -B(tn) + B(_), {
-    snapsContained: rn,
-    scrollContainLimit: sn
-  } = rt(C, $, en, g, A), V = q ? rn : en, {
-    limit: z
-  } = st($, V, l), Q = zn(dn(V), S, l), k = Q.clone(), P = fn(r), y = ({
-    dragHandler: W,
-    scrollBody: yn,
-    scrollBounds: xn,
+    watchDrag: v
+  } = e, F = 2, E = _t(), I = E.measure(n), D = r.map(E.measure), A = Kt(i, a), O = A.measureSize(I), V = Jt(O), Y = $t(u, O), B = !f && !!h, U = f || !!h, {
+    slideSizes: J,
+    slideSizesWithGaps: $,
+    startGap: _,
+    endGap: Q
+  } = mn(A, I, D, r, U, c), Z = gn(A, O, g, f, I, D, _, Q, F), {
+    snaps: K,
+    snapsAligned: et
+  } = sn(A, Y, I, D, Z), X = -j(K) + j($), {
+    snapsContained: rt,
+    scrollContainLimit: st
+  } = nn(O, X, et, h, F), z = B ? rt : et, {
+    limit: R
+  } = en(X, z, f), N = wt(at(z), S, f), ot = N.clone(), k = ct(r), P = ({
+    dragHandler: tt,
+    scrollBody: ht,
+    scrollBounds: St,
     options: {
-      loop: pn
+      loop: lt
     }
   }) => {
-    pn || xn.constrain(W.pointerDown()), yn.seek();
-  }, T = ({
-    scrollBody: W,
-    translate: yn,
-    location: xn,
-    offsetLocation: pn,
-    scrollLooper: Gn,
-    slideLooper: jn,
-    dragHandler: Rn,
-    animation: qn,
-    eventHandler: Mn,
+    lt || St.constrain(tt.pointerDown()), ht.seek();
+  }, y = ({
+    scrollBody: tt,
+    translate: ht,
+    location: St,
+    offsetLocation: lt,
+    scrollLooper: kt,
+    slideLooper: Ht,
+    dragHandler: Gt,
+    animation: jt,
+    eventHandler: At,
     options: {
-      loop: Un
+      loop: Rt
     }
-  }, $n) => {
-    const Fn = W.velocity(), Pn = W.settled();
-    Pn && !Rn.pointerDown() && (qn.stop(), Mn.emit("settle")), Pn || Mn.emit("scroll"), pn.set(xn.get() - Fn + Fn * $n), Un && (Gn.loop(W.direction()), jn.loop()), yn.to(pn.get());
-  }, w = Xn(i, c, () => y(Sn), (W) => T(Sn, W)), N = 0.68, J = V[Q.get()], K = mn(J), Z = mn(J), X = mn(J), cn = et(K, Z, X, p, N), gn = at(l, V, $, z, X), hn = lt(w, Q, k, cn, gn, X, e), Dn = ct(z), Tn = ln(), Bn = gt(t, r, e, d), {
-    slideRegistry: An
-  } = ft(q, g, V, sn, R, P), Hn = dt(n, r, An, hn, cn, Tn), Sn = {
-    ownerDocument: i,
+  }, qt) => {
+    const Mt = tt.velocity(), Ft = tt.settled();
+    Ft && !Gt.pointerDown() && (jt.stop(), At.emit("settle")), Ft || At.emit("scroll"), lt.set(St.get() - Mt + Mt * qt), Rt && (kt.loop(tt.direction()), Ht.loop()), ht.to(lt.get());
+  }, T = Qt(s, c, () => P(gt), (tt) => y(gt, tt)), C = 0.68, w = z[N.get()], q = dt(w), H = dt(w), G = dt(w), W = Wt(q, H, G, m, C), pt = un(f, z, X, R, G), mt = fn(T, N, ot, W, pt, G, o), vt = rn(R), Tt = ft(), zt = pn(n, r, o, p), {
+    slideRegistry: Dt
+  } = cn(B, h, z, st, Z, k), Bt = an(t, r, Dt, mt, W, Tt), gt = {
+    ownerDocument: s,
     ownerWindow: c,
-    eventHandler: e,
-    containerRect: E,
-    slideRects: v,
-    animation: w,
-    axis: M,
-    direction: D,
-    dragHandler: Jn(M, D, n, i, c, X, Zn(M, c), K, w, hn, cn, gn, Q, e, H, b, m, f, N, I),
-    eventStore: Tn,
-    percentOfView: H,
-    index: Q,
-    indexPrevious: k,
-    limit: z,
-    location: K,
-    offsetLocation: Z,
-    options: o,
-    resizeHandler: tt(t, e, c, r, M, x, O),
-    scrollBody: cn,
-    scrollBounds: ot(z, Z, X, cn, H),
-    scrollLooper: it($, z, Z, [K, Z, X]),
-    scrollProgress: Dn,
-    scrollSnapList: V.map(Dn.get),
-    scrollSnaps: V,
-    scrollTarget: gn,
-    scrollTo: hn,
-    slideLooper: pt(M, D, C, $, Y, _, tn, V, Z, r),
-    slideFocus: Hn,
-    slidesHandler: mt(t, e, L),
-    slidesInView: Bn,
-    slideIndexes: P,
-    slideRegistry: An,
-    slidesToScroll: R,
-    target: X,
-    translate: Vn(M, D, t)
+    eventHandler: o,
+    containerRect: I,
+    slideRects: D,
+    animation: T,
+    axis: A,
+    dragHandler: Xt(A, t, s, c, G, Yt(A, c), q, T, mt, W, pt, N, o, V, x, d, l, C, v),
+    eventStore: Tt,
+    percentOfView: V,
+    index: N,
+    indexPrevious: ot,
+    limit: R,
+    location: q,
+    offsetLocation: H,
+    options: e,
+    resizeHandler: Zt(n, o, c, r, A, b, E),
+    scrollBody: W,
+    scrollBounds: tn(R, H, G, W, V),
+    scrollLooper: on(X, R, H, [q, H, G]),
+    scrollProgress: vt,
+    scrollSnapList: z.map(vt.get),
+    scrollSnaps: z,
+    scrollTarget: pt,
+    scrollTo: mt,
+    slideLooper: ln(A, O, X, J, $, K, z, H, r),
+    slideFocus: Bt,
+    slidesHandler: dn(n, o, L),
+    slidesInView: zt,
+    slideIndexes: k,
+    slideRegistry: Dt,
+    slidesToScroll: Z,
+    target: G,
+    translate: Nt(A, n)
   };
-  return Sn;
+  return gt;
 }
-function xt() {
-  const n = {};
-  let t;
-  function r(s) {
-    t = s;
+function Sn() {
+  const t = {};
+  let n;
+  function r(i) {
+    n = i;
   }
-  function i(s) {
-    return n[s] || [];
+  function s(i) {
+    return t[i] || [];
   }
-  function c(s) {
-    return i(s).forEach((a) => a(t, s)), u;
+  function c(i) {
+    return s(i).forEach((a) => a(n, i)), u;
   }
-  function o(s, a) {
-    return n[s] = i(s).concat([a]), u;
+  function e(i, a) {
+    return t[i] = s(i).concat([a]), u;
   }
-  function e(s, a) {
-    return n[s] = i(s).filter((S) => S !== a), u;
+  function o(i, a) {
+    return t[i] = s(i).filter((S) => S !== a), u;
   }
   const u = {
     init: r,
     emit: c,
-    off: e,
-    on: o
+    off: o,
+    on: e
   };
   return u;
 }
-const bt = {
+const yn = {
   align: "center",
   axis: "x",
   container: null,
@@ -1042,163 +1040,163 @@ const bt = {
   watchResize: !0,
   watchSlides: !0
 };
-function Et(n) {
-  function t(o, e) {
-    return Cn(o, e || {});
+function bn(t) {
+  function n(e, o) {
+    return Ct(e, o || {});
   }
-  function r(o) {
-    const e = o.breakpoints || {}, u = an(e).filter((s) => n.matchMedia(s).matches).map((s) => e[s]).reduce((s, a) => t(s, a), {});
-    return t(o, u);
+  function r(e) {
+    const o = e.breakpoints || {}, u = ut(o).filter((i) => t.matchMedia(i).matches).map((i) => o[i]).reduce((i, a) => n(i, a), {});
+    return n(e, u);
   }
-  function i(o) {
-    return o.map((e) => an(e.breakpoints || {})).reduce((e, u) => e.concat(u), []).map(n.matchMedia);
+  function s(e) {
+    return e.map((o) => ut(o.breakpoints || {})).reduce((o, u) => o.concat(u), []).map(t.matchMedia);
   }
   return {
-    mergeOptions: t,
+    mergeOptions: n,
     optionsAtMedia: r,
-    optionsMediaQueries: i
+    optionsMediaQueries: s
   };
 }
-function Lt(n) {
-  let t = [];
-  function r(o, e) {
-    return t = e.filter(({
+function xn(t) {
+  let n = [];
+  function r(e, o) {
+    return n = o.filter(({
       options: u
-    }) => n.optionsAtMedia(u).active !== !1), t.forEach((u) => u.init(o, n)), e.reduce((u, s) => Object.assign(u, {
-      [s.name]: s
+    }) => t.optionsAtMedia(u).active !== !1), n.forEach((u) => u.init(e, t)), o.reduce((u, i) => Object.assign(u, {
+      [i.name]: i
     }), {});
   }
-  function i() {
-    t = t.filter((o) => o.destroy());
+  function s() {
+    n = n.filter((e) => e.destroy());
   }
   return {
     init: r,
-    destroy: i
+    destroy: s
   };
 }
-function kn(n, t, r) {
-  const i = n.ownerDocument, c = i.defaultView, o = Et(c), e = Lt(o), u = ln(), s = xt(), {
+function Vt(t, n, r) {
+  const s = t.ownerDocument, c = s.defaultView, e = bn(c), o = xn(e), u = ft(), i = Sn(), {
     mergeOptions: a,
     optionsAtMedia: S,
-    optionsMediaQueries: l
-  } = o, {
-    on: p,
-    off: b,
-    emit: m
-  } = s, d = M;
-  let h = !1, f, g = a(bt, kn.globalOptions), x = a(g), L = [], I, A, O;
-  function E() {
+    optionsMediaQueries: f
+  } = e, {
+    on: m,
+    off: x,
+    emit: d
+  } = i, p = O;
+  let g = !1, l, h = a(yn, Vt.globalOptions), b = a(h), L = [], v, F, E;
+  function I() {
     const {
       container: P,
       slides: y
-    } = x;
-    A = (bn(P) ? n.querySelector(P) : P) || n.children[0];
-    const w = bn(y) ? A.querySelectorAll(y) : y;
-    O = [].slice.call(w || A.children);
+    } = b;
+    F = (yt(P) ? t.querySelector(P) : P) || t.children[0];
+    const C = yt(y) ? F.querySelectorAll(y) : y;
+    E = [].slice.call(C || F.children);
   }
-  function v(P) {
-    const y = yt(n, A, O, i, c, P, s);
+  function D(P) {
+    const y = hn(t, F, E, s, c, P, i);
     if (P.loop && !y.slideLooper.canLoop()) {
       const T = Object.assign({}, P, {
         loop: !1
       });
-      return v(T);
+      return D(T);
     }
     return y;
   }
-  function D(P, y) {
-    h || (g = a(g, P), x = S(g), L = y || L, E(), f = v(x), l([g, ...L.map(({
+  function A(P, y) {
+    g || (h = a(h, P), b = S(h), L = y || L, I(), l = D(b), f([h, ...L.map(({
       options: T
-    }) => T)]).forEach((T) => u.add(T, "change", M)), x.active && (f.translate.to(f.location.get()), f.animation.init(), f.slidesInView.init(), f.slideFocus.init(), f.eventHandler.init(k), f.resizeHandler.init(k), f.slidesHandler.init(k), f.options.loop && f.slideLooper.loop(), A.offsetParent && O.length && f.dragHandler.init(k), I = e.init(k, L)));
+    }) => T)]).forEach((T) => u.add(T, "change", O)), b.active && (l.translate.to(l.location.get()), l.animation.init(), l.slidesInView.init(), l.slideFocus.init(), l.eventHandler.init(k), l.resizeHandler.init(k), l.slidesHandler.init(k), l.options.loop && l.slideLooper.loop(), F.offsetParent && E.length && l.dragHandler.init(k), v = o.init(k, L)));
   }
-  function M(P, y) {
-    const T = R();
-    C(), D(a({
+  function O(P, y) {
+    const T = K();
+    V(), A(a({
       startIndex: T
-    }, P), y), s.emit("reInit");
+    }, P), y), i.emit("reInit");
   }
-  function C() {
-    f.dragHandler.destroy(), f.eventStore.clear(), f.translate.clear(), f.slideLooper.clear(), f.resizeHandler.destroy(), f.slidesHandler.destroy(), f.slidesInView.destroy(), f.animation.destroy(), e.destroy(), u.clear();
+  function V() {
+    l.dragHandler.destroy(), l.eventStore.clear(), l.translate.clear(), l.slideLooper.clear(), l.resizeHandler.destroy(), l.slidesHandler.destroy(), l.slidesInView.destroy(), l.animation.destroy(), o.destroy(), u.clear();
   }
-  function H() {
-    h || (h = !0, u.clear(), C(), s.emit("destroy"));
+  function Y() {
+    g || (g = !0, u.clear(), V(), i.emit("destroy"));
   }
-  function G(P, y, T) {
-    !x.active || h || (f.scrollBody.useBaseFriction().useDuration(y === !0 ? 0 : x.duration), f.scrollTo.index(P, T || 0));
+  function B(P, y, T) {
+    !b.active || g || (l.scrollBody.useBaseFriction().useDuration(y === !0 ? 0 : b.duration), l.scrollTo.index(P, T || 0));
   }
-  function q(P) {
-    const y = f.index.add(1).get();
-    G(y, P, -1);
+  function U(P) {
+    const y = l.index.add(1).get();
+    B(y, P, -1);
   }
-  function j(P) {
-    const y = f.index.add(-1).get();
-    G(y, P, 1);
+  function J(P) {
+    const y = l.index.add(-1).get();
+    B(y, P, 1);
   }
-  function Y() {
-    return f.index.add(1).get() !== R();
+  function $() {
+    return l.index.add(1).get() !== K();
   }
   function _() {
-    return f.index.add(-1).get() !== R();
+    return l.index.add(-1).get() !== K();
   }
-  function U() {
-    return f.scrollSnapList;
+  function Q() {
+    return l.scrollSnapList;
   }
-  function on() {
-    return f.scrollProgress.get(f.location.get());
+  function Z() {
+    return l.scrollProgress.get(l.location.get());
   }
-  function R() {
-    return f.index.get();
+  function K() {
+    return l.index.get();
   }
-  function tn() {
-    return f.indexPrevious.get();
+  function et() {
+    return l.indexPrevious.get();
   }
-  function en() {
-    return f.slidesInView.get();
+  function X() {
+    return l.slidesInView.get();
   }
-  function $() {
-    return f.slidesInView.get(!1);
+  function rt() {
+    return l.slidesInView.get(!1);
   }
-  function rn() {
-    return I;
+  function st() {
+    return v;
   }
-  function sn() {
-    return f;
+  function z() {
+    return l;
   }
-  function V() {
-    return n;
+  function R() {
+    return t;
   }
-  function z() {
-    return A;
+  function N() {
+    return F;
   }
-  function Q() {
-    return O;
+  function ot() {
+    return E;
   }
   const k = {
-    canScrollNext: Y,
+    canScrollNext: $,
     canScrollPrev: _,
-    containerNode: z,
-    internalEngine: sn,
-    destroy: H,
-    off: b,
-    on: p,
-    emit: m,
-    plugins: rn,
-    previousScrollSnap: tn,
-    reInit: d,
-    rootNode: V,
-    scrollNext: q,
-    scrollPrev: j,
-    scrollProgress: on,
-    scrollSnapList: U,
-    scrollTo: G,
-    selectedScrollSnap: R,
-    slideNodes: Q,
-    slidesInView: en,
-    slidesNotInView: $
+    containerNode: N,
+    internalEngine: z,
+    destroy: Y,
+    off: x,
+    on: m,
+    emit: d,
+    plugins: st,
+    previousScrollSnap: et,
+    reInit: p,
+    rootNode: R,
+    scrollNext: U,
+    scrollPrev: J,
+    scrollProgress: Z,
+    scrollSnapList: Q,
+    scrollTo: B,
+    selectedScrollSnap: K,
+    slideNodes: ot,
+    slidesInView: X,
+    slidesNotInView: rt
   };
-  return D(t, r), setTimeout(() => s.emit("init"), 0), k;
+  return A(n, r), setTimeout(() => i.emit("init"), 0), k;
 }
-kn.globalOptions = void 0;
+Vt.globalOptions = void 0;
 export {
-  kn as default
+  Vt as default
 };