@arolariu/components 0.0.20 → 0.0.22

package/dist/es/carousel.js

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