@ozdao/prometheus-framework 0.2.31 → 0.2.32

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

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