@alfadocs/ui-kit 0.14.1 → 0.15.1

package/dist/_chunks/carousel.agent-OTn-kMQg.js

@@ -0,0 +1,1669 @@
+import { jsx as V, jsxs as Dt } from "react/jsx-runtime";
+import { useRef as Pt, useState as nt, useCallback as lt, useEffect as dt, forwardRef as xt, useId as xe, useMemo as Qt, useImperativeHandle as ye, Children as te, isValidElement as ee, createContext as Ie, useContext as Ce } from "react";
+import { c as ne } from "./index-D2ZczOXr.js";
+import { useTranslation as yt } from "react-i18next";
+import { I as Jt } from "./icon-button-C4CGcYuz.js";
+import { C as Le } from "./chevron-left-CX1jqD2M.js";
+import { C as we } from "./chevron-right-BrpYejk0.js";
+function Ee(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
+}
+function Xt(t) {
+  return Ee(t) || Array.isArray(t);
+}
+function Te() {
+  return !!(typeof window < "u" && window.document && window.document.createElement);
+}
+function Mt(t, e) {
+  const n = Object.keys(t), r = Object.keys(e);
+  if (n.length !== r.length) return !1;
+  const i = JSON.stringify(Object.keys(t.breakpoints || {})), s = JSON.stringify(Object.keys(e.breakpoints || {}));
+  return i !== s ? !1 : n.every((o) => {
+    const u = t[o], c = e[o];
+    return typeof u == "function" ? `${u}` == `${c}` : !Xt(u) || !Xt(c) ? u === c : Mt(u, c);
+  });
+}
+function Yt(t) {
+  return t.concat().sort((e, n) => e.name > n.name ? 1 : -1).map((e) => e.options);
+}
+function De(t, e) {
+  if (t.length !== e.length) return !1;
+  const n = Yt(t), r = Yt(e);
+  return n.every((i, s) => {
+    const o = r[s];
+    return Mt(i, o);
+  });
+}
+function kt(t) {
+  return typeof t == "number";
+}
+function At(t) {
+  return typeof t == "string";
+}
+function It(t) {
+  return typeof t == "boolean";
+}
+function Zt(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
+}
+function N(t) {
+  return Math.abs(t);
+}
+function Ot(t) {
+  return Math.sign(t);
+}
+function pt(t, e) {
+  return N(t - e);
+}
+function Pe(t, e) {
+  if (t === 0 || e === 0 || N(t) <= N(e)) return 0;
+  const n = pt(N(t), N(e));
+  return N(n / t);
+}
+function Ae(t) {
+  return Math.round(t * 100) / 100;
+}
+function mt(t) {
+  return gt(t).map(Number);
+}
+function J(t) {
+  return t[bt(t)];
+}
+function bt(t) {
+  return Math.max(0, t.length - 1);
+}
+function Ft(t, e) {
+  return e === bt(t);
+}
+function Wt(t, e = 0) {
+  return Array.from(Array(t), (n, r) => e + r);
+}
+function gt(t) {
+  return Object.keys(t);
+}
+function oe(t, e) {
+  return [t, e].reduce((n, r) => (gt(r).forEach((i) => {
+    const s = n[i], o = r[i], u = Zt(s) && Zt(o);
+    n[i] = u ? oe(s, o) : o;
+  }), n), {});
+}
+function Nt(t, e) {
+  return typeof e.MouseEvent < "u" && t instanceof e.MouseEvent;
+}
+function Ne(t, e) {
+  const n = {
+    start: r,
+    center: i,
+    end: s
+  };
+  function r() {
+    return 0;
+  }
+  function i(c) {
+    return s(c) / 2;
+  }
+  function s(c) {
+    return e - c;
+  }
+  function o(c, l) {
+    return At(t) ? n[t](c) : t(e, c, l);
+  }
+  return {
+    measure: o
+  };
+}
+function ht() {
+  let t = [];
+  function e(i, s, o, u = {
+    passive: !0
+  }) {
+    let c;
+    if ("addEventListener" in i)
+      i.addEventListener(s, o, u), c = () => i.removeEventListener(s, o, u);
+    else {
+      const l = i;
+      l.addListener(o), c = () => l.removeListener(o);
+    }
+    return t.push(c), r;
+  }
+  function n() {
+    t = t.filter((i) => i());
+  }
+  const r = {
+    add: e,
+    clear: n
+  };
+  return r;
+}
+function Me(t, e, n, r) {
+  const i = ht(), s = 1e3 / 60;
+  let o = null, u = 0, c = 0;
+  function l() {
+    i.add(t, "visibilitychange", () => {
+      t.hidden && d();
+    });
+  }
+  function b() {
+    v(), i.clear();
+  }
+  function p(h) {
+    if (!c) return;
+    o || (o = h, n(), n());
+    const f = h - o;
+    for (o = h, u += f; u >= s; )
+      n(), u -= s;
+    const a = u / s;
+    r(a), c && (c = e.requestAnimationFrame(p));
+  }
+  function m() {
+    c || (c = e.requestAnimationFrame(p));
+  }
+  function v() {
+    e.cancelAnimationFrame(c), o = null, u = 0, c = 0;
+  }
+  function d() {
+    o = null, u = 0;
+  }
+  return {
+    init: l,
+    destroy: b,
+    start: m,
+    stop: v,
+    update: n,
+    render: r
+  };
+}
+function ke(t, e) {
+  const n = e === "rtl", r = t === "y", i = r ? "y" : "x", s = r ? "x" : "y", o = !r && n ? -1 : 1, u = b(), c = p();
+  function l(d) {
+    const {
+      height: g,
+      width: h
+    } = d;
+    return r ? g : h;
+  }
+  function b() {
+    return r ? "top" : n ? "right" : "left";
+  }
+  function p() {
+    return r ? "bottom" : n ? "left" : "right";
+  }
+  function m(d) {
+    return d * o;
+  }
+  return {
+    scroll: i,
+    cross: s,
+    startEdge: u,
+    endEdge: c,
+    measureSize: l,
+    direction: m
+  };
+}
+function ct(t = 0, e = 0) {
+  const n = N(t - e);
+  function r(l) {
+    return l < t;
+  }
+  function i(l) {
+    return l > e;
+  }
+  function s(l) {
+    return r(l) || i(l);
+  }
+  function o(l) {
+    return s(l) ? r(l) ? t : e : l;
+  }
+  function u(l) {
+    return n ? l - n * Math.ceil((l - e) / n) : l;
+  }
+  return {
+    length: n,
+    max: e,
+    min: t,
+    constrain: o,
+    reachedAny: s,
+    reachedMax: i,
+    reachedMin: r,
+    removeOffset: u
+  };
+}
+function re(t, e, n) {
+  const {
+    constrain: r
+  } = ct(0, t), i = t + 1;
+  let s = o(e);
+  function o(m) {
+    return n ? N((i + m) % i) : r(m);
+  }
+  function u() {
+    return s;
+  }
+  function c(m) {
+    return s = o(m), p;
+  }
+  function l(m) {
+    return b().set(u() + m);
+  }
+  function b() {
+    return re(t, u(), n);
+  }
+  const p = {
+    get: u,
+    set: c,
+    add: l,
+    clone: b
+  };
+  return p;
+}
+function Oe(t, e, n, r, i, s, o, u, c, l, b, p, m, v, d, g, h, f, a) {
+  const {
+    cross: S,
+    direction: C
+  } = t, L = ["INPUT", "SELECT", "TEXTAREA"], w = {
+    passive: !1
+  }, y = ht(), I = ht(), E = ct(50, 225).constrain(v.measure(20)), P = {
+    mouse: 300,
+    touch: 400
+  }, T = {
+    mouse: 500,
+    touch: 600
+  }, j = d ? 43 : 25;
+  let M = !1, B = 0, R = 0, q = !1, X = !1, _ = !1, K = !1;
+  function ot(x) {
+    if (!a) return;
+    function D(G) {
+      (It(a) || a(x, G)) && k(G);
+    }
+    const z = e;
+    y.add(z, "dragstart", (G) => G.preventDefault(), w).add(z, "touchmove", () => {
+    }, w).add(z, "touchend", () => {
+    }).add(z, "touchstart", D).add(z, "mousedown", D).add(z, "touchcancel", F).add(z, "contextmenu", F).add(z, "click", $, !0);
+  }
+  function U() {
+    y.clear(), I.clear();
+  }
+  function W() {
+    const x = K ? n : e;
+    I.add(x, "touchmove", O, w).add(x, "touchend", F).add(x, "mousemove", O, w).add(x, "mouseup", F);
+  }
+  function tt(x) {
+    const D = x.nodeName || "";
+    return L.includes(D);
+  }
+  function Q() {
+    return (d ? T : P)[K ? "mouse" : "touch"];
+  }
+  function rt(x, D) {
+    const z = p.add(Ot(x) * -1), G = b.byDistance(x, !d).distance;
+    return d || N(x) < E ? G : h && D ? G * 0.5 : b.byIndex(z.get(), 0).distance;
+  }
+  function k(x) {
+    const D = Nt(x, r);
+    K = D, _ = d && D && !x.buttons && M, M = pt(i.get(), o.get()) >= 2, !(D && x.button !== 0) && (tt(x.target) || (q = !0, s.pointerDown(x), l.useFriction(0).useDuration(0), i.set(o), W(), B = s.readPoint(x), R = s.readPoint(x, S), m.emit("pointerDown")));
+  }
+  function O(x) {
+    if (!Nt(x, r) && x.touches.length >= 2) return F(x);
+    const z = s.readPoint(x), G = s.readPoint(x, S), Y = pt(z, B), Z = pt(G, R);
+    if (!X && !K && (!x.cancelable || (X = Y > Z, !X)))
+      return F(x);
+    const st = s.pointerMove(x);
+    Y > g && (_ = !0), l.useFriction(0.3).useDuration(0.75), u.start(), i.add(C(st)), x.preventDefault();
+  }
+  function F(x) {
+    const z = b.byDistance(0, !1).index !== p.get(), G = s.pointerUp(x) * Q(), Y = rt(C(G), z), Z = Pe(G, Y), st = j - 10 * Z, et = f + Z / 50;
+    X = !1, q = !1, I.clear(), l.useDuration(st).useFriction(et), c.distance(Y, !d), K = !1, m.emit("pointerUp");
+  }
+  function $(x) {
+    _ && (x.stopPropagation(), x.preventDefault(), _ = !1);
+  }
+  function H() {
+    return q;
+  }
+  return {
+    init: ot,
+    destroy: U,
+    pointerDown: H
+  };
+}
+function Fe(t, e) {
+  let r, i;
+  function s(p) {
+    return p.timeStamp;
+  }
+  function o(p, m) {
+    const d = `client${(m || t.scroll) === "x" ? "X" : "Y"}`;
+    return (Nt(p, e) ? p : p.touches[0])[d];
+  }
+  function u(p) {
+    return r = p, i = p, o(p);
+  }
+  function c(p) {
+    const m = o(p) - o(i), v = s(p) - s(r) > 170;
+    return i = p, v && (r = p), m;
+  }
+  function l(p) {
+    if (!r || !i) return 0;
+    const m = o(i) - o(r), v = s(p) - s(r), d = s(p) - s(i) > 170, g = m / v;
+    return v && !d && N(g) > 0.1 ? g : 0;
+  }
+  return {
+    pointerDown: u,
+    pointerMove: c,
+    pointerUp: l,
+    readPoint: o
+  };
+}
+function ze() {
+  function t(n) {
+    const {
+      offsetTop: r,
+      offsetLeft: i,
+      offsetWidth: s,
+      offsetHeight: o
+    } = n;
+    return {
+      top: r,
+      right: i + s,
+      bottom: r + o,
+      left: i,
+      width: s,
+      height: o
+    };
+  }
+  return {
+    measure: t
+  };
+}
+function Ve(t) {
+  function e(r) {
+    return t * (r / 100);
+  }
+  return {
+    measure: e
+  };
+}
+function je(t, e, n, r, i, s, o) {
+  const u = [t].concat(r);
+  let c, l, b = [], p = !1;
+  function m(h) {
+    return i.measureSize(o.measure(h));
+  }
+  function v(h) {
+    if (!s) return;
+    l = m(t), b = r.map(m);
+    function f(a) {
+      for (const S of a) {
+        if (p) return;
+        const C = S.target === t, L = r.indexOf(S.target), w = C ? l : b[L], y = m(C ? t : r[L]);
+        if (N(y - w) >= 0.5) {
+          h.reInit(), e.emit("resize");
+          break;
+        }
+      }
+    }
+    c = new ResizeObserver((a) => {
+      (It(s) || s(h, a)) && f(a);
+    }), n.requestAnimationFrame(() => {
+      u.forEach((a) => c.observe(a));
+    });
+  }
+  function d() {
+    p = !0, c && c.disconnect();
+  }
+  return {
+    init: v,
+    destroy: d
+  };
+}
+function Be(t, e, n, r, i, s) {
+  let o = 0, u = 0, c = i, l = s, b = t.get(), p = 0;
+  function m() {
+    const w = r.get() - t.get(), y = !c;
+    let I = 0;
+    return y ? (o = 0, n.set(r), t.set(r), I = w) : (n.set(t), o += w / c, o *= l, b += o, t.add(o), I = b - p), u = Ot(I), p = b, L;
+  }
+  function v() {
+    const w = r.get() - e.get();
+    return N(w) < 1e-3;
+  }
+  function d() {
+    return c;
+  }
+  function g() {
+    return u;
+  }
+  function h() {
+    return o;
+  }
+  function f() {
+    return S(i);
+  }
+  function a() {
+    return C(s);
+  }
+  function S(w) {
+    return c = w, L;
+  }
+  function C(w) {
+    return l = w, L;
+  }
+  const L = {
+    direction: g,
+    duration: d,
+    velocity: h,
+    seek: m,
+    settled: v,
+    useBaseFriction: a,
+    useBaseDuration: f,
+    useFriction: C,
+    useDuration: S
+  };
+  return L;
+}
+function Re(t, e, n, r, i) {
+  const s = i.measure(10), o = i.measure(50), u = ct(0.1, 0.99);
+  let c = !1;
+  function l() {
+    return !(c || !t.reachedAny(n.get()) || !t.reachedAny(e.get()));
+  }
+  function b(v) {
+    if (!l()) return;
+    const d = t.reachedMin(e.get()) ? "min" : "max", g = N(t[d] - e.get()), h = n.get() - e.get(), f = u.constrain(g / o);
+    n.subtract(h * f), !v && N(h) < s && (n.set(t.constrain(n.get())), r.useDuration(25).useBaseFriction());
+  }
+  function p(v) {
+    c = !v;
+  }
+  return {
+    shouldConstrain: l,
+    constrain: b,
+    toggleActive: p
+  };
+}
+function He(t, e, n, r, i) {
+  const s = ct(-e + t, 0), o = p(), u = b(), c = m();
+  function l(d, g) {
+    return pt(d, g) <= 1;
+  }
+  function b() {
+    const d = o[0], g = J(o), h = o.lastIndexOf(d), f = o.indexOf(g) + 1;
+    return ct(h, f);
+  }
+  function p() {
+    return n.map((d, g) => {
+      const {
+        min: h,
+        max: f
+      } = s, a = s.constrain(d), S = !g, C = Ft(n, g);
+      return S ? f : C || l(h, a) ? h : l(f, a) ? f : a;
+    }).map((d) => parseFloat(d.toFixed(3)));
+  }
+  function m() {
+    if (e <= t + i) return [s.max];
+    if (r === "keepSnaps") return o;
+    const {
+      min: d,
+      max: g
+    } = u;
+    return o.slice(d, g);
+  }
+  return {
+    snapsContained: c,
+    scrollContainLimit: u
+  };
+}
+function Ge(t, e, n) {
+  const r = e[0], i = n ? r - t : J(e);
+  return {
+    limit: ct(i, r)
+  };
+}
+function Ue(t, e, n, r) {
+  const s = e.min + 0.1, o = e.max + 0.1, {
+    reachedMin: u,
+    reachedMax: c
+  } = ct(s, o);
+  function l(m) {
+    return m === 1 ? c(n.get()) : m === -1 ? u(n.get()) : !1;
+  }
+  function b(m) {
+    if (!l(m)) return;
+    const v = t * (m * -1);
+    r.forEach((d) => d.add(v));
+  }
+  return {
+    loop: b
+  };
+}
+function $e(t) {
+  const {
+    max: e,
+    length: n
+  } = t;
+  function r(s) {
+    const o = s - e;
+    return n ? o / -n : 0;
+  }
+  return {
+    get: r
+  };
+}
+function qe(t, e, n, r, i) {
+  const {
+    startEdge: s,
+    endEdge: o
+  } = t, {
+    groupSlides: u
+  } = i, c = p().map(e.measure), l = m(), b = v();
+  function p() {
+    return u(r).map((g) => J(g)[o] - g[0][s]).map(N);
+  }
+  function m() {
+    return r.map((g) => n[s] - g[s]).map((g) => -N(g));
+  }
+  function v() {
+    return u(l).map((g) => g[0]).map((g, h) => g + c[h]);
+  }
+  return {
+    snaps: l,
+    snapsAligned: b
+  };
+}
+function _e(t, e, n, r, i, s) {
+  const {
+    groupSlides: o
+  } = i, {
+    min: u,
+    max: c
+  } = r, l = b();
+  function b() {
+    const m = o(s), v = !t || e === "keepSnaps";
+    return n.length === 1 ? [s] : v ? m : m.slice(u, c).map((d, g, h) => {
+      const f = !g, a = Ft(h, g);
+      if (f) {
+        const S = J(h[0]) + 1;
+        return Wt(S);
+      }
+      if (a) {
+        const S = bt(s) - J(h)[0] + 1;
+        return Wt(S, J(h)[0]);
+      }
+      return d;
+    });
+  }
+  return {
+    slideRegistry: l
+  };
+}
+function Ke(t, e, n, r, i) {
+  const {
+    reachedAny: s,
+    removeOffset: o,
+    constrain: u
+  } = r;
+  function c(d) {
+    return d.concat().sort((g, h) => N(g) - N(h))[0];
+  }
+  function l(d) {
+    const g = t ? o(d) : u(d), h = e.map((a, S) => ({
+      diff: b(a - g, 0),
+      index: S
+    })).sort((a, S) => N(a.diff) - N(S.diff)), {
+      index: f
+    } = h[0];
+    return {
+      index: f,
+      distance: g
+    };
+  }
+  function b(d, g) {
+    const h = [d, d + n, d - n];
+    if (!t) return d;
+    if (!g) return c(h);
+    const f = h.filter((a) => Ot(a) === g);
+    return f.length ? c(f) : J(h) - n;
+  }
+  function p(d, g) {
+    const h = e[d] - i.get(), f = b(h, g);
+    return {
+      index: d,
+      distance: f
+    };
+  }
+  function m(d, g) {
+    const h = i.get() + d, {
+      index: f,
+      distance: a
+    } = l(h), S = !t && s(h);
+    if (!g || S) return {
+      index: f,
+      distance: d
+    };
+    const C = e[f] - a, L = d + b(C, 0);
+    return {
+      index: f,
+      distance: L
+    };
+  }
+  return {
+    byDistance: m,
+    byIndex: p,
+    shortcut: b
+  };
+}
+function Qe(t, e, n, r, i, s, o) {
+  function u(p) {
+    const m = p.distance, v = p.index !== e.get();
+    s.add(m), m && (r.duration() ? t.start() : (t.update(), t.render(1), t.update())), v && (n.set(e.get()), e.set(p.index), o.emit("select"));
+  }
+  function c(p, m) {
+    const v = i.byDistance(p, m);
+    u(v);
+  }
+  function l(p, m) {
+    const v = e.clone().set(p), d = i.byIndex(v.get(), m);
+    u(d);
+  }
+  return {
+    distance: c,
+    index: l
+  };
+}
+function Je(t, e, n, r, i, s, o, u) {
+  const c = {
+    passive: !0,
+    capture: !0
+  };
+  let l = 0;
+  function b(v) {
+    if (!u) return;
+    function d(g) {
+      if ((/* @__PURE__ */ new Date()).getTime() - l > 10) return;
+      o.emit("slideFocusStart"), t.scrollLeft = 0;
+      const a = n.findIndex((S) => S.includes(g));
+      kt(a) && (i.useDuration(0), r.index(a, 0), o.emit("slideFocus"));
+    }
+    s.add(document, "keydown", p, !1), e.forEach((g, h) => {
+      s.add(g, "focus", (f) => {
+        (It(u) || u(v, f)) && d(h);
+      }, c);
+    });
+  }
+  function p(v) {
+    v.code === "Tab" && (l = (/* @__PURE__ */ new Date()).getTime());
+  }
+  return {
+    init: b
+  };
+}
+function ft(t) {
+  let e = t;
+  function n() {
+    return e;
+  }
+  function r(c) {
+    e = o(c);
+  }
+  function i(c) {
+    e += o(c);
+  }
+  function s(c) {
+    e -= o(c);
+  }
+  function o(c) {
+    return kt(c) ? c : c.get();
+  }
+  return {
+    get: n,
+    set: r,
+    add: i,
+    subtract: s
+  };
+}
+function se(t, e) {
+  const n = t.scroll === "x" ? o : u, r = e.style;
+  let i = null, s = !1;
+  function o(m) {
+    return `translate3d(${m}px,0px,0px)`;
+  }
+  function u(m) {
+    return `translate3d(0px,${m}px,0px)`;
+  }
+  function c(m) {
+    if (s) return;
+    const v = Ae(t.direction(m));
+    v !== i && (r.transform = n(v), i = v);
+  }
+  function l(m) {
+    s = !m;
+  }
+  function b() {
+    s || (r.transform = "", e.getAttribute("style") || e.removeAttribute("style"));
+  }
+  return {
+    clear: b,
+    to: c,
+    toggleActive: l
+  };
+}
+function Xe(t, e, n, r, i, s, o, u, c) {
+  const b = mt(i), p = mt(i).reverse(), m = f().concat(a());
+  function v(y, I) {
+    return y.reduce((E, P) => E - i[P], I);
+  }
+  function d(y, I) {
+    return y.reduce((E, P) => v(E, I) > 0 ? E.concat([P]) : E, []);
+  }
+  function g(y) {
+    return s.map((I, E) => ({
+      start: I - r[E] + 0.5 + y,
+      end: I + e - 0.5 + y
+    }));
+  }
+  function h(y, I, E) {
+    const P = g(I);
+    return y.map((T) => {
+      const j = E ? 0 : -n, M = E ? n : 0, B = E ? "end" : "start", R = P[T][B];
+      return {
+        index: T,
+        loopPoint: R,
+        slideLocation: ft(-1),
+        translate: se(t, c[T]),
+        target: () => u.get() > R ? j : M
+      };
+    });
+  }
+  function f() {
+    const y = o[0], I = d(p, y);
+    return h(I, n, !1);
+  }
+  function a() {
+    const y = e - o[0] - 1, I = d(b, y);
+    return h(I, -n, !0);
+  }
+  function S() {
+    return m.every(({
+      index: y
+    }) => {
+      const I = b.filter((E) => E !== y);
+      return v(I, e) <= 0.1;
+    });
+  }
+  function C() {
+    m.forEach((y) => {
+      const {
+        target: I,
+        translate: E,
+        slideLocation: P
+      } = y, T = I();
+      T !== P.get() && (E.to(T), P.set(T));
+    });
+  }
+  function L() {
+    m.forEach((y) => y.translate.clear());
+  }
+  return {
+    canLoop: S,
+    clear: L,
+    loop: C,
+    loopPoints: m
+  };
+}
+function Ye(t, e, n) {
+  let r, i = !1;
+  function s(c) {
+    if (!n) return;
+    function l(b) {
+      for (const p of b)
+        if (p.type === "childList") {
+          c.reInit(), e.emit("slidesChanged");
+          break;
+        }
+    }
+    r = new MutationObserver((b) => {
+      i || (It(n) || n(c, b)) && l(b);
+    }), r.observe(t, {
+      childList: !0
+    });
+  }
+  function o() {
+    r && r.disconnect(), i = !0;
+  }
+  return {
+    init: s,
+    destroy: o
+  };
+}
+function Ze(t, e, n, r) {
+  const i = {};
+  let s = null, o = null, u, c = !1;
+  function l() {
+    u = new IntersectionObserver((d) => {
+      c || (d.forEach((g) => {
+        const h = e.indexOf(g.target);
+        i[h] = g;
+      }), s = null, o = null, n.emit("slidesInView"));
+    }, {
+      root: t.parentElement,
+      threshold: r
+    }), e.forEach((d) => u.observe(d));
+  }
+  function b() {
+    u && u.disconnect(), c = !0;
+  }
+  function p(d) {
+    return gt(i).reduce((g, h) => {
+      const f = parseInt(h), {
+        isIntersecting: a
+      } = i[f];
+      return (d && a || !d && !a) && g.push(f), g;
+    }, []);
+  }
+  function m(d = !0) {
+    if (d && s) return s;
+    if (!d && o) return o;
+    const g = p(d);
+    return d && (s = g), d || (o = g), g;
+  }
+  return {
+    init: l,
+    destroy: b,
+    get: m
+  };
+}
+function We(t, e, n, r, i, s) {
+  const {
+    measureSize: o,
+    startEdge: u,
+    endEdge: c
+  } = t, l = n[0] && i, b = d(), p = g(), m = n.map(o), v = h();
+  function d() {
+    if (!l) return 0;
+    const a = n[0];
+    return N(e[u] - a[u]);
+  }
+  function g() {
+    if (!l) return 0;
+    const a = s.getComputedStyle(J(r));
+    return parseFloat(a.getPropertyValue(`margin-${c}`));
+  }
+  function h() {
+    return n.map((a, S, C) => {
+      const L = !S, w = Ft(C, S);
+      return L ? m[S] + b : w ? m[S] + p : C[S + 1][u] - a[u];
+    }).map(N);
+  }
+  return {
+    slideSizes: m,
+    slideSizesWithGaps: v,
+    startGap: b,
+    endGap: p
+  };
+}
+function tn(t, e, n, r, i, s, o, u, c) {
+  const {
+    startEdge: l,
+    endEdge: b,
+    direction: p
+  } = t, m = kt(n);
+  function v(f, a) {
+    return mt(f).filter((S) => S % a === 0).map((S) => f.slice(S, S + a));
+  }
+  function d(f) {
+    return f.length ? mt(f).reduce((a, S, C) => {
+      const L = J(a) || 0, w = L === 0, y = S === bt(f), I = i[l] - s[L][l], E = i[l] - s[S][b], P = !r && w ? p(o) : 0, T = !r && y ? p(u) : 0, j = N(E - T - (I + P));
+      return C && j > e + c && a.push(S), y && a.push(f.length), a;
+    }, []).map((a, S, C) => {
+      const L = Math.max(C[S - 1] || 0);
+      return f.slice(L, a);
+    }) : [];
+  }
+  function g(f) {
+    return m ? v(f, n) : d(f);
+  }
+  return {
+    groupSlides: g
+  };
+}
+function en(t, e, n, r, i, s, o) {
+  const {
+    align: u,
+    axis: c,
+    direction: l,
+    startIndex: b,
+    loop: p,
+    duration: m,
+    dragFree: v,
+    dragThreshold: d,
+    inViewThreshold: g,
+    slidesToScroll: h,
+    skipSnaps: f,
+    containScroll: a,
+    watchResize: S,
+    watchSlides: C,
+    watchDrag: L,
+    watchFocus: w
+  } = s, y = 2, I = ze(), E = I.measure(e), P = n.map(I.measure), T = ke(c, l), j = T.measureSize(E), M = Ve(j), B = Ne(u, j), R = !p && !!a, q = p || !!a, {
+    slideSizes: X,
+    slideSizesWithGaps: _,
+    startGap: K,
+    endGap: ot
+  } = We(T, E, P, n, q, i), U = tn(T, j, h, p, E, P, K, ot, y), {
+    snaps: W,
+    snapsAligned: tt
+  } = qe(T, B, E, P, U), Q = -J(W) + J(_), {
+    snapsContained: rt,
+    scrollContainLimit: k
+  } = He(j, Q, tt, a, y), O = R ? rt : tt, {
+    limit: F
+  } = Ge(Q, O, p), $ = re(bt(O), b, p), H = $.clone(), A = mt(n), x = ({
+    dragHandler: at,
+    scrollBody: Et,
+    scrollBounds: Tt,
+    options: {
+      loop: vt
+    }
+  }) => {
+    vt || Tt.constrain(at.pointerDown()), Et.seek();
+  }, D = ({
+    scrollBody: at,
+    translate: Et,
+    location: Tt,
+    offsetLocation: vt,
+    previousLocation: de,
+    scrollLooper: pe,
+    slideLooper: me,
+    dragHandler: ge,
+    animation: he,
+    eventHandler: Gt,
+    scrollBounds: be,
+    options: {
+      loop: Ut
+    }
+  }, $t) => {
+    const qt = at.settled(), ve = !be.shouldConstrain(), _t = Ut ? qt : qt && ve, Kt = _t && !ge.pointerDown();
+    Kt && he.stop();
+    const Se = Tt.get() * $t + de.get() * (1 - $t);
+    vt.set(Se), Ut && (pe.loop(at.direction()), me.loop()), Et.to(vt.get()), Kt && Gt.emit("settle"), _t || Gt.emit("scroll");
+  }, z = Me(r, i, () => x(wt), (at) => D(wt, at)), G = 0.68, Y = O[$.get()], Z = ft(Y), st = ft(Y), et = ft(Y), it = ft(Y), ut = Be(Z, et, st, it, m, G), Ct = Ke(p, O, Q, F, it), Lt = Qe(z, $, H, ut, Ct, it, o), Bt = $e(F), Rt = ht(), le = Ze(e, n, o, g), {
+    slideRegistry: Ht
+  } = _e(R, a, O, k, U, A), fe = Je(t, n, Ht, Lt, ut, Rt, o, w), wt = {
+    ownerDocument: r,
+    ownerWindow: i,
+    eventHandler: o,
+    containerRect: E,
+    slideRects: P,
+    animation: z,
+    axis: T,
+    dragHandler: Oe(T, t, r, i, it, Fe(T, i), Z, z, Lt, ut, Ct, $, o, M, v, d, f, G, L),
+    eventStore: Rt,
+    percentOfView: M,
+    index: $,
+    indexPrevious: H,
+    limit: F,
+    location: Z,
+    offsetLocation: et,
+    previousLocation: st,
+    options: s,
+    resizeHandler: je(e, o, i, n, T, S, I),
+    scrollBody: ut,
+    scrollBounds: Re(F, et, it, ut, M),
+    scrollLooper: Ue(Q, F, et, [Z, et, st, it]),
+    scrollProgress: Bt,
+    scrollSnapList: O.map(Bt.get),
+    scrollSnaps: O,
+    scrollTarget: Ct,
+    scrollTo: Lt,
+    slideLooper: Xe(T, j, Q, X, _, W, O, et, n),
+    slideFocus: fe,
+    slidesHandler: Ye(e, o, C),
+    slidesInView: le,
+    slideIndexes: A,
+    slideRegistry: Ht,
+    slidesToScroll: U,
+    target: it,
+    translate: se(T, e)
+  };
+  return wt;
+}
+function nn() {
+  let t = {}, e;
+  function n(l) {
+    e = l;
+  }
+  function r(l) {
+    return t[l] || [];
+  }
+  function i(l) {
+    return r(l).forEach((b) => b(e, l)), c;
+  }
+  function s(l, b) {
+    return t[l] = r(l).concat([b]), c;
+  }
+  function o(l, b) {
+    return t[l] = r(l).filter((p) => p !== b), c;
+  }
+  function u() {
+    t = {};
+  }
+  const c = {
+    init: n,
+    emit: i,
+    off: o,
+    on: s,
+    clear: u
+  };
+  return c;
+}
+const on = {
+  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 rn(t) {
+  function e(s, o) {
+    return oe(s, o || {});
+  }
+  function n(s) {
+    const o = s.breakpoints || {}, u = gt(o).filter((c) => t.matchMedia(c).matches).map((c) => o[c]).reduce((c, l) => e(c, l), {});
+    return e(s, u);
+  }
+  function r(s) {
+    return s.map((o) => gt(o.breakpoints || {})).reduce((o, u) => o.concat(u), []).map(t.matchMedia);
+  }
+  return {
+    mergeOptions: e,
+    optionsAtMedia: n,
+    optionsMediaQueries: r
+  };
+}
+function sn(t) {
+  let e = [];
+  function n(s, o) {
+    return e = o.filter(({
+      options: u
+    }) => t.optionsAtMedia(u).active !== !1), e.forEach((u) => u.init(s, t)), o.reduce((u, c) => Object.assign(u, {
+      [c.name]: c
+    }), {});
+  }
+  function r() {
+    e = e.filter((s) => s.destroy());
+  }
+  return {
+    init: n,
+    destroy: r
+  };
+}
+function St(t, e, n) {
+  const r = t.ownerDocument, i = r.defaultView, s = rn(i), o = sn(s), u = ht(), c = nn(), {
+    mergeOptions: l,
+    optionsAtMedia: b,
+    optionsMediaQueries: p
+  } = s, {
+    on: m,
+    off: v,
+    emit: d
+  } = c, g = T;
+  let h = !1, f, a = l(on, St.globalOptions), S = l(a), C = [], L, w, y;
+  function I() {
+    const {
+      container: A,
+      slides: x
+    } = S;
+    w = (At(A) ? t.querySelector(A) : A) || t.children[0];
+    const z = At(x) ? w.querySelectorAll(x) : x;
+    y = [].slice.call(z || w.children);
+  }
+  function E(A) {
+    const x = en(t, w, y, r, i, A, c);
+    if (A.loop && !x.slideLooper.canLoop()) {
+      const D = Object.assign({}, A, {
+        loop: !1
+      });
+      return E(D);
+    }
+    return x;
+  }
+  function P(A, x) {
+    h || (a = l(a, A), S = b(a), C = x || C, I(), f = E(S), p([a, ...C.map(({
+      options: D
+    }) => D)]).forEach((D) => u.add(D, "change", T)), S.active && (f.translate.to(f.location.get()), f.animation.init(), f.slidesInView.init(), f.slideFocus.init(H), f.eventHandler.init(H), f.resizeHandler.init(H), f.slidesHandler.init(H), f.options.loop && f.slideLooper.loop(), w.offsetParent && y.length && f.dragHandler.init(H), L = o.init(H, C)));
+  }
+  function T(A, x) {
+    const D = U();
+    j(), P(l({
+      startIndex: D
+    }, A), x), c.emit("reInit");
+  }
+  function j() {
+    f.dragHandler.destroy(), f.eventStore.clear(), f.translate.clear(), f.slideLooper.clear(), f.resizeHandler.destroy(), f.slidesHandler.destroy(), f.slidesInView.destroy(), f.animation.destroy(), o.destroy(), u.clear();
+  }
+  function M() {
+    h || (h = !0, u.clear(), j(), c.emit("destroy"), c.clear());
+  }
+  function B(A, x, D) {
+    !S.active || h || (f.scrollBody.useBaseFriction().useDuration(x === !0 ? 0 : S.duration), f.scrollTo.index(A, D || 0));
+  }
+  function R(A) {
+    const x = f.index.add(1).get();
+    B(x, A, -1);
+  }
+  function q(A) {
+    const x = f.index.add(-1).get();
+    B(x, A, 1);
+  }
+  function X() {
+    return f.index.add(1).get() !== U();
+  }
+  function _() {
+    return f.index.add(-1).get() !== U();
+  }
+  function K() {
+    return f.scrollSnapList;
+  }
+  function ot() {
+    return f.scrollProgress.get(f.offsetLocation.get());
+  }
+  function U() {
+    return f.index.get();
+  }
+  function W() {
+    return f.indexPrevious.get();
+  }
+  function tt() {
+    return f.slidesInView.get();
+  }
+  function Q() {
+    return f.slidesInView.get(!1);
+  }
+  function rt() {
+    return L;
+  }
+  function k() {
+    return f;
+  }
+  function O() {
+    return t;
+  }
+  function F() {
+    return w;
+  }
+  function $() {
+    return y;
+  }
+  const H = {
+    canScrollNext: X,
+    canScrollPrev: _,
+    containerNode: F,
+    internalEngine: k,
+    destroy: M,
+    off: v,
+    on: m,
+    emit: d,
+    plugins: rt,
+    previousScrollSnap: W,
+    reInit: g,
+    rootNode: O,
+    scrollNext: R,
+    scrollPrev: q,
+    scrollProgress: ot,
+    scrollSnapList: K,
+    scrollTo: B,
+    selectedScrollSnap: U,
+    slideNodes: $,
+    slidesInView: tt,
+    slidesNotInView: Q
+  };
+  return P(e, n), setTimeout(() => c.emit("init"), 0), H;
+}
+St.globalOptions = void 0;
+function zt(t = {}, e = []) {
+  const n = Pt(t), r = Pt(e), [i, s] = nt(), [o, u] = nt(), c = lt(() => {
+    i && i.reInit(n.current, r.current);
+  }, [i]);
+  return dt(() => {
+    Mt(n.current, t) || (n.current = t, c());
+  }, [t, c]), dt(() => {
+    De(r.current, e) || (r.current = e, c());
+  }, [e, c]), dt(() => {
+    if (Te() && o) {
+      St.globalOptions = zt.globalOptions;
+      const l = St(o, n.current, r.current);
+      return s(l), () => l.destroy();
+    } else
+      s(void 0);
+  }, [o, s]), [u, i];
+}
+zt.globalOptions = void 0;
+const cn = ne(
+  "ds:relative ds:flex ds:flex-col ds:gap-[var(--spacing-md)]",
+  {
+    variants: {
+      size: {
+        sm: "ds:[--carousel-item-inline-size:14rem]",
+        md: "ds:[--carousel-item-inline-size:20rem]",
+        lg: "ds:[--carousel-item-inline-size:28rem]"
+      }
+    },
+    defaultVariants: { size: "md" }
+  }
+), an = ne(
+  [
+    "ds:shrink-0 ds:basis-[var(--carousel-item-inline-size)]",
+    "ds:min-w-0",
+    "ds:focus-visible:outline-[length:var(--focus-ring-width)] ds:focus-visible:outline-solid",
+    "ds:focus-visible:outline-ring ds:focus-visible:outline-offset-[length:var(--focus-ring-offset)]",
+    "ds:rounded-[var(--radius-md)]"
+  ].join(" ")
+), ie = Ie(null);
+function ce(t) {
+  const e = Ce(ie);
+  if (!e)
+    throw new Error(
+      `[Carousel] \`${t}\` must be rendered inside <Carousel>.`
+    );
+  return e;
+}
+function un() {
+  const [t, e] = nt(() => typeof window > "u" || !window.matchMedia ? !1 : window.matchMedia("(prefers-reduced-motion: reduce)").matches);
+  return dt(() => {
+    if (typeof window > "u" || !window.matchMedia) return;
+    const n = window.matchMedia("(prefers-reduced-motion: reduce)"), r = () => e(n.matches);
+    return n.addEventListener("change", r), () => n.removeEventListener("change", r);
+  }, []), t;
+}
+function ln(t) {
+  let e = null;
+  const n = [];
+  return te.forEach(t, (r) => {
+    ee(r) && r.type.displayName === "Carousel.Header" ? e = r : n.push(r);
+  }), { header: e, items: n };
+}
+const ae = xt(
+  ({
+    children: t,
+    size: e = "md",
+    showControls: n = !0,
+    showIndicators: r = !0,
+    viewAllSlot: i,
+    snap: s = "mandatory",
+    id: o,
+    className: u,
+    "aria-label": c,
+    ...l
+  }, b) => {
+    const { t: p } = yt(), m = un(), v = xe(), d = `${o ?? v}-track`, g = `${o ?? v}-live`, h = Qt(
+      () => ({
+        align: "start",
+        // `mandatory` → embla's default tight snap; `proximity` → free-scroll.
+        dragFree: s === "proximity",
+        // Reduced-motion disables embla's tween entirely (snap is instant).
+        duration: m ? 0 : 25,
+        // Prevents over-scroll at the ends so the last item snaps cleanly.
+        containScroll: "trimSnaps"
+      }),
+      [s, m]
+    ), [f, a] = zt(h), [S, C] = nt(0), [L, w] = nt(0), [y, I] = nt(!1), [E, P] = nt(!1), [T, j] = nt(""), M = Pt("init");
+    dt(() => {
+      if (!a) return;
+      w(a.scrollSnapList().length), C(a.selectedScrollSnap()), I(a.canScrollPrev()), P(a.canScrollNext());
+      const k = () => {
+        const H = a.selectedScrollSnap();
+        C(H), I(a.canScrollPrev()), P(a.canScrollNext()), M.current === "control" && j(
+          p("carousel.slideAnnouncement", {
+            current: H + 1,
+            total: a.scrollSnapList().length
+          })
+        );
+      }, O = () => {
+        M.current = "drag";
+      }, F = () => {
+        M.current = "init";
+      }, $ = () => {
+        w(a.scrollSnapList().length), C(a.selectedScrollSnap()), I(a.canScrollPrev()), P(a.canScrollNext());
+      };
+      return a.on("select", k), a.on("pointerDown", O), a.on("pointerUp", F), a.on("reInit", $), () => {
+        a.off("select", k), a.off("pointerDown", O), a.off("pointerUp", F), a.off("reInit", $);
+      };
+    }, [a, p]);
+    const B = lt(() => {
+      a && (M.current = "control", a.scrollPrev());
+    }, [a]), R = lt(() => {
+      a && (M.current = "control", a.scrollNext());
+    }, [a]), q = lt(
+      (k) => {
+        a && (M.current = "control", a.scrollTo(k));
+      },
+      [a]
+    ), X = lt(
+      (k) => {
+        if (a)
+          switch (k.key) {
+            case "ArrowRight":
+              k.preventDefault(), a.scrollNext(), M.current = "control";
+              break;
+            case "ArrowLeft":
+              k.preventDefault(), a.scrollPrev(), M.current = "control";
+              break;
+            case "Home":
+              k.preventDefault(), a.scrollTo(0), M.current = "control";
+              break;
+            case "End":
+              k.preventDefault(), a.scrollTo(a.scrollSnapList().length - 1), M.current = "control";
+              break;
+            case "PageDown":
+            case "PageUp": {
+              k.preventDefault();
+              const O = a.slidesInView().length || 1, F = k.key === "PageDown" ? 1 : -1, $ = Math.max(
+                0,
+                Math.min(
+                  a.selectedScrollSnap() + F * O,
+                  a.scrollSnapList().length - 1
+                )
+              );
+              a.scrollTo($), M.current = "control";
+              break;
+            }
+          }
+      },
+      [a]
+    );
+    ye(
+      b,
+      () => ({
+        scrollTo: q,
+        getActiveIndex: () => S,
+        getCount: () => L,
+        scrollPrev: B,
+        scrollNext: R
+      }),
+      [q, B, R, S, L]
+    );
+    const { header: _, items: K } = ln(t), ot = K.length, U = Math.max(L, ot), W = n && U > 1 || i != null, tt = _ == null && W, Q = r && L > 1, rt = Qt(
+      () => ({
+        api: a,
+        activeIndex: S,
+        count: L,
+        canScrollPrev: y,
+        canScrollNext: E,
+        scrollPrev: B,
+        scrollNext: R,
+        scrollToIndex: q,
+        trackId: d
+      }),
+      [
+        a,
+        S,
+        L,
+        y,
+        E,
+        B,
+        R,
+        q,
+        d
+      ]
+    );
+    return /* @__PURE__ */ V(ie.Provider, { value: rt, children: /* @__PURE__ */ Dt(
+      "section",
+      {
+        ...l,
+        "aria-label": c ?? p("carousel.label", "Carousel"),
+        "aria-roledescription": p("carousel.roleDescription", "carousel"),
+        tabIndex: 0,
+        onKeyDown: X,
+        "data-component": "carousel",
+        "data-component-id": o,
+        "data-size": e,
+        "data-state": m ? "reduced-motion" : void 0,
+        className: cn({ size: e, className: u }),
+        children: [
+          _,
+          tt ? /* @__PURE__ */ V("div", { className: "ds:flex ds:items-center ds:justify-between ds:gap-[var(--spacing-md)]", children: /* @__PURE__ */ Dt("div", { className: "ds:flex ds:items-center ds:gap-[var(--spacing-sm)] ds:ms-auto", children: [
+            i,
+            n && U > 1 ? /* @__PURE__ */ V(dn, {}) : null
+          ] }) }) : null,
+          /* @__PURE__ */ V("div", { ref: f, className: "ds:overflow-hidden", children: /* @__PURE__ */ V(
+            "div",
+            {
+              id: d,
+              role: "presentation",
+              className: "ds:flex ds:gap-[var(--spacing-md)]",
+              children: te.map(K, (k, O) => ee(k) ? /* @__PURE__ */ V(fn, { index: O, total: U, children: k }) : k)
+            }
+          ) }),
+          Q ? /* @__PURE__ */ V(pn, {}) : null,
+          /* @__PURE__ */ V(
+            "div",
+            {
+              id: g,
+              role: "status",
+              "aria-live": "polite",
+              "aria-atomic": "true",
+              className: "ds:sr-only",
+              children: T
+            }
+          )
+        ]
+      }
+    ) });
+  }
+);
+ae.displayName = "Carousel";
+const Vt = xt(
+  ({ children: t, className: e, ...n }, r) => /* @__PURE__ */ V(
+    "div",
+    {
+      ref: r,
+      ...n,
+      tabIndex: -1,
+      className: an({ className: e }),
+      children: t
+    }
+  )
+);
+Vt.displayName = "Carousel.Item";
+function fn({
+  children: t,
+  index: e,
+  total: n
+}) {
+  const { t: r } = yt(), i = t.props, s = i["aria-label"] ?? r("carousel.slideLabel", {
+    current: e + 1,
+    total: n,
+    defaultValue: "{{current}} of {{total}}"
+  }), o = {
+    ...i,
+    role: "group",
+    "aria-roledescription": r("carousel.slideRoleDescription", "slide"),
+    "aria-label": s,
+    "data-slide-index": e,
+    "data-slide-id": i.id
+  };
+  return /* @__PURE__ */ V(Vt, { ...o });
+}
+const ue = xt(
+  ({ children: t, className: e, ...n }, r) => /* @__PURE__ */ V(
+    "div",
+    {
+      ref: r,
+      ...n,
+      className: [
+        "ds:flex ds:items-center ds:justify-between ds:gap-[var(--spacing-md)]",
+        e
+      ].filter(Boolean).join(" "),
+      children: t
+    }
+  )
+);
+ue.displayName = "Carousel.Header";
+function dn() {
+  return /* @__PURE__ */ V(jt, {});
+}
+const jt = xt(({ className: t, ...e }, n) => {
+  const { t: r } = yt(), { canScrollPrev: i, canScrollNext: s, scrollPrev: o, scrollNext: u, trackId: c } = ce("Carousel.Controls");
+  return /* @__PURE__ */ Dt(
+    "div",
+    {
+      ref: n,
+      ...e,
+      className: [
+        "ds:hidden ds:md:flex ds:items-center ds:gap-[var(--spacing-2xs)]",
+        t
+      ].filter(Boolean).join(" "),
+      children: [
+        /* @__PURE__ */ V(
+          Jt,
+          {
+            size: "sm",
+            intent: "ghost",
+            flipIconInRtl: !0,
+            icon: /* @__PURE__ */ V(Le, { "aria-hidden": "true" }),
+            "aria-controls": c,
+            "aria-label": r("carousel.previous", "Previous slide"),
+            disabled: !i,
+            onClick: o
+          }
+        ),
+        /* @__PURE__ */ V(
+          Jt,
+          {
+            size: "sm",
+            intent: "ghost",
+            flipIconInRtl: !0,
+            icon: /* @__PURE__ */ V(we, { "aria-hidden": "true" }),
+            "aria-controls": c,
+            "aria-label": r("carousel.next", "Next slide"),
+            disabled: !s,
+            onClick: u
+          }
+        )
+      ]
+    }
+  );
+});
+jt.displayName = "Carousel.Controls";
+function pn() {
+  const { t } = yt(), { activeIndex: e, count: n, scrollToIndex: r, trackId: i } = ce(
+    "Carousel.Indicators"
+  );
+  return (
+    // `<div role="tablist">` with direct `<button role="tab">` children.
+    // axe's `aria-required-children` rejects `<li>` wrappers between the
+    // tablist and its tabs, and the list semantic adds nothing the
+    // tablist role doesn't already convey. Matches the WAI APG carousel
+    // pattern.
+    /* @__PURE__ */ V(
+      "div",
+      {
+        role: "tablist",
+        "aria-label": t("carousel.indicatorsLabel", "Slides"),
+        className: "ds:flex ds:items-center ds:justify-center ds:gap-[var(--spacing-2xs)]",
+        children: Array.from({ length: n }).map((s, o) => {
+          const u = o === e;
+          return /* @__PURE__ */ V(
+            "button",
+            {
+              type: "button",
+              role: "tab",
+              "aria-controls": i,
+              "aria-current": u ? "true" : void 0,
+              "aria-label": t("carousel.goToSlide", {
+                index: o + 1,
+                defaultValue: "Go to slide {{index}}"
+              }),
+              onClick: () => r(o),
+              "data-active": u ? "true" : void 0,
+              className: [
+                "ds:size-2 ds:rounded-[var(--radius-full)]",
+                "ds:transition-[background-color,inline-size] ds:duration-[var(--animation-duration)] ds:motion-reduce:transition-none",
+                "ds:focus-visible:outline-[length:var(--focus-ring-width)] ds:focus-visible:outline-solid",
+                "ds:focus-visible:outline-ring ds:focus-visible:outline-offset-[length:var(--focus-ring-offset)]",
+                u ? "ds:bg-[var(--primary)] ds:w-[length:var(--spacing-md)]" : "ds:bg-[var(--border)] ds:hover:bg-[var(--muted-foreground)]"
+              ].join(" ")
+            },
+            o
+          );
+        })
+      }
+    )
+  );
+}
+const yn = Object.assign(ae, {
+  Header: ue,
+  Item: Vt,
+  Controls: jt
+}), In = {
+  id: "carousel",
+  capabilities: ["navigate", "view_change"],
+  state: {
+    activeIndex: {
+      type: "number",
+      description: "Zero-based index of the currently snapped slide.",
+      read: (t) => t.getActiveIndex()
+    },
+    count: {
+      type: "number",
+      description: "Total slide count.",
+      read: (t) => t.getCount()
+    }
+  },
+  actions: {
+    scroll_to: {
+      safety: "read",
+      argsType: "{ index: number }",
+      description: "Scroll to the slide at the given index.",
+      invoke: (t, e) => {
+        t.scrollTo(e.index);
+      }
+    },
+    scroll_prev: {
+      safety: "read",
+      description: "Scroll to the previous slide.",
+      invoke: (t) => {
+        t.scrollPrev();
+      }
+    },
+    scroll_next: {
+      safety: "read",
+      description: "Scroll to the next slide.",
+      invoke: (t) => {
+        t.scrollNext();
+      }
+    }
+  },
+  domHooks: {
+    root: { attr: "data-component", value: "carousel" },
+    instanceId: {
+      attr: "data-component-id",
+      sourceProp: "id",
+      description: "Sourced from the id prop on Carousel."
+    },
+    item: {
+      attr: "data-slide-id",
+      description: "Each Carousel.Item emits its `id` prop as `data-slide-id`. `data-slide-index` carries the zero-based position alongside."
+    }
+  }
+};
+export {
+  yn as C,
+  In as c
+};
+//# sourceMappingURL=carousel.agent-OTn-kMQg.js.map