commerce-toolkit 0.7.0 → 0.8.0

package/dist/carousel-next-icon--YmTPwxE.js

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