@equal-experts/kuat-react 0.9.1 → 0.10.0

package/dist/carousel-vRCoMeVE.js

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