@caseparts-org/caseblocks 0.0.57 → 0.0.58

package/dist/organisms/Carousel/Carousel.js

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