@purpur/library 9.1.3 → 9.2.0

package/dist/carousel-BkxojLwn.mjs

@@ -0,0 +1,1633 @@
+import { jsx as V, jsxs as wt, Fragment as bn } from "react/jsx-runtime";
+import Kt, { useRef as yt, useState as it, useCallback as nt, useEffect as st } from "react";
+import { b as Mt } from "./button-4-yWOgtD.mjs";
+import { l as vn } from "./arrow-left.es-DU-PX-Il.mjs";
+import { i as xn } from "./arrow-right.es-C7SkjAB6.mjs";
+import { b as Wt } from "./icon-DNHpBTHs-JfI8WyiR.mjs";
+import { c as tn } from "./bind-CU-R61T-.mjs";
+const wn = {
+  name: "play-filled",
+  svg: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor"><path d="M19 12 5.5 19.794V4.206L19 12Z"/><path fill-rule="evenodd" d="M19.875 12a.875.875 0 0 1-.438.758l-13.5 7.794a.875.875 0 0 1-1.312-.758V4.206a.875.875 0 0 1 1.313-.758l13.5 7.794c.27.156.437.445.437.758Zm-13.5-6.279V18.28L17.25 12 6.375 5.721Z" clip-rule="evenodd"/></svg>',
+  keywords: ["play-filled"],
+  category: "action"
+}, nn = (t) => /* @__PURE__ */ V(Wt, { ...t, svg: wn });
+nn.displayName = "IconPlayFilled";
+const En = {
+  name: "tv-pause",
+  svg: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor"><path d="M19 20h-3V4h3v16ZM8 20H5V4h3v16Z"/><path fill-rule="evenodd" d="M4.1 4a.9.9 0 0 1 .9-.9h3a.9.9 0 0 1 .9.9v16a.9.9 0 0 1-.9.9H5a.9.9 0 0 1-.9-.9V4Zm1.8.9v14.2h1.2V4.9H5.9Zm9.2-.9a.9.9 0 0 1 .9-.9h3a.9.9 0 0 1 .9.9v16a.9.9 0 0 1-.9.9h-3a.9.9 0 0 1-.9-.9V4Zm1.8.9v14.2h1.2V4.9h-1.2Z" clip-rule="evenodd"/></svg>',
+  keywords: ["tv-pause"],
+  category: "action"
+}, en = (t) => /* @__PURE__ */ V(Wt, { ...t, svg: En });
+en.displayName = "IconTvPause";
+const In = {
+  active: !0,
+  breakpoints: {},
+  delay: 4e3,
+  jump: !1,
+  playOnInit: !0,
+  stopOnFocusIn: !0,
+  stopOnInteraction: !0,
+  stopOnMouseEnter: !1,
+  stopOnLastSnap: !1,
+  rootNode: null
+};
+function Ln(t, n) {
+  const e = t.scrollSnapList();
+  return typeof n == "number" ? e.map(() => n) : n(e, t);
+}
+function _n(t, n) {
+  const e = t.rootNode();
+  return n && n(e) || e;
+}
+function Ct(t = {}) {
+  let n, e, i, c, o = null, r = 0, u = !1, s = !1, a = !1, g = !1;
+  function l(T, A) {
+    e = T;
+    const {
+      mergeOptions: j,
+      optionsAtMedia: $
+    } = A, G = j(In, Ct.globalOptions), U = j(G, t);
+    if (n = $(U), e.scrollSnapList().length <= 1) return;
+    g = n.jump, i = !1, c = Ln(e, n.delay);
+    const {
+      eventStore: K,
+      ownerDocument: R
+    } = e.internalEngine(), J = !!e.internalEngine().options.watchDrag, X = _n(e, n.rootNode);
+    K.add(R, "visibilitychange", d), J && e.on("pointerDown", b), J && !n.stopOnInteraction && e.on("pointerUp", E), n.stopOnMouseEnter && K.add(X, "mouseenter", L), n.stopOnMouseEnter && !n.stopOnInteraction && K.add(X, "mouseleave", I), n.stopOnFocusIn && e.on("slideFocusStart", y), n.stopOnFocusIn && !n.stopOnInteraction && K.add(e.containerNode(), "focusout", p), n.playOnInit && p();
+  }
+  function m() {
+    e.off("pointerDown", b).off("pointerUp", E).off("slideFocusStart", y), y(), i = !0, u = !1;
+  }
+  function S() {
+    const {
+      ownerWindow: T
+    } = e.internalEngine();
+    T.clearTimeout(r), r = T.setTimeout(O, c[e.selectedScrollSnap()]), o = (/* @__PURE__ */ new Date()).getTime(), e.emit("autoplay:timerset");
+  }
+  function f() {
+    const {
+      ownerWindow: T
+    } = e.internalEngine();
+    T.clearTimeout(r), r = 0, o = null, e.emit("autoplay:timerstopped");
+  }
+  function p() {
+    if (!i) {
+      if (h()) {
+        a = !0;
+        return;
+      }
+      u || e.emit("autoplay:play"), S(), u = !0;
+    }
+  }
+  function y() {
+    i || (u && e.emit("autoplay:stop"), f(), u = !1);
+  }
+  function d() {
+    if (h())
+      return a = u, y();
+    a && p();
+  }
+  function h() {
+    const {
+      ownerDocument: T
+    } = e.internalEngine();
+    return T.visibilityState === "hidden";
+  }
+  function b() {
+    s || y();
+  }
+  function E() {
+    s || p();
+  }
+  function L() {
+    s = !0, y();
+  }
+  function I() {
+    s = !1, p();
+  }
+  function x(T) {
+    typeof T < "u" && (g = T), p();
+  }
+  function w() {
+    u && y();
+  }
+  function _() {
+    u && p();
+  }
+  function N() {
+    return u;
+  }
+  function O() {
+    const {
+      index: T
+    } = e.internalEngine(), A = T.clone().add(1).get(), j = e.scrollSnapList().length - 1, $ = n.stopOnLastSnap && A === j;
+    if (e.canScrollNext() ? e.scrollNext(g) : e.scrollTo(0, g), e.emit("autoplay:select"), $) return y();
+    p();
+  }
+  function k() {
+    if (!o) return null;
+    const T = c[e.selectedScrollSnap()], A = (/* @__PURE__ */ new Date()).getTime() - o;
+    return T - A;
+  }
+  return {
+    name: "autoplay",
+    options: t,
+    init: l,
+    destroy: m,
+    play: x,
+    stop: w,
+    reset: _,
+    isPlaying: N,
+    timeUntilNext: k
+  };
+}
+Ct.globalOptions = void 0;
+function On(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
+}
+function Qt(t) {
+  return On(t) || Array.isArray(t);
+}
+function Tn() {
+  return !!(typeof window < "u" && window.document && window.document.createElement);
+}
+function kt(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 || {})), o = JSON.stringify(Object.keys(n.breakpoints || {}));
+  return c !== o ? !1 : e.every((r) => {
+    const u = t[r], s = n[r];
+    return typeof u == "function" ? `${u}` == `${s}` : !Qt(u) || !Qt(s) ? u === s : kt(u, s);
+  });
+}
+function Jt(t) {
+  return t.concat().sort((n, e) => n.name > e.name ? 1 : -1).map((n) => n.options);
+}
+function Dn(t, n) {
+  if (t.length !== n.length) return !1;
+  const e = Jt(t), i = Jt(n);
+  return e.every((c, o) => {
+    const r = i[o];
+    return kt(c, r);
+  });
+}
+function At(t) {
+  return typeof t == "number";
+}
+function Pt(t) {
+  return typeof t == "string";
+}
+function It(t) {
+  return typeof t == "boolean";
+}
+function Xt(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
+}
+function P(t) {
+  return Math.abs(t);
+}
+function Bt(t) {
+  return Math.sign(t);
+}
+function mt(t, n) {
+  return P(t - n);
+}
+function Mn(t, n) {
+  if (t === 0 || n === 0 || P(t) <= P(n)) return 0;
+  const e = mt(P(t), P(n));
+  return P(e / t);
+}
+function Pn(t) {
+  return Math.round(t * 100) / 100;
+}
+function ht(t) {
+  return St(t).map(Number);
+}
+function Z(t) {
+  return t[vt(t)];
+}
+function vt(t) {
+  return Math.max(0, t.length - 1);
+}
+function Ft(t, n) {
+  return n === vt(t);
+}
+function Yt(t, n = 0) {
+  return Array.from(Array(t), (e, i) => n + i);
+}
+function St(t) {
+  return Object.keys(t);
+}
+function on(t, n) {
+  return [t, n].reduce((e, i) => (St(i).forEach((c) => {
+    const o = e[c], r = i[c], u = Xt(o) && Xt(r);
+    e[c] = u ? on(o, r) : r;
+  }), e), {});
+}
+function Nt(t, n) {
+  return typeof n.MouseEvent < "u" && t instanceof n.MouseEvent;
+}
+function Nn(t, n) {
+  const e = {
+    start: i,
+    center: c,
+    end: o
+  };
+  function i() {
+    return 0;
+  }
+  function c(s) {
+    return o(s) / 2;
+  }
+  function o(s) {
+    return n - s;
+  }
+  function r(s, a) {
+    return Pt(t) ? e[t](s) : t(n, s, a);
+  }
+  return {
+    measure: r
+  };
+}
+function bt() {
+  let t = [];
+  function n(c, o, r, u = {
+    passive: !0
+  }) {
+    let s;
+    if ("addEventListener" in c)
+      c.addEventListener(o, r, u), s = () => c.removeEventListener(o, r, u);
+    else {
+      const a = c;
+      a.addListener(r), s = () => a.removeListener(r);
+    }
+    return t.push(s), i;
+  }
+  function e() {
+    t = t.filter((c) => c());
+  }
+  const i = {
+    add: n,
+    clear: e
+  };
+  return i;
+}
+function Cn(t, n, e, i) {
+  const c = bt(), o = 1e3 / 60;
+  let r = null, u = 0, s = 0;
+  function a() {
+    c.add(t, "visibilitychange", () => {
+      t.hidden && f();
+    });
+  }
+  function g() {
+    S(), c.clear();
+  }
+  function l(y) {
+    if (!s) return;
+    r || (r = y, e(), e());
+    const d = y - r;
+    for (r = y, u += d; u >= o; )
+      e(), u -= o;
+    const h = u / o;
+    i(h), s && (s = n.requestAnimationFrame(l));
+  }
+  function m() {
+    s || (s = n.requestAnimationFrame(l));
+  }
+  function S() {
+    n.cancelAnimationFrame(s), r = null, u = 0, s = 0;
+  }
+  function f() {
+    r = null, u = 0;
+  }
+  return {
+    init: a,
+    destroy: g,
+    start: m,
+    stop: S,
+    update: e,
+    render: i
+  };
+}
+function kn(t, n) {
+  const e = n === "rtl", i = t === "y", c = i ? "y" : "x", o = i ? "x" : "y", r = !i && e ? -1 : 1, u = g(), s = l();
+  function a(f) {
+    const {
+      height: p,
+      width: y
+    } = f;
+    return i ? p : y;
+  }
+  function g() {
+    return i ? "top" : e ? "right" : "left";
+  }
+  function l() {
+    return i ? "bottom" : e ? "left" : "right";
+  }
+  function m(f) {
+    return f * r;
+  }
+  return {
+    scroll: c,
+    cross: o,
+    startEdge: u,
+    endEdge: s,
+    measureSize: a,
+    direction: m
+  };
+}
+function at(t = 0, n = 0) {
+  const e = P(t - n);
+  function i(a) {
+    return a < t;
+  }
+  function c(a) {
+    return a > n;
+  }
+  function o(a) {
+    return i(a) || c(a);
+  }
+  function r(a) {
+    return o(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: r,
+    reachedAny: o,
+    reachedMax: c,
+    reachedMin: i,
+    removeOffset: u
+  };
+}
+function rn(t, n, e) {
+  const {
+    constrain: i
+  } = at(0, t), c = t + 1;
+  let o = r(n);
+  function r(m) {
+    return e ? P((c + m) % c) : i(m);
+  }
+  function u() {
+    return o;
+  }
+  function s(m) {
+    return o = r(m), l;
+  }
+  function a(m) {
+    return g().set(u() + m);
+  }
+  function g() {
+    return rn(t, u(), e);
+  }
+  const l = {
+    get: u,
+    set: s,
+    add: a,
+    clone: g
+  };
+  return l;
+}
+function An(t, n, e, i, c, o, r, u, s, a, g, l, m, S, f, p, y, d, h) {
+  const {
+    cross: b,
+    direction: E
+  } = t, L = ["INPUT", "SELECT", "TEXTAREA"], I = {
+    passive: !1
+  }, x = bt(), w = bt(), _ = at(50, 225).constrain(S.measure(20)), N = {
+    mouse: 300,
+    touch: 400
+  }, O = {
+    mouse: 500,
+    touch: 600
+  }, k = f ? 43 : 25;
+  let q = !1, T = 0, A = 0, j = !1, $ = !1, G = !1, U = !1;
+  function K(v) {
+    if (!h) return;
+    function D(F) {
+      (It(h) || h(v, F)) && dt(F);
+    }
+    const C = n;
+    x.add(C, "dragstart", (F) => F.preventDefault(), I).add(C, "touchmove", () => {
+    }, I).add(C, "touchend", () => {
+    }).add(C, "touchstart", D).add(C, "mousedown", D).add(C, "touchcancel", B).add(C, "contextmenu", B).add(C, "click", W, !0);
+  }
+  function R() {
+    x.clear(), w.clear();
+  }
+  function J() {
+    const v = U ? e : n;
+    w.add(v, "touchmove", z, I).add(v, "touchend", B).add(v, "mousemove", z, I).add(v, "mouseup", B);
+  }
+  function X(v) {
+    const D = v.nodeName || "";
+    return L.includes(D);
+  }
+  function Y() {
+    return (f ? O : N)[U ? "mouse" : "touch"];
+  }
+  function ft(v, D) {
+    const C = l.add(Bt(v) * -1), F = g.byDistance(v, !f).distance;
+    return f || P(v) < _ ? F : y && D ? F * 0.5 : g.byIndex(C.get(), 0).distance;
+  }
+  function dt(v) {
+    const D = Nt(v, i);
+    U = D, G = f && D && !v.buttons && q, q = mt(c.get(), r.get()) >= 2, !(D && v.button !== 0) && (X(v.target) || (j = !0, o.pointerDown(v), a.useFriction(0).useDuration(0), c.set(r), J(), T = o.readPoint(v), A = o.readPoint(v, b), m.emit("pointerDown")));
+  }
+  function z(v) {
+    if (!Nt(v, i) && v.touches.length >= 2) return B(v);
+    const C = o.readPoint(v), F = o.readPoint(v, b), Q = mt(C, T), tt = mt(F, A);
+    if (!$ && !U && (!v.cancelable || ($ = Q > tt, !$)))
+      return B(v);
+    const ct = o.pointerMove(v);
+    Q > p && (G = !0), a.useFriction(0.3).useDuration(0.75), u.start(), c.add(E(ct)), v.preventDefault();
+  }
+  function B(v) {
+    const C = g.byDistance(0, !1).index !== l.get(), F = o.pointerUp(v) * Y(), Q = ft(E(F), C), tt = Mn(F, Q), ct = k - 10 * tt, et = d + tt / 50;
+    $ = !1, j = !1, w.clear(), a.useDuration(ct).useFriction(et), s.distance(Q, !f), U = !1, m.emit("pointerUp");
+  }
+  function W(v) {
+    G && (v.stopPropagation(), v.preventDefault(), G = !1);
+  }
+  function H() {
+    return j;
+  }
+  return {
+    init: K,
+    destroy: R,
+    pointerDown: H
+  };
+}
+function Bn(t, n) {
+  let i, c;
+  function o(l) {
+    return l.timeStamp;
+  }
+  function r(l, m) {
+    const f = `client${(m || t.scroll) === "x" ? "X" : "Y"}`;
+    return (Nt(l, n) ? l : l.touches[0])[f];
+  }
+  function u(l) {
+    return i = l, c = l, r(l);
+  }
+  function s(l) {
+    const m = r(l) - r(c), S = o(l) - o(i) > 170;
+    return c = l, S && (i = l), m;
+  }
+  function a(l) {
+    if (!i || !c) return 0;
+    const m = r(c) - r(i), S = o(l) - o(i), f = o(l) - o(c) > 170, p = m / S;
+    return S && !f && P(p) > 0.1 ? p : 0;
+  }
+  return {
+    pointerDown: u,
+    pointerMove: s,
+    pointerUp: a,
+    readPoint: r
+  };
+}
+function Fn() {
+  function t(e) {
+    const {
+      offsetTop: i,
+      offsetLeft: c,
+      offsetWidth: o,
+      offsetHeight: r
+    } = e;
+    return {
+      top: i,
+      right: c + o,
+      bottom: i + r,
+      left: c,
+      width: o,
+      height: r
+    };
+  }
+  return {
+    measure: t
+  };
+}
+function Vn(t) {
+  function n(i) {
+    return t * (i / 100);
+  }
+  return {
+    measure: n
+  };
+}
+function zn(t, n, e, i, c, o, r) {
+  const u = [t].concat(i);
+  let s, a, g = [], l = !1;
+  function m(y) {
+    return c.measureSize(r.measure(y));
+  }
+  function S(y) {
+    if (!o) return;
+    a = m(t), g = i.map(m);
+    function d(h) {
+      for (const b of h) {
+        if (l) return;
+        const E = b.target === t, L = i.indexOf(b.target), I = E ? a : g[L], x = m(E ? t : i[L]);
+        if (P(x - I) >= 0.5) {
+          y.reInit(), n.emit("resize");
+          break;
+        }
+      }
+    }
+    s = new ResizeObserver((h) => {
+      (It(o) || o(y, h)) && d(h);
+    }), e.requestAnimationFrame(() => {
+      u.forEach((h) => s.observe(h));
+    });
+  }
+  function f() {
+    l = !0, s && s.disconnect();
+  }
+  return {
+    init: S,
+    destroy: f
+  };
+}
+function jn(t, n, e, i, c, o) {
+  let r = 0, u = 0, s = c, a = o, g = t.get(), l = 0;
+  function m() {
+    const I = i.get() - t.get(), x = !s;
+    let w = 0;
+    return x ? (r = 0, e.set(i), t.set(i), w = I) : (e.set(t), r += I / s, r *= a, g += r, t.add(r), w = g - l), u = Bt(w), l = g, L;
+  }
+  function S() {
+    const I = i.get() - n.get();
+    return P(I) < 1e-3;
+  }
+  function f() {
+    return s;
+  }
+  function p() {
+    return u;
+  }
+  function y() {
+    return r;
+  }
+  function d() {
+    return b(c);
+  }
+  function h() {
+    return E(o);
+  }
+  function b(I) {
+    return s = I, L;
+  }
+  function E(I) {
+    return a = I, L;
+  }
+  const L = {
+    direction: p,
+    duration: f,
+    velocity: y,
+    seek: m,
+    settled: S,
+    useBaseFriction: h,
+    useBaseDuration: d,
+    useFriction: E,
+    useDuration: b
+  };
+  return L;
+}
+function $n(t, n, e, i, c) {
+  const o = c.measure(10), r = c.measure(50), u = at(0.1, 0.99);
+  let s = !1;
+  function a() {
+    return !(s || !t.reachedAny(e.get()) || !t.reachedAny(n.get()));
+  }
+  function g(S) {
+    if (!a()) return;
+    const f = t.reachedMin(n.get()) ? "min" : "max", p = P(t[f] - n.get()), y = e.get() - n.get(), d = u.constrain(p / r);
+    e.subtract(y * d), !S && P(y) < o && (e.set(t.constrain(e.get())), i.useDuration(25).useBaseFriction());
+  }
+  function l(S) {
+    s = !S;
+  }
+  return {
+    shouldConstrain: a,
+    constrain: g,
+    toggleActive: l
+  };
+}
+function Rn(t, n, e, i, c) {
+  const o = at(-n + t, 0), r = l(), u = g(), s = m();
+  function a(f, p) {
+    return mt(f, p) <= 1;
+  }
+  function g() {
+    const f = r[0], p = Z(r), y = r.lastIndexOf(f), d = r.indexOf(p) + 1;
+    return at(y, d);
+  }
+  function l() {
+    return e.map((f, p) => {
+      const {
+        min: y,
+        max: d
+      } = o, h = o.constrain(f), b = !p, E = Ft(e, p);
+      return b ? d : E || a(y, h) ? y : a(d, h) ? d : h;
+    }).map((f) => parseFloat(f.toFixed(3)));
+  }
+  function m() {
+    if (n <= t + c) return [o.max];
+    if (i === "keepSnaps") return r;
+    const {
+      min: f,
+      max: p
+    } = u;
+    return r.slice(f, p);
+  }
+  return {
+    snapsContained: s,
+    scrollContainLimit: u
+  };
+}
+function Hn(t, n, e) {
+  const i = n[0], c = e ? i - t : Z(n);
+  return {
+    limit: at(c, i)
+  };
+}
+function qn(t, n, e, i) {
+  const o = n.min + 0.1, r = n.max + 0.1, {
+    reachedMin: u,
+    reachedMax: s
+  } = at(o, r);
+  function a(m) {
+    return m === 1 ? s(e.get()) : m === -1 ? u(e.get()) : !1;
+  }
+  function g(m) {
+    if (!a(m)) return;
+    const S = t * (m * -1);
+    i.forEach((f) => f.add(S));
+  }
+  return {
+    loop: g
+  };
+}
+function Gn(t) {
+  const {
+    max: n,
+    length: e
+  } = t;
+  function i(o) {
+    const r = o - n;
+    return e ? r / -e : 0;
+  }
+  return {
+    get: i
+  };
+}
+function Un(t, n, e, i, c) {
+  const {
+    startEdge: o,
+    endEdge: r
+  } = t, {
+    groupSlides: u
+  } = c, s = l().map(n.measure), a = m(), g = S();
+  function l() {
+    return u(i).map((p) => Z(p)[r] - p[0][o]).map(P);
+  }
+  function m() {
+    return i.map((p) => e[o] - p[o]).map((p) => -P(p));
+  }
+  function S() {
+    return u(a).map((p) => p[0]).map((p, y) => p + s[y]);
+  }
+  return {
+    snaps: a,
+    snapsAligned: g
+  };
+}
+function Zn(t, n, e, i, c, o) {
+  const {
+    groupSlides: r
+  } = c, {
+    min: u,
+    max: s
+  } = i, a = g();
+  function g() {
+    const m = r(o), S = !t || n === "keepSnaps";
+    return e.length === 1 ? [o] : S ? m : m.slice(u, s).map((f, p, y) => {
+      const d = !p, h = Ft(y, p);
+      if (d) {
+        const b = Z(y[0]) + 1;
+        return Yt(b);
+      }
+      if (h) {
+        const b = vt(o) - Z(y)[0] + 1;
+        return Yt(b, Z(y)[0]);
+      }
+      return f;
+    });
+  }
+  return {
+    slideRegistry: a
+  };
+}
+function Kn(t, n, e, i, c) {
+  const {
+    reachedAny: o,
+    removeOffset: r,
+    constrain: u
+  } = i;
+  function s(f) {
+    return f.concat().sort((p, y) => P(p) - P(y))[0];
+  }
+  function a(f) {
+    const p = t ? r(f) : u(f), y = n.map((h, b) => ({
+      diff: g(h - p, 0),
+      index: b
+    })).sort((h, b) => P(h.diff) - P(b.diff)), {
+      index: d
+    } = y[0];
+    return {
+      index: d,
+      distance: p
+    };
+  }
+  function g(f, p) {
+    const y = [f, f + e, f - e];
+    if (!t) return f;
+    if (!p) return s(y);
+    const d = y.filter((h) => Bt(h) === p);
+    return d.length ? s(d) : Z(y) - e;
+  }
+  function l(f, p) {
+    const y = n[f] - c.get(), d = g(y, p);
+    return {
+      index: f,
+      distance: d
+    };
+  }
+  function m(f, p) {
+    const y = c.get() + f, {
+      index: d,
+      distance: h
+    } = a(y), b = !t && o(y);
+    if (!p || b) return {
+      index: d,
+      distance: f
+    };
+    const E = n[d] - h, L = f + g(E, 0);
+    return {
+      index: d,
+      distance: L
+    };
+  }
+  return {
+    byDistance: m,
+    byIndex: l,
+    shortcut: g
+  };
+}
+function Qn(t, n, e, i, c, o, r) {
+  function u(l) {
+    const m = l.distance, S = l.index !== n.get();
+    o.add(m), m && (i.duration() ? t.start() : (t.update(), t.render(1), t.update())), S && (e.set(n.get()), n.set(l.index), r.emit("select"));
+  }
+  function s(l, m) {
+    const S = c.byDistance(l, m);
+    u(S);
+  }
+  function a(l, m) {
+    const S = n.clone().set(l), f = c.byIndex(S.get(), m);
+    u(f);
+  }
+  return {
+    distance: s,
+    index: a
+  };
+}
+function Jn(t, n, e, i, c, o, r, u) {
+  const s = {
+    passive: !0,
+    capture: !0
+  };
+  let a = 0;
+  function g(S) {
+    if (!u) return;
+    function f(p) {
+      if ((/* @__PURE__ */ new Date()).getTime() - a > 10) return;
+      r.emit("slideFocusStart"), t.scrollLeft = 0;
+      const h = e.findIndex((b) => b.includes(p));
+      At(h) && (c.useDuration(0), i.index(h, 0), r.emit("slideFocus"));
+    }
+    o.add(document, "keydown", l, !1), n.forEach((p, y) => {
+      o.add(p, "focus", (d) => {
+        (It(u) || u(S, d)) && f(y);
+      }, s);
+    });
+  }
+  function l(S) {
+    S.code === "Tab" && (a = (/* @__PURE__ */ new Date()).getTime());
+  }
+  return {
+    init: g
+  };
+}
+function gt(t) {
+  let n = t;
+  function e() {
+    return n;
+  }
+  function i(s) {
+    n = r(s);
+  }
+  function c(s) {
+    n += r(s);
+  }
+  function o(s) {
+    n -= r(s);
+  }
+  function r(s) {
+    return At(s) ? s : s.get();
+  }
+  return {
+    get: e,
+    set: i,
+    add: c,
+    subtract: o
+  };
+}
+function sn(t, n) {
+  const e = t.scroll === "x" ? r : u, i = n.style;
+  let c = null, o = !1;
+  function r(m) {
+    return `translate3d(${m}px,0px,0px)`;
+  }
+  function u(m) {
+    return `translate3d(0px,${m}px,0px)`;
+  }
+  function s(m) {
+    if (o) return;
+    const S = Pn(t.direction(m));
+    S !== c && (i.transform = e(S), c = S);
+  }
+  function a(m) {
+    o = !m;
+  }
+  function g() {
+    o || (i.transform = "", n.getAttribute("style") || n.removeAttribute("style"));
+  }
+  return {
+    clear: g,
+    to: s,
+    toggleActive: a
+  };
+}
+function Xn(t, n, e, i, c, o, r, u, s) {
+  const g = ht(c), l = ht(c).reverse(), m = d().concat(h());
+  function S(x, w) {
+    return x.reduce((_, N) => _ - c[N], w);
+  }
+  function f(x, w) {
+    return x.reduce((_, N) => S(_, w) > 0 ? _.concat([N]) : _, []);
+  }
+  function p(x) {
+    return o.map((w, _) => ({
+      start: w - i[_] + 0.5 + x,
+      end: w + n - 0.5 + x
+    }));
+  }
+  function y(x, w, _) {
+    const N = p(w);
+    return x.map((O) => {
+      const k = _ ? 0 : -e, q = _ ? e : 0, T = _ ? "end" : "start", A = N[O][T];
+      return {
+        index: O,
+        loopPoint: A,
+        slideLocation: gt(-1),
+        translate: sn(t, s[O]),
+        target: () => u.get() > A ? k : q
+      };
+    });
+  }
+  function d() {
+    const x = r[0], w = f(l, x);
+    return y(w, e, !1);
+  }
+  function h() {
+    const x = n - r[0] - 1, w = f(g, x);
+    return y(w, -e, !0);
+  }
+  function b() {
+    return m.every(({
+      index: x
+    }) => {
+      const w = g.filter((_) => _ !== x);
+      return S(w, n) <= 0.1;
+    });
+  }
+  function E() {
+    m.forEach((x) => {
+      const {
+        target: w,
+        translate: _,
+        slideLocation: N
+      } = x, O = w();
+      O !== N.get() && (_.to(O), N.set(O));
+    });
+  }
+  function L() {
+    m.forEach((x) => x.translate.clear());
+  }
+  return {
+    canLoop: b,
+    clear: L,
+    loop: E,
+    loopPoints: m
+  };
+}
+function Yn(t, n, e) {
+  let i, c = !1;
+  function o(s) {
+    if (!e) return;
+    function a(g) {
+      for (const l of g)
+        if (l.type === "childList") {
+          s.reInit(), n.emit("slidesChanged");
+          break;
+        }
+    }
+    i = new MutationObserver((g) => {
+      c || (It(e) || e(s, g)) && a(g);
+    }), i.observe(t, {
+      childList: !0
+    });
+  }
+  function r() {
+    i && i.disconnect(), c = !0;
+  }
+  return {
+    init: o,
+    destroy: r
+  };
+}
+function Wn(t, n, e, i) {
+  const c = {};
+  let o = null, r = null, u, s = !1;
+  function a() {
+    u = new IntersectionObserver((f) => {
+      s || (f.forEach((p) => {
+        const y = n.indexOf(p.target);
+        c[y] = p;
+      }), o = null, r = null, e.emit("slidesInView"));
+    }, {
+      root: t.parentElement,
+      threshold: i
+    }), n.forEach((f) => u.observe(f));
+  }
+  function g() {
+    u && u.disconnect(), s = !0;
+  }
+  function l(f) {
+    return St(c).reduce((p, y) => {
+      const d = parseInt(y), {
+        isIntersecting: h
+      } = c[d];
+      return (f && h || !f && !h) && p.push(d), p;
+    }, []);
+  }
+  function m(f = !0) {
+    if (f && o) return o;
+    if (!f && r) return r;
+    const p = l(f);
+    return f && (o = p), f || (r = p), p;
+  }
+  return {
+    init: a,
+    destroy: g,
+    get: m
+  };
+}
+function te(t, n, e, i, c, o) {
+  const {
+    measureSize: r,
+    startEdge: u,
+    endEdge: s
+  } = t, a = e[0] && c, g = f(), l = p(), m = e.map(r), S = y();
+  function f() {
+    if (!a) return 0;
+    const h = e[0];
+    return P(n[u] - h[u]);
+  }
+  function p() {
+    if (!a) return 0;
+    const h = o.getComputedStyle(Z(i));
+    return parseFloat(h.getPropertyValue(`margin-${s}`));
+  }
+  function y() {
+    return e.map((h, b, E) => {
+      const L = !b, I = Ft(E, b);
+      return L ? m[b] + g : I ? m[b] + l : E[b + 1][u] - h[u];
+    }).map(P);
+  }
+  return {
+    slideSizes: m,
+    slideSizesWithGaps: S,
+    startGap: g,
+    endGap: l
+  };
+}
+function ne(t, n, e, i, c, o, r, u, s) {
+  const {
+    startEdge: a,
+    endEdge: g,
+    direction: l
+  } = t, m = At(e);
+  function S(d, h) {
+    return ht(d).filter((b) => b % h === 0).map((b) => d.slice(b, b + h));
+  }
+  function f(d) {
+    return d.length ? ht(d).reduce((h, b, E) => {
+      const L = Z(h) || 0, I = L === 0, x = b === vt(d), w = c[a] - o[L][a], _ = c[a] - o[b][g], N = !i && I ? l(r) : 0, O = !i && x ? l(u) : 0, k = P(_ - O - (w + N));
+      return E && k > n + s && h.push(b), x && h.push(d.length), h;
+    }, []).map((h, b, E) => {
+      const L = Math.max(E[b - 1] || 0);
+      return d.slice(L, h);
+    }) : [];
+  }
+  function p(d) {
+    return m ? S(d, e) : f(d);
+  }
+  return {
+    groupSlides: p
+  };
+}
+function ee(t, n, e, i, c, o, r) {
+  const {
+    align: u,
+    axis: s,
+    direction: a,
+    startIndex: g,
+    loop: l,
+    duration: m,
+    dragFree: S,
+    dragThreshold: f,
+    inViewThreshold: p,
+    slidesToScroll: y,
+    skipSnaps: d,
+    containScroll: h,
+    watchResize: b,
+    watchSlides: E,
+    watchDrag: L,
+    watchFocus: I
+  } = o, x = 2, w = Fn(), _ = w.measure(n), N = e.map(w.measure), O = kn(s, a), k = O.measureSize(_), q = Vn(k), T = Nn(u, k), A = !l && !!h, j = l || !!h, {
+    slideSizes: $,
+    slideSizesWithGaps: G,
+    startGap: U,
+    endGap: K
+  } = te(O, _, N, e, j, c), R = ne(O, k, y, l, _, N, U, K, x), {
+    snaps: J,
+    snapsAligned: X
+  } = Un(O, T, _, N, R), Y = -Z(J) + Z(G), {
+    snapsContained: ft,
+    scrollContainLimit: dt
+  } = Rn(k, Y, X, h, x), z = A ? ft : X, {
+    limit: B
+  } = Hn(Y, z, l), W = rn(vt(z), g, l), H = W.clone(), M = ht(e), v = ({
+    dragHandler: lt,
+    scrollBody: Tt,
+    scrollBounds: Dt,
+    options: {
+      loop: xt
+    }
+  }) => {
+    xt || Dt.constrain(lt.pointerDown()), Tt.seek();
+  }, D = ({
+    scrollBody: lt,
+    translate: Tt,
+    location: Dt,
+    offsetLocation: xt,
+    previousLocation: fn,
+    scrollLooper: dn,
+    slideLooper: pn,
+    dragHandler: gn,
+    animation: mn,
+    eventHandler: Rt,
+    scrollBounds: yn,
+    options: {
+      loop: Ht
+    }
+  }, qt) => {
+    const Gt = lt.settled(), hn = !yn.shouldConstrain(), Ut = Ht ? Gt : Gt && hn, Zt = Ut && !gn.pointerDown();
+    Zt && mn.stop();
+    const Sn = Dt.get() * qt + fn.get() * (1 - qt);
+    xt.set(Sn), Ht && (dn.loop(lt.direction()), pn.loop()), Tt.to(xt.get()), Zt && Rt.emit("settle"), Ut || Rt.emit("scroll");
+  }, C = Cn(i, c, () => v(Ot), (lt) => D(Ot, lt)), F = 0.68, Q = z[W.get()], tt = gt(Q), ct = gt(Q), et = gt(Q), ut = gt(Q), pt = jn(tt, et, ct, ut, m, F), Lt = Kn(l, z, Y, B, ut), _t = Qn(C, W, H, pt, Lt, ut, r), zt = Gn(B), jt = bt(), an = Wn(n, e, r, p), {
+    slideRegistry: $t
+  } = Zn(A, h, z, dt, R, M), ln = Jn(t, e, $t, _t, pt, jt, r, I), Ot = {
+    ownerDocument: i,
+    ownerWindow: c,
+    eventHandler: r,
+    containerRect: _,
+    slideRects: N,
+    animation: C,
+    axis: O,
+    dragHandler: An(O, t, i, c, ut, Bn(O, c), tt, C, _t, pt, Lt, W, r, q, S, f, d, F, L),
+    eventStore: jt,
+    percentOfView: q,
+    index: W,
+    indexPrevious: H,
+    limit: B,
+    location: tt,
+    offsetLocation: et,
+    previousLocation: ct,
+    options: o,
+    resizeHandler: zn(n, r, c, e, O, b, w),
+    scrollBody: pt,
+    scrollBounds: $n(B, et, ut, pt, q),
+    scrollLooper: qn(Y, B, et, [tt, et, ct, ut]),
+    scrollProgress: zt,
+    scrollSnapList: z.map(zt.get),
+    scrollSnaps: z,
+    scrollTarget: Lt,
+    scrollTo: _t,
+    slideLooper: Xn(O, k, Y, $, G, J, z, et, e),
+    slideFocus: ln,
+    slidesHandler: Yn(n, r, E),
+    slidesInView: an,
+    slideIndexes: M,
+    slideRegistry: $t,
+    slidesToScroll: R,
+    target: ut,
+    translate: sn(O, n)
+  };
+  return Ot;
+}
+function oe() {
+  let t = {}, n;
+  function e(a) {
+    n = a;
+  }
+  function i(a) {
+    return t[a] || [];
+  }
+  function c(a) {
+    return i(a).forEach((g) => g(n, a)), s;
+  }
+  function o(a, g) {
+    return t[a] = i(a).concat([g]), s;
+  }
+  function r(a, g) {
+    return t[a] = i(a).filter((l) => l !== g), s;
+  }
+  function u() {
+    t = {};
+  }
+  const s = {
+    init: e,
+    emit: c,
+    off: r,
+    on: o,
+    clear: u
+  };
+  return s;
+}
+const re = {
+  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 se(t) {
+  function n(o, r) {
+    return on(o, r || {});
+  }
+  function e(o) {
+    const r = o.breakpoints || {}, u = St(r).filter((s) => t.matchMedia(s).matches).map((s) => r[s]).reduce((s, a) => n(s, a), {});
+    return n(o, u);
+  }
+  function i(o) {
+    return o.map((r) => St(r.breakpoints || {})).reduce((r, u) => r.concat(u), []).map(t.matchMedia);
+  }
+  return {
+    mergeOptions: n,
+    optionsAtMedia: e,
+    optionsMediaQueries: i
+  };
+}
+function ie(t) {
+  let n = [];
+  function e(o, r) {
+    return n = r.filter(({
+      options: u
+    }) => t.optionsAtMedia(u).active !== !1), n.forEach((u) => u.init(o, t)), r.reduce((u, s) => Object.assign(u, {
+      [s.name]: s
+    }), {});
+  }
+  function i() {
+    n = n.filter((o) => o.destroy());
+  }
+  return {
+    init: e,
+    destroy: i
+  };
+}
+function Et(t, n, e) {
+  const i = t.ownerDocument, c = i.defaultView, o = se(c), r = ie(o), u = bt(), s = oe(), {
+    mergeOptions: a,
+    optionsAtMedia: g,
+    optionsMediaQueries: l
+  } = o, {
+    on: m,
+    off: S,
+    emit: f
+  } = s, p = O;
+  let y = !1, d, h = a(re, Et.globalOptions), b = a(h), E = [], L, I, x;
+  function w() {
+    const {
+      container: M,
+      slides: v
+    } = b;
+    I = (Pt(M) ? t.querySelector(M) : M) || t.children[0];
+    const C = Pt(v) ? I.querySelectorAll(v) : v;
+    x = [].slice.call(C || I.children);
+  }
+  function _(M) {
+    const v = ee(t, I, x, i, c, M, s);
+    if (M.loop && !v.slideLooper.canLoop()) {
+      const D = Object.assign({}, M, {
+        loop: !1
+      });
+      return _(D);
+    }
+    return v;
+  }
+  function N(M, v) {
+    y || (h = a(h, M), b = g(h), E = v || E, w(), d = _(b), l([h, ...E.map(({
+      options: D
+    }) => D)]).forEach((D) => u.add(D, "change", O)), b.active && (d.translate.to(d.location.get()), d.animation.init(), d.slidesInView.init(), d.slideFocus.init(H), d.eventHandler.init(H), d.resizeHandler.init(H), d.slidesHandler.init(H), d.options.loop && d.slideLooper.loop(), I.offsetParent && x.length && d.dragHandler.init(H), L = r.init(H, E)));
+  }
+  function O(M, v) {
+    const D = R();
+    k(), N(a({
+      startIndex: D
+    }, M), v), s.emit("reInit");
+  }
+  function k() {
+    d.dragHandler.destroy(), d.eventStore.clear(), d.translate.clear(), d.slideLooper.clear(), d.resizeHandler.destroy(), d.slidesHandler.destroy(), d.slidesInView.destroy(), d.animation.destroy(), r.destroy(), u.clear();
+  }
+  function q() {
+    y || (y = !0, u.clear(), k(), s.emit("destroy"), s.clear());
+  }
+  function T(M, v, D) {
+    !b.active || y || (d.scrollBody.useBaseFriction().useDuration(v === !0 ? 0 : b.duration), d.scrollTo.index(M, D || 0));
+  }
+  function A(M) {
+    const v = d.index.add(1).get();
+    T(v, M, -1);
+  }
+  function j(M) {
+    const v = d.index.add(-1).get();
+    T(v, M, 1);
+  }
+  function $() {
+    return d.index.add(1).get() !== R();
+  }
+  function G() {
+    return d.index.add(-1).get() !== R();
+  }
+  function U() {
+    return d.scrollSnapList;
+  }
+  function K() {
+    return d.scrollProgress.get(d.offsetLocation.get());
+  }
+  function R() {
+    return d.index.get();
+  }
+  function J() {
+    return d.indexPrevious.get();
+  }
+  function X() {
+    return d.slidesInView.get();
+  }
+  function Y() {
+    return d.slidesInView.get(!1);
+  }
+  function ft() {
+    return L;
+  }
+  function dt() {
+    return d;
+  }
+  function z() {
+    return t;
+  }
+  function B() {
+    return I;
+  }
+  function W() {
+    return x;
+  }
+  const H = {
+    canScrollNext: $,
+    canScrollPrev: G,
+    containerNode: B,
+    internalEngine: dt,
+    destroy: q,
+    off: S,
+    on: m,
+    emit: f,
+    plugins: ft,
+    previousScrollSnap: J,
+    reInit: p,
+    rootNode: z,
+    scrollNext: A,
+    scrollPrev: j,
+    scrollProgress: K,
+    scrollSnapList: U,
+    scrollTo: T,
+    selectedScrollSnap: R,
+    slideNodes: W,
+    slidesInView: X,
+    slidesNotInView: Y
+  };
+  return N(n, e), setTimeout(() => s.emit("init"), 0), H;
+}
+Et.globalOptions = void 0;
+function Vt(t = {}, n = []) {
+  const e = yt(t), i = yt(n), [c, o] = it(), [r, u] = it(), s = nt(() => {
+    c && c.reInit(e.current, i.current);
+  }, [c]);
+  return st(() => {
+    kt(e.current, t) || (e.current = t, s());
+  }, [t, s]), st(() => {
+    Dn(i.current, n) || (i.current = n, s());
+  }, [n, s]), st(() => {
+    if (Tn() && r) {
+      Et.globalOptions = Vt.globalOptions;
+      const a = Et(r, e.current, i.current);
+      return o(a), () => a.destroy();
+    } else
+      o(void 0);
+  }, [r, o]), [u, c];
+}
+Vt.globalOptions = void 0;
+const ce = {
+  "purpur-carousel": "_purpur-carousel_pqv4p_1",
+  "purpur-carousel__viewport": "_purpur-carousel__viewport_pqv4p_16",
+  "purpur-carousel__container": "_purpur-carousel__container_pqv4p_19",
+  "purpur-carousel__page-indicators": "_purpur-carousel__page-indicators_pqv4p_27",
+  "purpur-carousel__controls": "_purpur-carousel__controls_pqv4p_36",
+  "purpur-carousel__autoplay-pause-button": "_purpur-carousel__autoplay-pause-button_pqv4p_40",
+  "purpur-carousel__buttons": "_purpur-carousel__buttons_pqv4p_48",
+  "purpur-carousel__slide": "_purpur-carousel__slide_pqv4p_59"
+}, ue = {
+  "carousel-page-indicator": "_carousel-page-indicator_1j94u_1",
+  "dot-progress": "_dot-progress_1j94u_1"
+}, ae = tn.bind(ue), le = "carousel-page-indicator", fe = 4e3, de = ({
+  index: t,
+  selectedIndex: n,
+  totalIndicators: e,
+  showProgress: i,
+  delay: c = fe
+}) => {
+  const o = () => {
+    const m = Math.min(t, e - 1 - t);
+    let S = u;
+    if (!g) return 0;
+    if (m === 0) return 150;
+    s === 0 && (u === 2 && (S = 1), u === 3 && (S = 2));
+    const f = 1 / (2 * (S || 0.5));
+    return f < 0.25 ? 50 : f < 0.5 ? 100 : 150;
+  }, r = t === n, u = Math.abs(n - t), s = Math.min(n, e - 1 - n), a = Math.max(5 - s, 3), g = u < a, l = e < 6 ? 150 : o();
+  return /* @__PURE__ */ V(
+    "li",
+    {
+      className: ae(le),
+      "data-selected": r,
+      "data-show-progress": i,
+      style: {
+        marginLeft: g ? "var(--purpur-spacing-100)" : void 0,
+        width: r ? "var(--purpur-spacing-400)" : `var(--purpur-spacing-${l})`,
+        height: `var(--purpur-spacing-${l})`,
+        // @ts-expect-error TS doesn't know about CSS variables yet
+        "--progress-time": `${c}ms`
+      }
+    }
+  );
+}, pe = (t, n) => {
+  const e = yt(!1), [i, c] = it(!1), o = t?.plugins()?.autoplay, r = nt(() => {
+    if (!o) return;
+    (o.isPlaying() ? o.stop : o.play)();
+  }, [o]), u = () => {
+    o && o.reset();
+  };
+  return st(() => {
+    o && (c(o.isPlaying()), t.on("autoplay:play", () => c(!0)).on("autoplay:stop", () => c(!1)).on("reInit", () => c(o.isPlaying())));
+  }, [o, t]), st(() => {
+    if (!o || !n?.current) return;
+    const s = new IntersectionObserver(
+      ([g]) => {
+        g.isIntersecting ? e.current && (e.current = !1, o.play()) : o.isPlaying() && (e.current = !0, o.stop());
+      },
+      { threshold: 0 }
+    ), a = n.current;
+    return s.observe(a), () => s.disconnect();
+  }, [o, n]), {
+    isPlaying: i,
+    toggle: r,
+    reset: u
+  };
+}, ge = (t) => {
+  const [n, e] = it(0), [i, c] = it([]), o = nt(
+    (s) => {
+      t && t.scrollTo(s);
+    },
+    [t]
+  ), r = nt((s) => {
+    c(s.scrollSnapList());
+  }, []), u = nt((s) => {
+    e(s.selectedScrollSnap());
+  }, []);
+  return st(() => {
+    t && (r(t), u(t), t.on("reInit", r).on("reInit", u).on("select", u));
+  }, [t, r, u]), {
+    selectedIndex: n,
+    scrollSnaps: i,
+    onIndicatorClick: o
+  };
+}, cn = "(prefers-reduced-motion: reduce)", me = () => typeof window > "u" ? !1 : window.matchMedia(cn).matches, ye = () => {
+  const [t, n] = it(me);
+  return st(() => {
+    if (typeof window > "u")
+      return;
+    const e = window.matchMedia(cn), i = () => {
+      n(e.matches);
+    };
+    return i(), e.addEventListener("change", i), () => {
+      e.removeEventListener("change", i);
+    };
+  }, []), t;
+}, he = (t, n, e) => {
+  const [i, c] = it(!0), [o, r] = it(!0), u = nt(() => {
+    t && (t.scrollPrev(), e.reset());
+  }, [t, e]), s = nt(() => {
+    t && (t.scrollNext(), e.reset());
+  }, [t, e]), a = nt((l) => {
+    c(!l.canScrollPrev()), r(!l.canScrollNext());
+  }, []), g = nt(
+    (l) => {
+      switch (l.key) {
+        case "ArrowLeft":
+          u(), l.target?.previousSibling?.focus();
+          break;
+        case "ArrowRight":
+          s(), l.target?.nextSibling?.focus();
+          break;
+      }
+    },
+    [u, s]
+  );
+  return st(() => {
+    const l = n.current;
+    if (t && l)
+      return a(t), t.on("reInit", a).on("select", a), l.addEventListener("keydown", g), () => {
+        l.removeEventListener("keydown", g);
+      };
+  }, [t, a, n, g]), {
+    prevBtnDisabled: i,
+    nextBtnDisabled: o,
+    onPrevButtonClick: u,
+    onNextButtonClick: s
+  };
+}, ot = tn.bind(ce), rt = "purpur-carousel", un = ({
+  className: t,
+  options: n = {},
+  children: e,
+  controllerPlacement: i = "bottom",
+  ...c
+}) => {
+  const o = yt(null), r = yt(null), u = typeof c.autoplay == "boolean" ? {} : c.autoplay ?? {}, s = ot(rt, t), a = ye(), g = be(
+    a ? { ...n, duration: 0 } : n
+  ), l = [];
+  c.autoplay && l.push(
+    Ct({
+      ...u,
+      jump: a
+    })
+  );
+  const [m, S] = Vt({ align: "start", ...g }, l), f = pe(S, o), p = he(S, o, f), { selectedIndex: y, scrollSnaps: d } = ge(S), h = () => Kt.Children.toArray(e).map((L) => Kt.Children.only(L)), b = () => /* @__PURE__ */ wt("div", { className: ot(`${rt}__controls`), children: [
+    c.hidePageIndicator !== !0 && /* @__PURE__ */ wt(bn, { children: [
+      /* @__PURE__ */ V(
+        "ul",
+        {
+          className: ot(`${rt}__page-indicators`),
+          "data-overflowing": d.length > 5,
+          "aria-label": `${c.ariaLabels.autoplay.indicator} ${y + 1}`,
+          "aria-live": "off",
+          children: d.map((L, I, x) => /* @__PURE__ */ V(
+            de,
+            {
+              index: I,
+              ref: r,
+              showProgress: f.isPlaying,
+              totalIndicators: x.length,
+              selectedIndex: y,
+              delay: u.delay
+            },
+            I
+          ))
+        }
+      ),
+      c.autoplay && /* @__PURE__ */ V(
+        Mt,
+        {
+          variant: "text",
+          "aria-label": f.isPlaying ? c.ariaLabels.autoplay.pause : c.ariaLabels.autoplay.play,
+          onClick: f.toggle,
+          iconOnly: !0,
+          size: "sm",
+          className: ot(`${rt}__autoplay-pause-button`),
+          children: f.isPlaying ? /* @__PURE__ */ V(en, { size: "xs" }) : /* @__PURE__ */ V(nn, { size: "xs" })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ wt("div", { className: ot(`${rt}__buttons`), children: [
+      /* @__PURE__ */ V(
+        Mt,
+        {
+          iconOnly: !0,
+          "aria-label": c.ariaLabels.previousButton,
+          size: "md",
+          variant: "secondary",
+          onClick: p.onPrevButtonClick,
+          disabled: p.prevBtnDisabled,
+          children: /* @__PURE__ */ V(vn, { size: "xs" })
+        }
+      ),
+      /* @__PURE__ */ V(
+        Mt,
+        {
+          iconOnly: !0,
+          "aria-label": c.ariaLabels.nextButton,
+          size: "md",
+          variant: "secondary",
+          onClick: p.onNextButtonClick,
+          disabled: p.nextBtnDisabled,
+          children: /* @__PURE__ */ V(xn, { size: "xs" })
+        }
+      )
+    ] })
+  ] }), E = Math.max(0, Math.min(50, c.nextSlidePreview || 0));
+  return /* @__PURE__ */ wt(
+    "section",
+    {
+      ref: o,
+      className: s,
+      "data-is-looping": !!n?.loop,
+      style: {
+        // @ts-expect-error TS doesn't know about CSS variables yet
+        "--n": g.slidesToShow || 1,
+        "--preview": E,
+        "--slide-spacing": `var(--purpur-spacing-${c.slideSpacing || 300})`
+      },
+      children: [
+        i === "top" && b(),
+        /* @__PURE__ */ V("div", { className: ot(`${rt}__viewport`), ref: m, children: /* @__PURE__ */ V("ul", { className: ot(`${rt}__container`), children: h() }) }),
+        i === "bottom" && b()
+      ]
+    }
+  );
+}, Se = ({ children: t }) => /* @__PURE__ */ V("li", { className: ot(`${rt}__slide`), children: t });
+un.displayName = "Carousel";
+un.Slide = Se;
+function be(t = {}) {
+  const n = { ...t };
+  if (typeof window > "u" || !t.breakpoints)
+    return n;
+  for (const e in t.breakpoints)
+    Object.assign(n, window.matchMedia(e).matches ? t.breakpoints[e] : {});
+  return n;
+}
+export {
+  un as C
+};
+//# sourceMappingURL=carousel-BkxojLwn.mjs.map