@cfx-dev/ui-components 5.0.25 → 5.0.27

package/dist/embla-carousel-react.esm-BE464U1q.js

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