zudoku 0.13.6 → 0.13.7

package/lib/ui/Carousel.js

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