ics-ui-kit 0.1.0-alpha.12 → 0.1.0-alpha.13

package/dist/CarouselItem-pSHe0ufN.js

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