@equal-experts/kuat-react 0.10.0 → 0.12.0

package/dist/carousel-B_FcJvc1.js

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