ics-ui-kit 0.1.0-alpha.9 → 0.1.0

package/dist/components/carousel.js

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