@enya-learning/nova 0.4.2 → 0.5.0

package/dist/components/carousel.js

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